📚 PubMed Tool

What it does: Takes a PubMed search query string, calls the NCBI E-utilities API (esearch + efetch), and returns a JSON array of literature records with full metadata including abstracts. This is the core tool for automated literature retrieval.

Configuration Parameters:

• API Key: Optional. Without key: 3 requests/second limit. With key: 10 requests/second. Get free key from NCBI.
• Email: Required by NCBI policy. Used for rate limit identification.
• Max Results: Maximum number of articles to retrieve (default: 20).
• Include Abstracts: Whether to fetch full abstracts (slower) or just metadata (faster).
• Citation Format: Format for the Citation field (e.g., "Author et al. Journal. Year").

📥 INPUT FORMAT:

Plain text string containing a valid PubMed search query. Can be simple keywords or complex boolean queries with field tags.

📤 OUTPUT FORMAT:

JSON array of article objects. Each object contains standardized fields. Empty fields are included as empty strings.

[
  {
    "PMID": "38847563",
    "Title": "CAR-T cell therapy for solid tumors: current status and future directions",
    "Authors": ["Zhang Y", "Wang X", "Liu H", "Chen J"],
    "Journal": "Journal of Hematology & Oncology",
    "Year": "2024",
    "DOI": "10.1186/s13045-024-01547-8",
    "Citation": "Zhang Y et al. J Hematol Oncol. 2024",
    "Abstract": "Chimeric antigen receptor T-cell (CAR-T) therapy has revolutionized..."
  },
  {
    "PMID": "38652341",
    "Title": "Overcoming barriers in CAR-T therapy for solid malignancies",
    "Authors": ["Smith A", "Johnson B"],
    "Journal": "Nature Reviews Cancer",
    "Year": "2024",
    "DOI": "10.1038/s41568-024-00678-1",
    "Citation": "Smith A et al. Nat Rev Cancer. 2024",
    "Abstract": "Despite remarkable success in hematological malignancies..."
  }
]

💡 Typical Workflow: PubMed Search Agent (generates optimized query) → PubMed Tool (fetches results) → Iteration Tool (processes each paper) → AI Agent (analyzes/summarizes)

🏥 PMC Tool

What it does: Similar to PubMed Tool, but retrieves from PubMed Central (PMC) which contains full-text open-access articles. While PubMed only has abstracts, PMC provides complete article text including Introduction, Methods, Results, and Discussion sections.

Key Difference from PubMed Tool:

• PubMed: ~35 million articles, abstracts only
• PMC: ~8 million articles, full text available, but only open-access content

📥 INPUT FORMAT:

📤 OUTPUT FORMAT:

[
  {
    "PMCID": "PMC7654321",
    "PMID": "33245678",
    "Title": "Full-text article title here",
    "Authors": ["Author A", "Author B"],
    "Journal": "PLoS ONE",
    "Year": "2023",
    "FullText": {
      "Introduction": "Background information and study objectives...",
      "Methods": "Study design, participants, and analysis methods...",
      "Results": "Main findings with statistical data...",
      "Discussion": "Interpretation of results and implications..."
    }
  }
]

⚠️ Limitation: Only open-access articles are available. Paywalled content cannot be retrieved through PMC API.

🌐 HTTP Request

What it does: Sends HTTP requests (GET, POST, PUT, DELETE) to any external API endpoint. The key feature is automatic URL extraction: if the previous node (typically a Search Agent) outputs text containing a URL, this tool will automatically find and call that URL.

Configuration Parameters:

• Static URL: Optional fixed URL. If empty, tool extracts URL from previous node's output.
• HTTP Method: GET (default), POST, PUT, or DELETE.
• Headers: JSON object for custom headers, e.g., {"Authorization": "Bearer xxx"}
• Body: Request body for POST/PUT requests (JSON or plain text).

📥 INPUT FORMAT:

Either a direct URL string, or text containing a URL (tool uses regex to extract first http/https URL found).

📤 OUTPUT FORMAT:

The raw API response (usually JSON). Format depends entirely on the external API being called.

{
  "messages": [
    {
      "status": "ok",
      "count": 150,
      "total": 2847
    }
  ],
  "collection": [
    {
      "doi": "10.1101/2024.05.15.594356",
      "title": "Novel findings in cancer research",
      "authors": "Smith, J.; Jones, M.",
      "date": "2024-05-15",
      "category": "cancer biology"
    }
  ]
}

💡 Common Use: Chain with bioRxiv/ClinicalTrials/cBioPortal Search Agents that output API URLs. The HTTP Request tool auto-fetches the data.

🔧 Variable Extraction

What it does: Splits a delimited text string into a JSON array of individual items. For example, if an AI outputs "apple | banana | cherry", this tool converts it to ["apple", "banana", "cherry"]. Essential for preparing data for iteration.

Configuration Parameters:

• Separator: auto (smart detection), pipe (|), comma (,), semicolon (;), newline (\n), tab (\t), space, or custom string.
• Auto mode: Tries to detect the most likely separator based on text analysis.

📥 INPUT FORMAT:

Plain text with values separated by a delimiter. Whitespace around values is automatically trimmed.

📤 OUTPUT FORMAT:

Clean JSON array of strings. Ready for iteration or further processing.

💡 Use Case: AI generates a list of search terms → Variable Extraction splits them → Iteration Tool processes each term through PubMed Tool.

🔍 JSON Extraction

What it does: Extracts valid JSON from text that may contain other content. AI models often wrap JSON in markdown code blocks (```json ... ```) or add explanatory text before/after. This tool finds and extracts the pure JSON.

How it works:

1. First tries to find ```json ... ``` code blocks
2. If not found, looks for JSON starting with [ or { characters
3. Validates and parses the extracted JSON
4. Returns pure JSON without surrounding text

📥 INPUT FORMAT:

Any text containing JSON. The JSON can be wrapped in code blocks or mixed with explanatory text.

📤 OUTPUT FORMAT:

Pure JSON array or object, stripped of all surrounding text and code block markers.

[
  {"entity": "BRCA1", "type": "gene", "confidence": 0.95},
  {"entity": "breast cancer", "type": "disease", "confidence": 0.92}
]

📦 JSON Parse

What it does: Handles "double-encoded" JSON — arrays where each element is itself a JSON string that needs parsing. This commonly happens with Iteration Tool output, where each iteration returns a JSON string, resulting in an array of strings rather than an array of objects.

Configuration Parameters:

• Flatten: If true, nested arrays are flattened into a single array.
• Ignore Errors: If true, malformed items are skipped rather than failing the whole operation.

📥 INPUT FORMAT:

JSON array where elements are stringified JSON (escaped quotes, etc.).

[
  "[{\"PMID\": \"123\", \"Title\": \"Paper A\"}]",
  "[{\"PMID\": \"456\", \"Title\": \"Paper B\"}, {\"PMID\": \"789\", \"Title\": \"Paper C\"}]"
]

📤 OUTPUT FORMAT:

With Flatten=true: Single flat array of all objects.

[
  {"PMID": "123", "Title": "Paper A"},
  {"PMID": "456", "Title": "Paper B"},
  {"PMID": "789", "Title": "Paper C"}
]

🧬 JSON Parse PubMed

What it does: Specialized processor for PubMed results. Key features: (1) Select which fields to keep (PMID, Title, Abstract, etc.), (2) Deduplicate papers across multiple search results by PMID, (3) Handle nested array structures from multi-term searches.

Configuration Parameters:

• Fields to include: Checkboxes for PMID, Title, Abstract, Authors, Journal, Year, DOI, Citation.
• Enable deduplication: Remove duplicate papers (same PMID) across groups.

📥 INPUT FORMAT:

Nested array from Iteration Tool processing multiple search terms. Each element is a JSON string containing search results.

[
  "[{\"PMID\":\"111\",\"Title\":\"Paper A\",\"Abstract\":\"...\",\"Authors\":[...],\"Journal\":\"...\"}]",
  "[{\"PMID\":\"111\",\"Title\":\"Paper A\",\"Abstract\":\"...\"},{\"PMID\":\"222\",\"Title\":\"Paper B\",\"Abstract\":\"...\"}]"
]

📤 OUTPUT FORMAT:

With fields=[PMID, Title, Abstract] and dedup=true:

[
  "[{\"PMID\":\"111\",\"Title\":\"Paper A\",\"Abstract\":\"...\"}]",
  "[{\"PMID\":\"222\",\"Title\":\"Paper B\",\"Abstract\":\"...\"}]"
]

🔎 JSON Filter

What it does: Filters a JSON array based on keyword matching. You specify keywords and a mode (include or exclude), and the tool keeps or removes array elements that contain those keywords in any field.

Configuration Parameters:

• Filter Mode: "include" (keep matching) or "exclude" (remove matching).
• Keywords: Comma-separated list of keywords to match.
• Match Logic: "or" (match any keyword) or "and" (match all keywords).
• Case Sensitive: Whether matching is case-sensitive.

📥 INPUT FORMAT:

[
  {"PMID": "111", "Title": "CAR-T therapy in solid tumors", "Abstract": "...immunotherapy..."},
  {"PMID": "222", "Title": "Heart disease treatment", "Abstract": "...cardiovascular..."},
  {"PMID": "333", "Title": "Cancer immunotherapy advances", "Abstract": "...CAR-T..."},
  {"PMID": "444", "Title": "Diabetes management", "Abstract": "...insulin..."}
]

📤 OUTPUT FORMAT:

With mode="include", keywords="CAR-T, immunotherapy", logic="or":

[
  {"PMID": "111", "Title": "CAR-T therapy in solid tumors", "Abstract": "...immunotherapy..."},
  {"PMID": "333", "Title": "Cancer immunotherapy advances", "Abstract": "...CAR-T..."}
]

🔗 JSON Array Concat

What it does: Extracts a specific field from each object in a JSON array and concatenates the values into a single text string. Useful for combining all abstracts, titles, or other text fields into one block for AI processing.

Configuration Parameters:

• Field Name: The field to extract from each object (e.g., "Abstract", "Title").
• Separator: String to insert between values. Default: "\n\n" (double newline). Use "\n" for single newline, ", " for comma-separated, etc.

📥 INPUT FORMAT:

[
  {"PMID": "111", "Title": "Paper A", "Abstract": "This study investigates CAR-T therapy mechanisms..."},
  {"PMID": "222", "Title": "Paper B", "Abstract": "We present novel findings on tumor resistance..."},
  {"PMID": "333", "Title": "Paper C", "Abstract": "Clinical outcomes of immunotherapy in melanoma..."}
]

📤 OUTPUT FORMAT:

With field="Abstract", separator="\n\n":

"This study investigates CAR-T therapy mechanisms...

We present novel findings on tumor resistance...

Clinical outcomes of immunotherapy in melanoma..."

🔗 Node String Concat

What it does: Combines the outputs from multiple previous workflow nodes into a single string. Unlike JSON Array Concat (which works on array elements), this tool works on different nodes' outputs. Use this when you need to merge results from parallel processing branches.

Configuration Parameters:

• Source Nodes: Checkboxes to select which previous nodes' outputs to include.
• Separator: String between outputs. Default: "\n\n".

📥 INPUT (Conceptual):

Imagine a workflow where Node 1, Node 2, and Node 3 each produce different research outputs:

📤 OUTPUT FORMAT:

With all 3 nodes selected, separator="\n\n":

"# Background
Recent advances in CAR-T therapy have opened new possibilities...

# Key Findings
Analysis of 50 papers reveals three major trends...

# Research Gaps
Several areas remain unexplored including..."

⚠️ Important: You MUST click the "SAVE" button after selecting source nodes. If you don't save, the configuration won't persist and the tool will fail with "No source nodes configured" error.

📚 Citation Converter

What it does: Converts PMID-style inline citations [12345678] to numbered format [1], [2], [3] and generates a properly formatted reference list at the end. Essential for producing well-cited research reports and knowledge synthesis documents.

Configuration Parameters:

• Text Source Node: Select the node containing the document with [PMID] citations.
• Citation Source Node: Select the node containing PubMed JSON data (for looking up citation info).

📥 INPUT (Two Sources):

"Recent studies have shown that CAR-T therapy is effective [38847563]. 
The mechanism involves T-cell activation [38652341]. 
Multiple clinical trials have confirmed these findings [38847563][38652341]."

[
  {"PMID": "38847563", "Citation": "Zhang Y et al. J Hematol Oncol. 2024", ...},
  {"PMID": "38652341", "Citation": "Smith A et al. Nat Rev Cancer. 2024", ...}
]

📤 OUTPUT FORMAT:

"Recent studies have shown that CAR-T therapy is effective [1]. 
The mechanism involves T-cell activation [2]. 
Multiple clinical trials have confirmed these findings [1][2].

[1] Zhang Y et al. J Hematol Oncol. 2024
[2] Smith A et al. Nat Rev Cancer. 2024"

🗑️ PMID Exclude

What it does: Removes papers from a JSON array that have already been cited in a reference text. Use this in multi-stage research workflows where each stage should analyze different papers to avoid redundancy. The tool detects [PMID] patterns in the reference text and filters matching papers from the source array.

Configuration Parameters:

• Source Array Node: Node containing JSON array of papers to filter.
• Reference Node: Node containing text with [PMID] citations to exclude.

📥 INPUT (Two Sources):

[
  {"PMID": "111", "Title": "Paper A", "Abstract": "..."},
  {"PMID": "222", "Title": "Paper B", "Abstract": "..."},
  {"PMID": "333", "Title": "Paper C", "Abstract": "..."},
  {"PMID": "444", "Title": "Paper D", "Abstract": "..."}
]

"In Phase 1, we analyzed findings from [111] and [333]. These studies show..."

📤 OUTPUT FORMAT:

[
  {"PMID": "222", "Title": "Paper B", "Abstract": "..."},
  {"PMID": "444", "Title": "Paper D", "Abstract": "..."}
]

🔄 Iteration Tool

What it does: The most powerful tool in BioForge. Takes a JSON array and processes each element through a target AI/Tool node, one by one. Think of it as a "for-each loop" for workflow nodes. Each iteration passes one array element to the target node, collects the response, and continues to the next element.

Two Modes:

• Single Array Mode: Iterate over one array. Each element processed independently.
• Multi-Array Sync Mode: Iterate over multiple arrays in parallel. Element[0] from all arrays processed together, then element[1], etc.

Configuration Parameters:

• Mode: single or sync.
• Source Nodes: Which nodes provide the array(s) to iterate over.
• Target Node: The AI/Tool node to call for each iteration.
• Fixed Nodes: Optional. Context that stays constant across all iterations (e.g., instructions).

📥 INPUT FORMAT (Single Mode):

[
  {"PMID": "111", "Title": "Paper A", "Abstract": "Study on CAR-T efficacy..."},
  {"PMID": "222", "Title": "Paper B", "Abstract": "Clinical trial results..."},
  {"PMID": "333", "Title": "Paper C", "Abstract": "Mechanism analysis..."}
]

📤 OUTPUT FORMAT:

Array of AI responses, one per iteration:

[
  "This study [111] demonstrated CAR-T efficacy in solid tumors with 60% response rate...",
  "Clinical trial [222] showed improved survival in patients treated with combination therapy...",
  "Paper [333] revealed the molecular mechanism underlying T-cell exhaustion..."
]

📥 INPUT FORMAT (Sync Mode):

Two source arrays processed in parallel:

🔄🔄 Nested Iteration Tool

What it does: Two-level iteration for hierarchical data. The outer loop iterates over groups, the inner loop iterates over items within each group. Output preserves the group structure. Use this when you have grouped data (e.g., papers grouped by search term) and need to process each paper while maintaining group boundaries.

📥 INPUT FORMAT:

Array of arrays (groups of items):

[
  ["{paper1 from search term 1}", "{paper2 from search term 1}"],
  ["{paper3 from search term 2}"],
  ["{paper4 from search term 3}", "{paper5 from search term 3}", "{paper6 from search term 3}"]
]

📤 OUTPUT FORMAT:

[
  ["AI response for paper1", "AI response for paper2"],
  ["AI response for paper3"],
  ["AI response for paper4", "AI response for paper5", "AI response for paper6"]
]

🔄 PubMed Iteration Tool

What it does: Specialized iteration tool designed for PubMed-based deep research workflows. Key feature: built-in reference exclusion. Before iterating, it removes papers that are already cited in a reference text, preventing redundant analysis across research stages.

Essentially combines PMID Exclude + Iteration Tool functionality in one step.

🕐 Current Time

What it does: Returns current date/time in multiple formats. Standalone tool that doesn't require input from previous nodes. Useful for timestamping outputs or calculating date ranges for searches.

📤 OUTPUT FORMAT:

🕐 Current Time Information
━━━━━━━━━━━━━━━━━━━━━━━━━━

🏠 Timezone: Local System Time

📅 ISO 8601 Format:
2024-12-04T15:30:45.123Z

🌍 Local Time:
12/04/2024, 3:30:45 PM

⏱️ Unix Timestamp:
1733326245123

📖 Human Readable:
Wednesday, December 04, 2024, 3:30:45 PM

🌐 UTC Time:
Wed, 04 Dec 2024 15:30:45 GMT

━━━━━━━━━━━━━━━━━━━━━━━━━━

🔬 PubMed Search Agent

Generates precise PubMed API search queries from natural language. Automatically excludes review articles, applies appropriate filters (humans, English, date ranges), and uses correct MeSH terms. Perfect for literature retrieval when writing reviews.

🧬 bioRxiv/medRxiv Search Agent

Converts natural language queries into bioRxiv and medRxiv API request URLs. Supports category filtering, date range queries, pagination, and DOI lookups. Automatically calculates date ranges and uses correct URL formats. Features auto-execute HTTP to immediately fetch results.

💊 ClinicalTrials.gov Search Agent

Expert in generating ClinicalTrials.gov API v2 URLs for finding clinical trials. Supports queries by condition, intervention, phase, and status. Defaults to showing trials from the last 3 years with all statuses (including valuable completed trials with results). Features auto-execute HTTP.

🧬 cBioPortal API Agent

Converts natural language queries into cBioPortal HTTP API requests for cancer genomics data. Supports queries for mutations, expression data, clinical data, and molecular profiles from TCGA and MSK-IMPACT studies. Features auto-execute HTTP.

🧬 GEO DataSets Search Agent

Generates NCBI E-utilities API queries for searching gene expression datasets. Supports organism filtering, platform specification, and dataset type selection. Ideal for finding microarray and RNA-seq datasets for specific research topics.

🔬 Refiner Agent

Expert biomedical literature analyst that extracts core findings from abstracts. First judges relevance to your research query, then summarizes key results with PMID citations. Outputs "It_is_Irrelevant_Research[PMID]" for off-topic papers, saving you time on irrelevant literature.

🔭 Perspective Agent

Specializes in writing "Conclusion and Perspective" sections for biomedical reviews. Integrates research summary, key insights, current limitations, and future directions into 1-2 well-structured paragraphs (400-500 words) with appropriate emphasis on forward-looking analysis.

📝 Summary Agent

Creates concise, information-dense abstracts for biomedical reviews. Produces 200-300 word summaries covering background, scope, key findings, and conclusions in continuous paragraph form, plus 5 relevant keywords. Follows international journal standards.

📄 Report Agent

Generates structured review chapter content with proper PMID citations [12345678]. Takes main chapter titles, subsection lists, and literature collections as input. Produces publication-grade content with logical argumentation, proper citation format, and 70-80% literature coverage.

✨ Enhance Report Agent

Incrementally improves existing review content by integrating unused literature. Follows an "add-only" principle—polishes and expands content without deleting or changing original meaning. Also fixes duplicate consecutive citations and maintains scientific data integrity.

🔌 API Provider

The API provider determines which AI service platform your agent will connect to. You must first configure API keys in the ⚙️ API Config section before they appear here. Common providers include:

• DeepSeek: Cost-effective Chinese AI provider with strong performance. Recommended for most text tasks.
• OpenAI: Provider of GPT-4, GPT-4o models. Industry standard with broad capabilities.
• Anthropic: Provider of Claude models. Excellent for complex reasoning and long-context tasks.
• Google (Gemini): Provider of Gemini models. Required for image generation features.
• Alibaba (Qwen): Provider of Qwen models. Strong Chinese language support.
• SiliconFlow: Aggregator platform hosting multiple models. Recommended for Embedding and Rerank.

💡 Tip: Configure multiple APIs to have backup options. Each provider has different pricing and rate limits.

🤖 Built-in Models

BioForge supports multiple model types for different use cases. You can either select from the dropdown list or type any custom model name directly in the input field (useful for newly released models not yet in the list).

💡 The model input supports both selection and free text input — just type your custom model name if it's not in the list.

💬 Chat Models (Text Conversation)

• DeepSeek: deepseek-chat (general purpose, fast), deepseek-reasoner (complex reasoning)
• OpenAI: gpt-5 / gpt-5-mini / gpt-5-nano (latest), gpt-4.1 / gpt-4.1-mini (balanced), gpt-4o / gpt-4o-mini (legacy), o3 / o3-mini / o4-mini (reasoning)
• Claude: claude-opus-4-5-20251101 (highest quality), claude-sonnet-4-5-20250929 (balanced), claude-haiku-4-5-20251001 (fast), claude-sonnet-4-20250514, claude-opus-4-20250514
• Gemini: gemini-2.5-flash / gemini-2.5-pro (recommended), gemini-2.0-flash, gemini-2.5-flash-lite / gemini-2.0-flash-lite (lightweight), gemini-3-pro-preview / gemini-2.0-pro-exp (experimental)
• Qwen: qwen3-max (highest quality), qwen-plus (balanced), qwen-turbo / qwen-long (fast), qwq-plus / qwq-32b (reasoning), qwen3-coder-plus / qwen3-coder-flash (coding), qwen3-vl-plus / qwen3-vl-max (vision)
• SiliconFlow: deepseek-ai/DeepSeek-R1 / DeepSeek-V3.1-Terminus, Qwen/Qwen3-235B-A22B / Qwen3-32B / Qwen3-14B / Qwen3-8B, moonshotai/Kimi-K2-Thinking / Kimi-K2-Instruct-0905, zai-org/GLM-4.6 / GLM-4.5, MiniMaxAI/MiniMax-M1-80k

🎨 Image Generation Models

• Gemini: gemini-2.5-flash-image (fast, versatile), gemini-3-pro-image-preview (high quality preview)
• SiliconFlow: black-forest-labs/FLUX.1-dev (high quality), black-forest-labs/FLUX.1-schnell (fast), stabilityai/stable-diffusion-3-medium (balanced)
• OpenAI: gpt-image-1 (latest), dall-e-3 (creative, artistic)
• Qwen: wanx-v1 (Alibaba image generation)

📚 Embedding Models (Vector Database)

• SiliconFlow (Recommended): Qwen/Qwen3-Embedding-8B / 4B / 0.6B (latest), BAAI/bge-m3 (multilingual), BAAI/bge-large-en-v1.5 (English)
• OpenAI: text-embedding-3-large (highest quality), text-embedding-3-small (fast)
• Gemini: gemini-embedding-001 (stable), gemini-embedding-exp (experimental)
• Qwen: text-embedding-v3
• DeepSeek: deepseek-embedding

🎯 Rerank Models (Search Optimization)

• SiliconFlow (Recommended): Qwen/Qwen3-Reranker-8B / 4B (latest Qwen reranker), BAAI/bge-reranker-v2-m3 (multilingual, reliable)

💡 Tip: For database search agents, use deepseek-chat with low temperature (0.3). For writing, use claude-sonnet-4-5 or gpt-4.1. For RAG, use SiliconFlow's embedding + rerank combo.

🌡️ Temperature (0.0 - 2.0)

Controls the randomness/creativity of AI responses. Think of it as a "creativity dial":

• Low (0.0 - 0.3): More deterministic and focused. The AI gives consistent, predictable answers. Best for database queries, code generation, and factual tasks where you need the same result every time.
• Medium (0.4 - 0.7): Balanced creativity and coherence. Good for most writing tasks, summaries, and analysis where you want some variety but still reliable outputs.
• High (0.8 - 1.2): More creative and diverse outputs. The AI explores more possibilities. Use for brainstorming, creative writing, or when you want varied responses.
• Very High (1.3 - 2.0): Maximum randomness. Can produce unexpected or incoherent results. Rarely recommended for practical tasks.

💡 Default: 0.7 for writing agents, 0.3 for search/database agents.

🧠 Enable Memory

When enabled, the agent remembers previous messages in the conversation:

• ON: The agent maintains context across multiple messages. Use for interactive conversations where follow-up questions reference earlier content (e.g., "Can you explain that more?" or "Now do the same for cancer").
• OFF: Each message is processed independently with no memory of previous exchanges. Use for batch processing or when each query should be handled fresh without context.

💡 Memory is typically OFF for database search agents (each query is independent) and ON for conversational assistants.

💾 Vector Database Integration (RAG)

Connect the agent to one or more Vector Databases to enable RAG (Retrieval-Augmented Generation). This allows the AI to answer questions based on your own documents.

What is Embedding?

Embedding is the process of converting text into numerical vectors (arrays of numbers) that capture semantic meaning. Similar texts have similar vectors, allowing the system to find relevant content even without exact keyword matches. For example, "heart attack" and "myocardial infarction" would have similar embeddings despite using different words.

💡 Recommended Embedding API: SiliconFlow (BAAI/bge-large-zh-v1.5 for Chinese, BAAI/bge-large-en-v1.5 for English)

What is Rerank?

Rerank is a second-stage retrieval optimization. After initial embedding search returns candidate results, the Rerank model re-scores each result by directly comparing the query against each document. This significantly improves accuracy because Rerank models understand context better than simple vector similarity. It's like having a human double-check which search results are actually relevant.

💡 Recommended Rerank API: SiliconFlow (BAAI/bge-reranker-v2-m3)

Configuration Options:

• Vector DB IDs: Select which databases to search when the agent receives a query. You can select multiple databases.
• Top-K: Number of most relevant chunks to retrieve from the database. Higher values return more context but may include less relevant content. Typical range: 3-10.
• Use Rerank: Enable reranking to improve retrieval accuracy. Adds latency but significantly improves result quality. Requires a Rerank API configured in API Config.

🖼️ Image Generation Settings (for Image Nodes only)

• API: Select an API that supports image generation (Gemini, SiliconFlow, OpenAI, or Qwen).
• Model: Choose based on your API: Gemini (gemini-2.5-flash-image), SiliconFlow (FLUX.1-dev/schnell), OpenAI (gpt-image-1, dall-e-3), or Qwen (wanx-v1).
• Image Size: Output dimensions (e.g., 1024x1024, 768x1024). Larger sizes may take longer to generate.

📡 Genes & Diseases Knowledge Base

What it contains: This is a comprehensive literature database containing 1,076,052 articles related to gene-disease associations. The database has been processed and indexed for semantic search, enabling rapid retrieval of relevant literature based on natural language queries.

Use Cases:

• Finding literature on specific gene-disease relationships (e.g., "BRCA1 mutations in breast cancer")
• Discovering research on disease mechanisms and therapeutic targets
• Literature review for understanding genetic basis of diseases
• Identifying research gaps in gene-disease associations

💡 Tip: Use with AI Agents that have RAG enabled to get AI-generated summaries grounded in the literature.

📡 Cell Marker Knowledge Base

What it contains: This database is derived from the ACT (Automatic Cell Type annotation) system, which was developed based on structural marker maps and cell type enrichment algorithms. It facilitates efficient cell type annotation for single-cell RNA sequencing (scRNA-seq) analysis.

Key Features:

• Cell Type Enrichment: Core tool for annotating cell types based on marker expression
• Hierarchy Mapping: Well-organized hierarchy map of enriched cell types
• Marker-Gene Mapping: Relationship between canonical markers and differentially up-regulated genes
• Multi-organ Coverage: Integrative scRNA-seq expression data for human and mouse across multiple organs
• Canonical Marker Prevalence: Visualization of marker expression patterns

Use Cases:

• Annotating unknown cell clusters from scRNA-seq data
• Finding canonical markers for specific cell types
• Understanding cell type composition in tissues
• Cross-referencing marker genes across human and mouse studies

💡 Tip: Combine with the Genes & Diseases database for comprehensive research on cell type-specific disease mechanisms.

⚙️ Search Configuration

Top K (Initial Retrieval)

Number of documents to retrieve from the remote database before any local processing. Range: 1-500, Default: 20.

• Lower values (5-10): Faster, but may miss relevant documents
• Medium values (20-50): Good balance, recommended when reranking is enabled
• Higher values (100-500): More comprehensive retrieval, use when you need thorough coverage

💡 When local reranking is enabled, set this higher (50-100) to give the reranker more candidates to work with.

Search Method

Determines how the database searches for relevant documents:

• Hybrid Search (Recommended): Combines keyword matching and semantic similarity. Best overall results for most queries. Uses both exact term matches and meaning-based retrieval.
• Semantic Search Only: Uses vector similarity exclusively. Good for conceptual queries where exact terms may not appear (e.g., finding papers about "cell death" when searching for "apoptosis").
• Keyword Search Only: Traditional text matching. Use when you need exact phrase matches or specific terminology (e.g., gene names, drug names).

🎯 Local Reranking

What is Reranking? After the initial search returns candidate documents, reranking uses a specialized AI model to re-evaluate each result against your query. This significantly improves accuracy by considering deeper semantic relationships that simple vector similarity might miss.

Enable Local Reranking

Toggle to enable/disable local reranking of results. When enabled, you'll need to configure the reranking API and model.

Rerank API Configuration

Select an API that supports reranking models. You must first configure this API in ⚙️ API Config.

💡 Recommended: SiliconFlow (supports multiple reranking models at low cost)

Rerank Model

Choose the reranking model to use:

• Qwen/Qwen3-Reranker-8B: Latest Qwen reranker, highest quality
• Qwen/Qwen3-Reranker-4B: Balanced quality and speed
• BAAI/bge-reranker-v2-m3: Excellent multilingual support, reliable
• netease-youdao/bce-reranker-base_v1: Good for Chinese content
• Custom: Enter any model name supported by your API

Final Results Count

Number of top documents to return after reranking. Range: 1-500, Default: 5.

This should typically be lower than your initial Top K. For example, retrieve 50 documents initially, then rerank to return the top 5 most relevant.

Score Threshold

Minimum similarity score for returned documents. Range: 0-1, Default: 0 (no filtering).

• 0: Return all results (no filtering)
• 0.3-0.5: Filter out loosely related documents
• 0.6-0.8: Only highly relevant documents
• 0.9+: Very strict, may miss relevant content

💡 Start with 0, then gradually increase if you're getting too many irrelevant results.

📋 Database Information

Database Name

A descriptive name for your database. Examples: "PubMed LitForge", "My Cancer Research", "Lab Meeting Notes".

Description (Optional)

A brief description of what this database contains and its intended use.

🔌 Embedding Configuration

API Configuration

Select an API that supports embedding models. You must first configure this API in ⚙️ API Config.

💡 Recommended: SiliconFlow (offers free tier and supports multiple embedding models)

Embedding Model

The model that converts text into vectors. Choose based on your content:

• Qwen/Qwen3-Embedding-8B: Latest Qwen embedding, best quality
• Qwen/Qwen3-Embedding-4B: Good quality with faster speed
• BAAI/bge-m3: Excellent multilingual support (English + Chinese + more)
• BAAI/bge-large-en-v1.5: High quality for English-only content
• text-embedding-3-large (OpenAI): OpenAI's highest quality embedding
• text-embedding-3-small (OpenAI): Faster, lower cost option

⚠️ Important: Once created, you cannot change the embedding model. All documents must use the same model for consistent retrieval.

📄 Document Upload

Supported Formats: .txt files (plain text)

Click the upload area to select files. You can upload multiple files at once. Each file will be processed, chunked, and embedded according to your settings.

💡 Tip: For best results, pre-process your documents to remove headers, footers, and irrelevant content before uploading.

✂️ Text Chunking Settings

Why Chunking? Long documents need to be split into smaller pieces (chunks) for effective retrieval. Too large, and the AI can't focus on the relevant part. Too small, and context is lost. Finding the right balance is key.

Chunk Size (characters)

Maximum number of characters per chunk. Range: 100-20000, Default: 10000.

• Small (200-500): More precise retrieval, but loses context. Good for keyword-heavy content.
• Medium (800-1500): Balanced approach. ⭐ Recommended for most biomedical literature.
• Large (2000-4000): More context preserved. Good for Q&A tasks where full paragraphs are needed.
• Very Large (5000-10000): Use for long-form content where sections need to stay together.

Chunk Overlap (characters)

Number of characters shared between consecutive chunks. Range: 0-500, Default: 100.

Overlap prevents information loss at chunk boundaries. If a concept spans two chunks, the overlap ensures both chunks capture part of it.

• 0: No overlap. Clean splits, but may break sentences/concepts.
• 10-20% of chunk size: ⭐ Recommended. Provides redundancy without too much duplication.
• Higher values: More redundancy, but increases database size and retrieval noise.

Split Delimiter

Character sequence used to split text before chunk size is applied. Default: \n\n (double newline, splits by paragraphs).

• \n\n: Split by paragraphs (default). Best for most documents.
• \n: Split by single lines. Use for line-by-line content.
• ###: Split by section markers. Use if your documents have custom section delimiters.
• Custom: Any string that marks logical boundaries in your content.

💡 How it works: Text is first split by the delimiter, then each segment is further split if it exceeds the chunk size.

💾 RAG Configuration (in Agent Nodes)

Vector DB Selection

Select which databases to search when the agent receives a query. You can select multiple databases — results will be combined from all selected sources.

Top-K

Number of most relevant chunks to retrieve and include in the AI's context. Typical range: 3-10.

• Lower values (3-5): More focused context, less noise, faster responses
• Higher values (8-15): More comprehensive context, but may include less relevant content

💡 Start with 5 and adjust based on response quality. Too few = missing information; too many = diluted focus.

Use Rerank

Enable reranking to improve retrieval accuracy. When enabled, initial results are re-evaluated and reordered by a specialized reranking model.

• ON: Better accuracy, but adds latency. Requires a Rerank API configured in API Config.
• OFF: Faster responses, relies on vector similarity alone.

💡 Recommended: Enable reranking for important research tasks where accuracy matters more than speed.

📝 Document Preparation

• Clean your documents: Remove headers, footers, page numbers, and other metadata that could confuse retrieval.
• Use consistent formatting: Ensure section breaks, paragraph separations, and headings follow a consistent pattern.
• Include metadata: Add titles, PMIDs, or other identifiers to help trace retrieved content back to sources.
• Organize by topic: Consider creating separate databases for different research areas rather than one massive database.

✂️ Chunking Strategy

• For biomedical literature: Use medium chunk size (1000-1500) with 10-15% overlap. This captures full paragraphs while maintaining specificity.
• For Q&A applications: Larger chunks (2000-3000) provide more context for comprehensive answers.
• For keyword search: Smaller chunks (300-500) improve precision for finding specific facts.
• Test and iterate: Create a small test database, run sample queries, and adjust parameters based on retrieval quality.

🤖 Model Selection

• For English biomedical content: BAAI/bge-large-en-v1.5 or text-embedding-3-large (OpenAI)
• For multilingual content: BAAI/bge-m3 or Qwen/Qwen3-Embedding series
• For cost-effectiveness: SiliconFlow + BAAI models (low cost, good quality)
• Consistency is key: Use the same embedding model for all documents in a database. Mixing models will degrade retrieval quality.

⚠️ Troubleshooting Common Issues

• "Irrelevant results": Try enabling reranking, or use smaller chunks for more precise retrieval.
• "Missing context": Increase chunk size or Top-K to retrieve more content.
• "Slow responses": Reduce Top-K, disable reranking, or use a faster embedding model.
• "API errors": Verify your API key is valid and has sufficient credits. Check that the selected model is supported by your API provider.

📊 Data Flow in a Workflow Chain

Each arrow represents data flowing from one node to the next

💬 AI Nodes (Custom AI Nodes)

Purpose: Process text using AI models with custom system prompts. These are your "thinking" nodes that can analyze, summarize, extract, or generate content.

📥 Input:

Plain text string (from previous node output or user input)

📤 Output:

Plain text string (AI's response based on system prompt)

💡 Best for: Text analysis, summarization, content generation, question answering

🤖 Agent Nodes (Pre-configured Agents)

Purpose: Specialized AI agents with optimized system prompts for specific tasks like database search query generation, literature refinement, or report writing.

📥 Input:

Plain text string (task description or data to process)

📤 Output:

Text or structured data (depends on agent type — Search Agents output queries/URLs, Analysis Agents output text)

💡 Best for: PubMed search query generation, literature analysis, report writing, API URL construction

🔧 Tool Nodes (Data Processing Tools)

Purpose: Deterministic data operations — fetching data from APIs, parsing JSON, filtering arrays, iterating over items, etc. These are your "utility" nodes that don't use AI.

📥 Input:

Varies by tool (see detailed Input/Output Reference below)

📤 Output:

Varies by tool (JSON arrays, filtered data, concatenated strings, etc.)

💡 Best for: API calls, data parsing, filtering, iteration, format conversion

💾 Vector DB Nodes (Knowledge Retrieval)

Purpose: Search vector databases to retrieve relevant documents based on semantic similarity. Essential for RAG (Retrieval-Augmented Generation) workflows.

📥 Input:

Plain text query string (the search question)

📤 Output:

Retrieved text chunks (relevant documents from the knowledge base)

💡 Best for: Knowledge base search, document retrieval, grounding AI responses in your own data

📚 Example 1: PubMed Literature Search & Report (manifest_pubmed)

Use Case: Automatically search PubMed, extract abstracts, generate a comprehensive report, and format citations.

Key Configuration:

• PubMed Tool: Max Results = 300, Citation Format = APA
• JSON Extract: Field Path = "Abstract"
• Report Agent receives input from multiple nodes (Node 4 + Node 2)
• Citation Converter links text source (Node 5) with citation source (Node 3)

💾 Example 2: RAG with Remote Vector Database (Genes_and_Diseases)

Use Case: Extract biomedical entities from user query, search the Genes & Diseases knowledge base, and generate a comprehensive report.

Key Configuration:

• Custom AI Node: Temperature = 0 (deterministic entity extraction)
• Vector DB: genes_diseases, Top-K = 100, Rerank enabled with BAAI/bge-reranker-v2-m3
• Entity Extraction uses few-shot examples for accurate biomedical entity recognition
• Supports multilingual input (auto-translated to English for search)

💡 Why Entity Extraction? Raw user queries often contain noise. Extracting specific biomedical entities improves Vector DB search accuracy significantly.

🧬 Example 3: GEO Dataset Search (manifest_geo)

Use Case: Search NCBI GEO database for gene expression datasets and get AI-assisted analysis of results.

Key Configuration:

• GEO Search Agent: Temperature = 0.3 (focused query generation)
• General Assistant: Temperature = 1 (creative analysis)
• Node 2 uses both original query AND previous results for context

💡 Tip: This is a great starter workflow — simple but effective. You can extend it by adding JSON parsing and iteration for deeper analysis of each dataset.

🔑 Key Takeaways from These Examples

• Multiple Input Sources: Nodes can receive input from multiple previous nodes (e.g., Report Agent in Example 1 receives from both JSON Extract and Language Detection)
• Parallel Processing: Language Detection runs parallel to the main data pipeline, providing metadata for the final report
• Custom AI Nodes: You can create specialized AI nodes (like BioMed Entity Extraction) with custom system prompts for specific tasks
• Format Transformation: JSON Extract Tool converts array data to specific fields, making it suitable for text-based analysis
• Vector DB Integration: Remote Vector DB nodes can be inserted anywhere in the chain to add knowledge retrieval

Step 1: Plan Your Data Flow

Before building, sketch out: What is my input? What transformations are needed? What is my desired output? Identify which nodes you'll need and verify their input/output compatibility.

Step 2: Create New Workflow

Go to 🔗 Workflow Chain in the sidebar. Click ➕ New Workflow. Enter a name and description for your workflow.

Step 3: Add Nodes

Click ➕ Add Node to open the node selector. Choose from four tabs: AI Nodes, Agent Nodes, Tool Nodes, or Vector DB. Click a node to add it to your workflow.

Step 4: Configure Each Node

Click the ⚙️ button on each node to configure it. For Tool nodes, set parameters like separators, filters, etc. For AI/Agent nodes, select the API and model. For Iteration tools, configure the target AI node and prompt template.

Step 5: Set Input Sources

For each node (except the first), configure which previous node(s) to receive input from. Some nodes like String Concat can accept multiple inputs.

Step 6: Save and Test

Click 💾 Save to save your workflow. Enter test input in the input area and click ▶️ Run. Monitor the execution log for errors. Adjust node configurations as needed.

✅ Best Practices

• Start simple: Build and test 2-3 node workflows before creating complex chains. Verify each connection works before adding more nodes.
• Check format compatibility: Always verify that the output format of one node matches the expected input format of the next. Use the Input/Output Reference table above.
• Use JSON Parse after Iteration: Iteration tools output arrays of strings. If you need to merge them into a single array of objects, add a JSON Parse node.
• Add String Concat before final AI: When combining outputs from multiple branches, use String Concat to merge them before the final analysis node.
• Save frequently: Save your workflow after adding each node. This prevents losing work if something goes wrong.
• Use descriptive names: Name your workflows and nodes clearly (e.g., "Cancer Gene Literature Review" not "Workflow 1").

⚠️ Common Issues & Solutions

• "Node received undefined input": The previous node didn't produce output, or the input source is not configured. Check node connections and ensure the previous node runs successfully.
• "Cannot parse JSON": The input is not valid JSON. Add a JSON Extraction node before JSON-requiring tools if the input contains mixed text and JSON.
• "Empty results from PubMed": The search query may be too restrictive. Test the query directly in PubMed to verify it returns results.
• "Iteration produces empty array": The source node isn't producing a valid JSON array. Add a Variable Extraction or JSON Extraction node to convert the input first.
• "API rate limit error": You're sending too many requests. Add delays between iterations or reduce batch size. Consider using API keys with higher rate limits.
• "Workflow runs but output is wrong": Check each node's output in the execution log. Identify where the data format diverges from expectations, then fix that node's configuration.

📋 Pre-Run Checklist

• ☐ All nodes have their input sources configured
• ☐ API keys are configured for AI/Agent nodes
• ☐ Tool nodes have required parameters set
• ☐ Output format of each node matches input requirements of the next
• ☐ Iteration tools have target AI node and prompt configured
• ☐ Workflow is saved

🔄 Two Modes, One Powerful System

🤖 AI Model Configuration

Configure the AI model that will analyze retrieved documents and generate responses:

• Temperature: 0.0-2.0. Lower = more focused and factual, Higher = more creative. Recommended: 0.5-0.7 for research tasks.
• Memory: When enabled, the AI remembers previous messages in the conversation for context-aware responses.
• API & Model: Select your preferred AI provider and model (e.g., DeepSeek, GPT-4, Claude).

🗄️ Vector Database & Retrieval

Configure which knowledge bases to search and how to retrieve information:

• Vector Databases: Select one or more databases to search. You can combine local databases (your own) with remote databases (Genes & Diseases, Cell Marker).
• Top K: Number of most relevant chunks to retrieve (default: based on each database's setting).
• Search Method: Hybrid (recommended), Semantic only, or Keyword only — appears when remote databases are selected.
• Enable Reranking: Use a reranking model to improve retrieval accuracy (requires Rerank API configured).

💬 Prompts Configuration

Customize how the AI processes and responds to your queries:

• System Prompt: Instructions that define the AI's behavior and response format. Use this to create specialized research assistants (e.g., "You are a cancer biology expert...").
• User Prompt (Optional): A template that wraps your query. Use {query} placeholder for dynamic insertion.

💡 Tip: Leave prompts empty to use default behavior, or customize for specialized tasks like report generation, literature review, or Q&A.

📊 Library Mode Processing Pipeline

📊 Vector Database Selection

Choose where to store your processed literature:

• Select Database: Choose an existing local database from the dropdown.
• ➕ New: Create a new database for a specific research topic or project.

💡 Recommendation: Create separate databases for different research areas (e.g., "Cancer Immunotherapy", "scRNA-seq Methods", "Drug Resistance Mechanisms").

📚 PubMed Search Configuration

• Max Results: Maximum articles to retrieve per search (1-500). Start with 30-50 for testing, increase for comprehensive literature collection.
• Citation Format: APA, MLA, Chicago, Vancouver, Harvard, or IEEE — determines how citations are formatted in stored records.

🔍 Query Converter AI Configuration

AI that converts your natural language query into optimized PubMed search syntax:

• Temperature: Recommended 0.1-0.3. Lower values produce more precise, consistent search queries.
• API & Model: Any capable chat model works. DeepSeek-chat or GPT-4 recommended.

📄 Literature Extractor AI Configuration

AI that extracts structured biomedical entities from each article:

• Temperature: Recommended 0.3-0.5. Balanced for accurate extraction while handling varied writing styles.
• API & Model: Select your preferred AI provider and model.
• Parallel Threads: Number of articles processed simultaneously (1-50, default: 10). Higher = faster but more API calls.

💡 What gets extracted: Gene names (HGNC symbols), diseases, chemicals/drugs, proteins, species, key methods, and main findings.

🔢 Embedding Configuration

Settings for generating vector embeddings:

• Embedding API: API that provides embedding models (SiliconFlow recommended for cost-effectiveness).
• Embedding Model: BAAI/bge-m3 (multilingual) or bge-large-en-v1.5 (English) recommended.
• Chunk Size: Characters per text chunk (default: 10000). For PubMed abstracts, the default is usually sufficient.
• Chunk Overlap: Overlapping characters between chunks (default: 100).
• Delimiter: Text splitting pattern (default: \n\n for paragraph splits).
• Parallel Threads: Concurrent embedding generations (default: 1). Increase for faster processing if your API allows.

📈 Knowledge Accumulation Strategy

Phase 1: Foundation (Week 1)

• Create databases for your main research areas
• Add foundational papers and key reviews (50-100 papers per topic)
• Test Chat Mode to verify retrieval quality

Phase 2: Expansion (Ongoing)

• Set a weekly schedule to add new publications
• Run focused searches for specific sub-topics as projects evolve
• PMID deduplication ensures you never store the same paper twice

Phase 3: Utilization (Daily)

• Use Chat Mode for quick literature-grounded answers
• Generate literature reviews and background sections
• Identify research gaps by querying across your knowledge base

🎯 Practical Use Cases

• Literature Synthesis: Ask "What are the current approaches to X?" and get comprehensive answers synthesized from your curated literature collection.
• Hypothesis Generation: Query across your knowledge base to identify patterns, connections, and potential research directions you might have missed.
• Lab Meetings: Quickly find relevant papers to discuss, generate summaries of recent additions to your database.
• New Student Onboarding: Share your lab's literature database to help new members quickly get up to speed on the field.
• Research Gap Analysis: Query "What has not been studied about X and Y?" to identify potential research directions.

✅ Recommended Practices

• Organize by topic: Create separate databases for distinct research areas rather than one massive database.
• Start focused: Begin with specific, narrow searches to build a high-quality core, then expand gradually.
• Use natural language: The Query Converter AI handles translation to PubMed syntax — write queries as you would describe your research question.
• Monitor extraction: Check the progress panel to see what information is being extracted and identify any issues.
• Consistent embedding model: Use the same embedding model for all documents in a database for optimal retrieval.

⚠️ Common Issues & Solutions

• "No articles found": Try broader search terms, remove date restrictions, or check your query for typos.
• "All articles already in database": Your database already contains these papers — the deduplication is working correctly!
• Slow processing: Reduce parallel threads if hitting API rate limits, or increase threads if your API allows more concurrent calls.
• Poor retrieval in Chat Mode: Try increasing Top-K, enable reranking, or check that your databases contain relevant literature.
• Extraction failures: Some articles may fail AI extraction due to unusual formatting — check the progress panel for details.

🧬 BioElement Agent

Describe what you need in plain language, and BioElement Agent will generate clean, professional biological diagram elements — cells, proteins, organs, pathways, lab equipment, and more. The generated images are:

• Clean & Vector-like: No text labels (you add your own), no busy backgrounds
• Scientifically Accurate: Trained to understand biological structures and conventions
• Instantly Inserted: Generated images appear directly on your canvas — no downloading, no importing
• Fully Customizable: Adjust the system prompt to match your preferred illustration style

Example prompts: "a T cell attacking a cancer cell", "mitochondria cross-section", "DNA double helix unwinding", "96-well plate from above", "mouse liver tissue"

📐 Layout

• Top Toolbar: Project management (New, Save, Open), Undo/Redo, Zoom controls, Grid/Snap/Smart Guides toggles, Alignment tools, Crop Canvas, Export
• Left Panel: Drawing tools (Select, Text, Arrow, Rectangle, Ellipse, Line, Freehand, Label), BioElement Agent, Style options (Stroke/Fill colors), Canvas settings (Preset sizes, DPI)
• Center Canvas: Your working area — drag, resize, arrange objects here
• Right Panel: Layers list, Image upload area
• Bottom Status Bar: Current tool, selection info, canvas dimensions

📷 Adding Images

• Drag & Drop: Drag image files directly onto the canvas
• Upload Panel: Click the upload area in the right panel to browse for files
• Paste: Copy an image and press Ctrl+V to paste directly onto the canvas
• BioElement Agent: Type a description and click Generate — the image appears on canvas automatically

🎯 Selection & Transformation

• Select: Click an object, or drag a selection box to select multiple objects
• Multi-select: Hold Shift and click to add/remove objects from selection
• Move: Drag selected objects, or use Arrow keys (5px steps, Shift+Arrow for 1px fine adjustment)
• Resize: Drag corner handles to resize
• ⭐ Proportional Scaling: Hold Ctrl while dragging corner handles to maintain aspect ratio
• Select All: Press Ctrl+A to select all objects on canvas

📏 Alignment & Distribution

When multiple objects are selected, the alignment toolbar appears:

• Align Left/Center/Right: Align objects horizontally
• Align Top/Middle/Bottom: Align objects vertically
• Distribute Horizontally/Vertically: Space objects evenly

💡 Tip: Enable "Smart Guides" in the toolbar to see alignment guides as you drag objects.

📚 Layer Ordering

Control which objects appear in front of others:

• Right-click menu: Select an object, right-click, choose "Bring to Front" or "Send to Back"
• Layers panel: The right panel shows all objects — drag to reorder, or use the layer controls

Tool Shortcuts (press without Ctrl):

🧬 How to Generate Scientific Illustrations

1. Configure API: Select a Gemini API from the dropdown (requires Gemini API key configured in API Config)
2. Select Model: Choose an image generation model (e.g., gemini-2.5-flash-image)
3. Choose Aspect Ratio: Select from 1:1, 4:3, 16:9, etc. based on your needs
4. Enter Prompt: Describe the biological element you need in the text field
5. Generate: Click "✨ Generate" or press Enter — the image appears on your canvas
6. Iterate: Not quite right? Adjust your prompt and regenerate. The AI learns from descriptive feedback.

💡 Effective Prompting Tips:

• Be specific: "CD8+ T cell with TCR engaging MHC-I on tumor cell" > "immune cell"
• Specify style: "flat vector style", "3D rendered", "hand-drawn sketch", "textbook illustration"
• Request clean output: "without text labels", "transparent background", "isolated element"
• Add context: "for a cell biology paper", "schematic diagram", "simplified representation"

⚙️ Custom System Prompt: Click "System Prompt Settings" to customize the AI's behavior. The default prompt is optimized for clean biological elements without text.

📐 Canvas Settings

• Preset Sizes: A4 Portrait, Letter, Square, Postcard, or Custom dimensions
• DPI: 72 (screen) to 300+ (print). Higher DPI = larger file size but better print quality
• Grid: Toggle grid overlay for precise positioning
• Snap to Grid: Objects automatically align to grid lines when dragging
• Smart Guides: Dynamic alignment guides appear when objects align with each other

📤 Export Options

Click "Export" in the toolbar to open export settings:

• Format: PNG (transparency support), JPG (smaller file), PDF (print-ready)
• DPI: 72 (screen) to 2500 (maximum quality). For publications, use 300-600 DPI.
• Trim Whitespace: Automatically crop to content bounds with minimal padding
• Filename: Custom filename for the exported file

💡 Publication Tip: Most journals require 300 DPI minimum. Use 600 DPI for figures with fine details.

🎯 Focus on Your Scientific Narrative

The goal of Figure Composer + BioElement Agent is to free you from tedious image editing so you can focus on what matters — communicating your science effectively.

1. Plan your figure: Sketch the layout on paper first. What panels do you need? What story does each panel tell?
2. Generate elements: Use BioElement Agent to create the biological components. Iterate on prompts until you get what you need.
3. Arrange on canvas: Position and resize elements. Use Ctrl+drag for proportional scaling.
4. Add annotations: Use Text, Arrow, and Label tools to add panel labels (A, B, C...), scale bars, and callouts.
5. Align and polish: Use alignment tools and smart guides to create a clean, professional layout.
6. Export: Export at publication-quality DPI. Use Trim Whitespace to remove unnecessary margins.

💡 Save frequently! Use Ctrl+S to save your project. You can open it later from the Projects list.

• ⛓️ Workflow Chain: Complete workflow templates for common research tasks. Import and run immediately, or customize to fit your needs.
• 🤖 Agents/AI Nodes: Pre-configured AI agents with optimized prompts for specific biomedical tasks.
• 🔑 AI API Configuration: Ready-to-use API configurations for various AI providers.
• 💾 Vector Databases: Pre-built knowledge bases for specialized research domains.

1. Open Super BioMarket from the sidebar
2. Browse resources by category
3. Click 📥 Import on any resource card
4. The resource is automatically added to your workspace and ready to use

💡 Imported resources appear in their respective sections (Workflow Chain, Agent/Nodes, Vector DB, etc.).

🎯 Best Use Cases for WebR StatForge

💡 Summary: WebR StatForge excels at visualization, basic statistics, and data exploration. For advanced bioinformatics (RNA-seq, enrichment, single-cell), use a local R/RStudio installation with Bioconductor.

📊 Main Components:

• Code Editor (Left Panel): Write and edit R code here. Supports syntax highlighting and cursor position tracking.
• Output Panel (Right Panel): Displays execution results, including text output and generated plots.
• Toolbar: Quick access buttons for common operations.
• Data Browser: View and manage variables in the R environment.

▶️ Run Code

Execute all code in the editor. Results appear in the Output panel. Keyboard shortcut: Ctrl + Enter

🧹 Clear

Clear all content in the code editor. Use with caution — this cannot be undone.

📦 Install Packages

Open the package manager to install R packages from the WebR repository. See Section 3 below for detailed package installation rules.

🤖 AI Assistant

Open the AI coding assistant panel. Generate R code using natural language prompts. See Section 5 for detailed usage.

📁 Upload File

Upload data files (CSV, TSV, TXT, RData, etc.) to the WebR virtual filesystem. Files are stored at /home/web_user/

💾 Save Code

Save your current code to the browser's local storage (IndexedDB). You can reload saved scripts later.

📥 Download Code

Download the current code as an .R file to your local computer.

🌐 WebR Package Repository

WebR maintains its own package repository at https://repo.r-wasm.org/. This repository contains pre-compiled WebAssembly (WASM) versions of R packages that can run in the browser.

Key Point: Only packages that have been compiled to WASM and hosted in this repository can be installed in WebR. You cannot install packages directly from CRAN, GitHub, or Bioconductor.

✅ Available Packages (~20,000+)

Most popular CRAN packages are available, including:

• Data Manipulation: dplyr, tidyr, data.table, stringr, lubridate
• Visualization: ggplot2, plotly, pheatmap, corrplot, RColorBrewer
• Statistics: survival, lme4, nlme, car, emmeans
• Bioinformatics: Some Bioconductor packages (limited, see below)
• Machine Learning: randomForest, glmnet, xgboost (limited)

📋 Full list: https://repo.r-wasm.org/

🚫 Package Limitations

❌ GitHub Packages:

Cannot install packages directly from GitHub using devtools::install_github() or remotes::install_github(). WebR cannot compile packages on-the-fly.

❌ Bioconductor Packages:

Most Bioconductor packages are NOT available. Only a small subset has been compiled for WebR. Packages like DESeq2, edgeR, limma, clusterProfiler are typically unavailable. Check the WebR repo before planning your analysis.

❌ System Dependencies:

Packages requiring system libraries (e.g., rJava, RCurl with SSL, packages needing compilers) cannot work in the browser sandbox.

❌ Large Binary Packages:

Some packages are too large to load in browser memory (e.g., TensorFlow, Keras R bindings).

📝 How to Install Packages in WebR

Method 1: Using the Package Manager (Recommended)

1. Click 📦 Install Packages button in toolbar
2. Enter package name (e.g., "ggplot2")
3. Click Install and wait for completion

Method 2: Using R Code

⚡ Auto-Install Feature

BioForge's WebR StatForge has an auto-install feature: when you run library(package_name) and the package is not yet installed, the system will automatically attempt to install it from the WebR repository.

⚠️ Note: Auto-install only works for packages available in the WebR repository. If a package is not available, you will see an error.

Step 1: Upload Your File

1. Click the 📁 Upload File button in the toolbar
2. Select your data file (CSV, TSV, TXT, RData, RDS, etc.)
3. Wait for the upload confirmation message

Step 2: Read the File in R

After upload, files are located at /home/web_user/your_filename

💡 Tip: Use list.files("/home/web_user/") to see all uploaded files.

Opening the AI Assistant

1. Click the 🤖 AI Assistant button in the toolbar
2. A side panel will open on the right
3. Configure your AI API settings (first time only)

AI Panel Options Explained

• 📝 Your Request: Enter your natural language instruction here. Be specific about what you want.
  Example: "Create a scatter plot of mpg vs hp from mtcars dataset with a trend line"
• ☑️ Include current Editor code: When checked, the AI can see your existing code for context. Useful for debugging or extending existing code.
• ☑️ Include current Output Text: When checked, the AI can see the console output. Helpful when you want to fix errors.
• 🧠 Enable Memory: When checked, the AI remembers ALL your previous conversations. This helps maintain context across multiple requests.
• 🗑️ Clear Memory: Clears all conversation history permanently. Use this to start fresh or if the AI seems confused.

AI Model Configuration

• API Config: Select which AI API to use (configured in API Config section)
• Model: Choose the AI model (e.g., deepseek-chat, gpt-4, claude-3)
• Temperature: Controls creativity. Lower (0-0.3) = more precise; Higher (0.7-1) = more creative

✅ Good Prompts

• "Read the CSV file at /home/web_user/data.csv and create a boxplot comparing values across groups"
• "Perform a t-test comparing group A vs group B in the 'value' column of my dataframe 'df'"
• "Create a heatmap using pheatmap package with clustering on both rows and columns"
• "Fix the error in my code: Error in ggplot(data = NULL..."

❌ Vague Prompts

• "Make a plot" → Be specific: what data? what type of plot?
• "Analyze my data" → Specify: what analysis? what variables?
• "Do statistics" → Specify: which test? what hypothesis?

💡 Pro Tips

• Check "Include current Editor code" when you want to extend or fix existing code
• Check "Include current Output Text" when debugging errors
• Enable Memory for multi-step workflows where context matters
• Place cursor exactly where you want new code inserted before clicking Generate
• Use Clear Memory when starting a completely new task

❓ "Package not available" error

The package is not in WebR's repository. Check if an alternative package is available, or consider using a local R installation for advanced packages like most Bioconductor tools.

❓ "File not found" error

Make sure you uploaded the file first. Use list.files("/home/web_user/") to verify. Remember the path is /home/web_user/filename, not just the filename.

❓ AI generates code using unavailable packages

Tell the AI specifically: "Use only packages available in WebR" or "Avoid Bioconductor packages". You can also ask it to check package availability first.

❓ WebR is slow or unresponsive

WebR runs in your browser and may be slower than local R. Large datasets or complex computations may take longer. Consider using smaller sample data for testing.