Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_abnumber/app/abnumber_server.py

@@ -0,0 +1,124 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Literal
+
+# from mcp import tool
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_abnumber'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def abnumber(
+    input_file: Path,
+    outfile: Optional[Path] = None,
+    scheme: Literal['imgt', 'kabat', 'chothia', 'contact', 'aho', 'martin'] = 'imgt',
+    chain_type: Literal['H', 'K', 'L'] = 'H',
+    header: bool = False,
+    regions: bool = False,
+    seq: bool = False,
+    scheme_out: bool = False,
+    chain_out: bool = False,
+    species_out: bool = False,
+    gene_out: bool = False,
+    score_out: bool = False,
+    bitscore_out: bool = False,
+    evalue_out: bool = False,
+):
+    """
+    Number antibody sequences from a FASTA file using ANARCI.
+
+    This tool is a command-line wrapper for the AbNumber Python library, which
+    uses ANARCI for antibody numbering. It takes a FASTA file as input and
+    produces a table with numbered sequences and other annotations.
+
+    Args:
+        input_file: FASTA file with sequences to number.
+        outfile: Output file path. If not provided, output is sent to stdout.
+        scheme: Numbering scheme to use.
+        chain_type: Chain type to assign if not determined by ANARCI.
+        header: Print a header in the output table.
+        regions: Print CDR/FR regions instead of the numbered sequence.
+        seq: Print the original sequence in the output.
+        scheme_out: Print the numbering scheme in the output.
+        chain_out: Print the chain type in the output.
+        species_out: Print the species in the output.
+        gene_out: Print the V/J genes in the output.
+        score_out: Print the ANARCI score in the output.
+        bitscore_out: Print the ANARCI bitscore in the output.
+        evalue_out: Print the ANARCI E-value in the output.
+    """
+    # Input validation
+    if not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    # Command construction
+    cmd = ["abnumber", str(input_file)]
+
+    # Add optional arguments
+    cmd.extend(["--scheme", scheme])
+    cmd.extend(["--chain_type", chain_type])
+
+    if outfile:
+        cmd.extend(["--outfile", str(outfile)])
+
+    # Add boolean flags
+    if header:
+        cmd.append("--header")
+    if regions:
+        cmd.append("--regions")
+    if seq:
+        cmd.append("--seq")
+    if scheme_out:
+        cmd.append("--scheme-out")
+    if chain_out:
+        cmd.append("--chain-out")
+    if species_out:
+        cmd.append("--species-out")
+    if gene_out:
+        cmd.append("--gene-out")
+    if score_out:
+        cmd.append("--score-out")
+    if bitscore_out:
+        cmd.append("--bitscore-out")
+    if evalue_out:
+        cmd.append("--evalue-out")
+
+    command_executed = " ".join(cmd)
+
+    # Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+    except FileNotFoundError:
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: 'abnumber' command not found. Ensure the tool is installed and in your system's PATH.",
+            "output_files": []
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": []
+        }
+
+    # Structured result return
+    output_files = [str(outfile)] if outfile else []
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": output_files
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_abnumber/app/abnumber_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_abnumber/app/abnumber_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_abnumber'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_abnumber/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_abnumber/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - abnumber
+  - python=3.10
+    

Biomni/mcp_generated/mcp_abnumber/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_abricate/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install abricate via conda (e.g., from bioconda)
+RUN conda install -c bioconda abricate -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/abricate_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/abricate_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/abricate_server.py"]
+        

Biomni/mcp_generated/mcp_abricate/app/abricate_server.py

@@ -0,0 +1,312 @@
+import logging
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger(__name__)
+
+# MCP decorator is not defined here, but the functions are structured
+# to be compatible with it.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(f):
+            return f
+        return decorator
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_abricate'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def abricate_run(
+    contigs: List[Path],
+    db: str = "resfinder",
+    minid: float = 80.0,
+    mincov: float = 80.0,
+    threads: int = 1,
+    report: Optional[Path] = None,
+    summary: Optional[Path] = None,
+    json_output: Optional[Path] = None,
+    gff: Optional[Path] = None,
+    fofn: Optional[Path] = None,
+    datadir: Optional[Path] = None,
+    mismatches: Optional[int] = None,
+    minlen: Optional[int] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    nopathogen: bool = False,
+    csv: bool = False,
+    noheader: bool = False,
+    all_genes: bool = False,
+    nukem: bool = False,
+    long_report: bool = False,
+    pretty: bool = False,
+    agrvate: bool = False,
+    roary: bool = False,
+    prokka: bool = False,
+    plasmid: bool = False,
+    resistance: bool = False,
+    virulence: bool = False,
+    locus: bool = False,
+    seqid: bool = False,
+) -> Dict[str, Any]:
+    """
+    Mass screen contigs for antimicrobial resistance or virulence genes using Abricate.
+
+    This is the main analysis function of Abricate. It takes one or more FASTA files
+    and screens them against a specified database.
+    """
+    # --- Input Validation ---
+    if not contigs and not fofn:
+        raise ValueError("Either 'contigs' (a list of FASTA files) or 'fofn' (a file of FASTA paths) must be provided.")
+    if contigs and fofn:
+        raise ValueError("Provide either 'contigs' or 'fofn', but not both.")
+    
+    if contigs:
+        for file_path in contigs:
+            if not file_path.exists():
+                raise FileNotFoundError(f"Input contig file not found: {file_path}")
+    
+    if fofn and not fofn.exists():
+        raise FileNotFoundError(f"Input FOFN file not found: {fofn}")
+
+    if not 0.0 <= minid <= 100.0:
+        raise ValueError(f"'minid' must be between 0.0 and 100.0, but got {minid}")
+    if not 0.0 <= mincov <= 100.0:
+        raise ValueError(f"'mincov' must be between 0.0 and 100.0, but got {mincov}")
+    if threads < 1:
+        raise ValueError(f"'threads' must be a positive integer, but got {threads}")
+    if mismatches is not None and mismatches < 0:
+        raise ValueError(f"'mismatches' cannot be negative, but got {mismatches}")
+    if minlen is not None and minlen < 0:
+        raise ValueError(f"'minlen' cannot be negative, but got {minlen}")
+
+    # --- Command Construction ---
+    cmd = ["abricate"]
+    output_files = []
+
+    # Add options with values
+    cmd.extend(["--db", db])
+    cmd.extend(["--minid", str(minid)])
+    cmd.extend(["--mincov", str(mincov)])
+    cmd.extend(["--threads", str(threads)])
+
+    if report:
+        cmd.extend(["--report", str(report)])
+        output_files.append(str(report))
+    if summary:
+        cmd.extend(["--summary", str(summary)])
+        output_files.append(str(summary))
+    if json_output:
+        cmd.extend(["--json", str(json_output)])
+        output_files.append(str(json_output))
+    if gff:
+        cmd.extend(["--gff", str(gff)])
+        output_files.append(str(gff))
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if mismatches is not None:
+        cmd.extend(["--mismatches", str(mismatches)])
+    if minlen is not None:
+        cmd.extend(["--minlen", str(minlen)])
+    if fofn:
+        cmd.extend(["--fofn", str(fofn)])
+
+    # Add boolean flags
+    if quiet: cmd.append("--quiet")
+    if debug: cmd.append("--debug")
+    if nopathogen: cmd.append("--nopathogen")
+    if csv: cmd.append("--csv")
+    if noheader: cmd.append("--noheader")
+    if all_genes: cmd.append("--all")
+    if nukem: cmd.append("--nukem")
+    if long_report: cmd.append("--long")
+    if pretty: cmd.append("--pretty")
+    if agrvate: cmd.append("--agrvate")
+    if roary: cmd.append("--roary")
+    if prokka: cmd.append("--prokka")
+    if plasmid: cmd.append("--plasmid")
+    if resistance: cmd.append("--resistance")
+    if virulence: cmd.append("--virulence")
+    if locus: cmd.append("--locus")
+    if seqid: cmd.append("--seqid")
+
+    # Add positional arguments (input files)
+    if contigs:
+        cmd.extend([str(p) for p in contigs])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        log.error(f"Abricate execution failed with exit code {e.returncode}")
+        log.error(f"STDOUT: {e.stdout}")
+        log.error(f"STDERR: {e.stderr}")
+        raise RuntimeError(f"Abricate failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_list_databases(
+    datadir: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False
+) -> Dict[str, Any]:
+    """Lists all available abricate databases."""
+    cmd = ["abricate", "--list"]
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if quiet:
+        cmd.append("--quiet")
+    if debug:
+        cmd.append("--debug")
+
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate failed to list databases: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_check_databases(
+    datadir: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False
+) -> Dict[str, Any]:
+    """Checks if the abricate databases are installed correctly."""
+    cmd = ["abricate", "--check"]
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if quiet:
+        cmd.append("--quiet")
+    if debug:
+        cmd.append("--debug")
+
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate database check failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_setup_databases(
+    datadir: Optional[Path] = None,
+    threads: int = 1,
+    quiet: bool = False,
+    debug: bool = False
+) -> Dict[str, Any]:
+    """Downloads and sets up all the abricate databases."""
+    if threads < 1:
+        raise ValueError(f"'threads' must be a positive integer, but got {threads}")
+
+    cmd = ["abricate", "--setupdb"]
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+    if quiet:
+        cmd.append("--quiet")
+    if debug:
+        cmd.append("--debug")
+
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate database setup failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_get_version() -> Dict[str, Any]:
+    """Prints the abricate version."""
+    cmd = ["abricate", "--version"]
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate version check failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_get_citation() -> Dict[str, Any]:
+    """Prints the citation for abricate."""
+    cmd = ["abricate", "--citation"]
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate citation check failed: {e.stderr}")
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_abricate/app/abricate_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abricate/app/abricate_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_abricate'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_abricate/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_abricate/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-abricate:
+    build: .
+    image: mcp-abricate:latest
+    container_name: mcp-abricate
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=abricate
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_abricate/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - abricate
+  - python=3.10
+    

Biomni/mcp_generated/mcp_abricate/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_art/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install art via conda (e.g., from bioconda)
+RUN conda install -c bioconda art -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/art_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/art_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/art_server.py"]
+        

Biomni/mcp_generated/mcp_art/app/art_server.py

@@ -0,0 +1,302 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_art'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def art_illumina(
+    input_fasta: str,
+    output_prefix: str,
+    read_len: int,
+    fold_coverage: Optional[float] = None,
+    read_count: Optional[int] = None,
+    paired: bool = False,
+    mean_frag_len: Optional[float] = None,
+    std_dev: Optional[float] = None,
+    seq_sys: Optional[str] = None,
+    no_aln: bool = False,
+    sam_output: bool = False,
+    random_seed: Optional[int] = None,
+    id_prefix: Optional[str] = None,
+    q_shift: Optional[float] = None,
+    q_shift2: Optional[float] = None,
+    error_free: bool = False,
+    cigar_m: bool = False,
+    quiet: bool = False
+):
+    """
+    ART_Illumina: Simulation of Illumina Next-Generation Sequencing Reads.
+
+    Args:
+        input_fasta: The name of DNA reference format file (FASTA).
+        output_prefix: The prefix of output files.
+        read_len: The length of reads to be simulated.
+        fold_coverage: The fold of read coverage to be simulated.
+        read_count: The number of reads to be simulated (alternative to fold_coverage).
+        paired: Indicate a paired-end read simulation.
+        mean_frag_len: The mean size of DNA fragments for paired-end simulations.
+        std_dev: The standard deviation of DNA fragment size for paired-end simulations.
+        seq_sys: The sequencing system (e.g., 'HS20', 'HS25', 'HSXn', 'MSv1', 'MSv3', 'NS50').
+        no_aln: Do not output alignment file.
+        sam_output: Generate SAM alignment file.
+        random_seed: The seed for random number generator.
+        id_prefix: The prefix of read ID.
+        q_shift: The amount to shift every quality score for read 1.
+        q_shift2: The amount to shift every quality score for read 2.
+        error_free: Generate error-free reads.
+        cigar_m: Use M instead of =/X in SAM CIGAR strings.
+        quiet: Do not print log messages.
+    """
+    # Input validation
+    input_path = Path(input_fasta)
+    if not input_path.exists():
+        return {"error": f"Input FASTA file not found: {input_fasta}"}
+
+    if fold_coverage is None and read_count is None:
+        return {"error": "Either fold_coverage (-f) or read_count (-n) must be specified."}
+
+    cmd = ["art_illumina", "-i", str(input_path), "-o", output_prefix, "-l", str(read_len)]
+
+    if fold_coverage is not None:
+        cmd.extend(["-f", str(fold_coverage)])
+    if read_count is not None:
+        cmd.extend(["-n", str(read_count)])
+    
+    if paired:
+        cmd.append("-p")
+        if mean_frag_len is not None:
+            cmd.extend(["-m", str(mean_frag_len)])
+        if std_dev is not None:
+            cmd.extend(["-s", str(std_dev)])
+    
+    if seq_sys:
+        cmd.extend(["-ss", seq_sys])
+    if no_aln:
+        cmd.append("-na")
+    if sam_output:
+        cmd.append("-sam")
+    if random_seed is not None:
+        cmd.extend(["-rs", str(random_seed)])
+    if id_prefix:
+        cmd.extend(["-id", id_prefix])
+    if q_shift is not None:
+        cmd.extend(["-qs", str(q_shift)])
+    if q_shift2 is not None:
+        cmd.extend(["-qs2", str(q_shift2)])
+    if error_free:
+        cmd.append("-ef")
+    if cigar_m:
+        cmd.append("-M")
+    if quiet:
+        cmd.append("-q")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        # Identify output files based on prefix
+        output_files = list(Path(".").glob(f"{output_prefix}*"))
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(f) for f in output_files]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def art_454(
+    input_fasta: str,
+    output_prefix: str,
+    read_len: int,
+    fold_coverage: Optional[float] = None,
+    read_count: Optional[int] = None,
+    paired: bool = False,
+    mean_frag_len: Optional[float] = None,
+    std_dev: Optional[float] = None,
+    random_seed: Optional[int] = None,
+    quiet: bool = False
+):
+    """
+    ART_454: Simulation of 454 Next-Generation Sequencing Reads.
+
+    Args:
+        input_fasta: The name of DNA reference format file (FASTA).
+        output_prefix: The prefix of output files.
+        read_len: The length of reads to be simulated.
+        fold_coverage: The fold of read coverage to be simulated.
+        read_count: The number of reads to be simulated (alternative to fold_coverage).
+        paired: Indicate a paired-end read simulation.
+        mean_frag_len: The mean size of DNA fragments for paired-end simulations.
+        std_dev: The standard deviation of DNA fragment size for paired-end simulations.
+        random_seed: The seed for random number generator.
+        quiet: Do not print log messages.
+    """
+    input_path = Path(input_fasta)
+    if not input_path.exists():
+        return {"error": f"Input FASTA file not found: {input_fasta}"}
+
+    if fold_coverage is None and read_count is None:
+        return {"error": "Either fold_coverage (-f) or read_count (-n) must be specified."}
+
+    cmd = ["art_454", "-i", str(input_path), "-o", output_prefix, "-l", str(read_len)]
+
+    if fold_coverage is not None:
+        cmd.extend(["-f", str(fold_coverage)])
+    if read_count is not None:
+        cmd.extend(["-n", str(read_count)])
+    
+    if paired:
+        cmd.append("-p")
+        if mean_frag_len is not None:
+            cmd.extend(["-m", str(mean_frag_len)])
+        if std_dev is not None:
+            cmd.extend(["-s", str(std_dev)])
+    
+    if random_seed is not None:
+        cmd.extend(["-r", str(random_seed)])
+    if quiet:
+        cmd.append("-q")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        output_files = list(Path(".").glob(f"{output_prefix}*"))
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(f) for f in output_files]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def art_solid(
+    input_fasta: str,
+    output_prefix: str,
+    read_len: int,
+    fold_coverage: Optional[float] = None,
+    read_count: Optional[int] = None,
+    paired: bool = False,
+    mean_frag_len: Optional[float] = None,
+    std_dev: Optional[float] = None,
+    random_seed: Optional[int] = None,
+    quiet: bool = False
+):
+    """
+    ART_SOLiD: Simulation of Applied Biosystems SOLiD Sequencing Reads.
+
+    Args:
+        input_fasta: The name of DNA reference format file (FASTA).
+        output_prefix: The prefix of output files.
+        read_len: The length of reads to be simulated.
+        fold_coverage: The fold of read coverage to be simulated.
+        read_count: The number of reads to be simulated (alternative to fold_coverage).
+        paired: Indicate a paired-end read simulation.
+        mean_frag_len: The mean size of DNA fragments for paired-end simulations.
+        std_dev: The standard deviation of DNA fragment size for paired-end simulations.
+        random_seed: The seed for random number generator.
+        quiet: Do not print log messages.
+    """
+    input_path = Path(input_fasta)
+    if not input_path.exists():
+        return {"error": f"Input FASTA file not found: {input_fasta}"}
+
+    if fold_coverage is None and read_count is None:
+        return {"error": "Either fold_coverage (-f) or read_count (-n) must be specified."}
+
+    cmd = ["art_solid", "-i", str(input_path), "-o", output_prefix, "-l", str(read_len)]
+
+    if fold_coverage is not None:
+        cmd.extend(["-f", str(fold_coverage)])
+    if read_count is not None:
+        cmd.extend(["-n", str(read_count)])
+    
+    if paired:
+        cmd.append("-p")
+        if mean_frag_len is not None:
+            cmd.extend(["-m", str(mean_frag_len)])
+        if std_dev is not None:
+            cmd.extend(["-s", str(std_dev)])
+    
+    if random_seed is not None:
+        cmd.extend(["-r", str(random_seed)])
+    if quiet:
+        cmd.append("-q")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        output_files = list(Path(".").glob(f"{output_prefix}*"))
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(f) for f in output_files]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def art_profiler_illumina(
+    output_profile: str,
+    input_dir: str,
+    fastq_extension: str = "fastq",
+    threads: int = 1
+):
+    """
+    ART_Profiler_Illumina: Create a sequencing error profile from Illumina FASTQ files.
+
+    Args:
+        output_profile: The name of the output profile.
+        input_dir: The directory containing Illumina FASTQ files.
+        fastq_extension: The filename extension of FASTQ files (e.g., 'fastq' or 'fq').
+        threads: The number of threads to use.
+    """
+    input_path = Path(input_dir)
+    if not input_path.is_dir():
+        return {"error": f"Input directory not found: {input_dir}"}
+
+    cmd = ["art_profiler_illumina", output_profile, str(input_path), fastq_extension, str(threads)]
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        # Profiles usually create multiple files with the profile name
+        output_files = list(Path(".").glob(f"{output_profile}*"))
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(f) for f in output_files]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_art/app/art_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_art/app/art_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_art'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_art/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_art/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-art:
+    build: .
+    image: mcp-art:latest
+    container_name: mcp-art
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=art
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_art/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - art
+  - python=3.10
+    

Biomni/mcp_generated/mcp_art/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_augustus/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install augustus via conda (e.g., from bioconda)
+RUN conda install -c bioconda augustus -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY augustus_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/augustus_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/augustus_server.py"]
+        

Biomni/mcp_generated/mcp_augustus/app/augustus_server.py

@@ -0,0 +1,149 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, List, Literal
+
+# Assume mcp.tool is available in the execution environment.
+# Since we are not importing it, we can define a dummy decorator
+# to make the code syntactically valid.
+class mcp:
+    def tool(func):
+        return func
+
+@mcp.tool
+def augustus(
+    query_file: Path,
+    species: str,
+    strand: Literal["both", "forward", "backward"] = "both",
+    genemodel: Literal["partial", "intronless", "complete", "atleastone", "exactlyone"] = "partial",
+    outfile: Optional[Path] = None,
+    hints_file: Optional[Path] = None,
+    gff3: bool = False,
+    utr: bool = False,
+    singlestrand: bool = False,
+    protein: bool = True,
+    introns: bool = True,
+    start: bool = True,
+    stop: bool = True,
+    cds: bool = True,
+    codingseq: bool = False,
+    no_in_frame_stop: bool = False,
+    alternatives_from_evidence: bool = True,
+    alternatives_from_sampling: bool = False,
+    sample: Optional[int] = None,
+    keep_viterbi: bool = False,
+    no_prediction: bool = False,
+    progress: bool = False,
+    unique_gene_id: bool = False,
+    softmasking: bool = False,
+    extrinsic_cfg_file: Optional[Path] = None,
+    augustus_config_path: Optional[Path] = None,
+) -> dict:
+    """
+    Runs AUGUSTUS, a tool for gene prediction in eukaryotes.
+
+    This tool predicts genes in a given input FASTA file (query_file) based on a species-specific model.
+    It supports various prediction models, extrinsic evidence (hints), and output formats.
+    """
+    # 1. Input validation
+    if not query_file.is_file():
+        raise FileNotFoundError(f"Input query file not found: {query_file}")
+    if hints_file and not hints_file.is_file():
+        raise FileNotFoundError(f"Hints file not found: {hints_file}")
+    if extrinsic_cfg_file and not extrinsic_cfg_file.is_file():
+        raise FileNotFoundError(f"Extrinsic config file not found: {extrinsic_cfg_file}")
+    if augustus_config_path and not augustus_config_path.is_dir():
+        raise NotADirectoryError(f"AUGUSTUS_CONFIG_PATH is not a valid directory: {augustus_config_path}")
+
+    # 2. Command construction
+    cmd = ["augustus"]
+
+    # Add parameters
+    cmd.append(f"--species={species}")
+    cmd.append(f"--strand={strand}")
+    cmd.append(f"--genemodel={genemodel}")
+
+    # Boolean flags with true/false values
+    if singlestrand:
+        cmd.append("--singlestrand=true")
+    if no_in_frame_stop:
+        cmd.append("--noInFrameStop=true")
+    if alternatives_from_evidence:
+        cmd.append("--alternatives-from-evidence=true")
+    if alternatives_from_sampling:
+        cmd.append("--alternatives-from-sampling=true")
+    if keep_viterbi:
+        cmd.append("--keep_viterbi=true")
+    if no_prediction:
+        cmd.append("--noprediction=true")
+    if progress:
+        cmd.append("--progress=true")
+    if unique_gene_id:
+        cmd.append("--uniqueGeneId=true")
+
+    # Boolean flags with on/off values
+    cmd.append(f"--gff3={'on' if gff3 else 'off'}")
+    cmd.append(f"--UTR={'on' if utr else 'off'}")
+    cmd.append(f"--protein={'on' if protein else 'off'}")
+    cmd.append(f"--introns={'on' if introns else 'off'}")
+    cmd.append(f"--start={'on' if start else 'off'}")
+    cmd.append(f"--stop={'on' if stop else 'off'}")
+    cmd.append(f"--cds={'on' if cds else 'off'}")
+    cmd.append(f"--codingseq={'on' if codingseq else 'off'}")
+    
+    # Boolean flag with 1/0 value
+    if softmasking:
+        cmd.append("--softmasking=1")
+
+    # Optional file/directory paths and other values
+    if hints_file:
+        cmd.append(f"--hintsfile={hints_file}")
+    if extrinsic_cfg_file:
+        cmd.append(f"--extrinsicCfgFile={extrinsic_cfg_file}")
+    if augustus_config_path:
+        cmd.append(f"--AUGUSTUS_CONFIG_PATH={augustus_config_path}")
+    if sample is not None:
+        cmd.append(f"--sample={sample}")
+    if outfile:
+        # Ensure parent directory exists for the output file
+        outfile.parent.mkdir(parents=True, exist_ok=True)
+        cmd.append(f"--outfile={outfile}")
+
+    # Positional argument (must be last for some versions)
+    cmd.append(str(query_file))
+
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    # 3. Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except FileNotFoundError:
+        raise RuntimeError("augustus executable not found. Please ensure it is in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        logging.error(f"AUGUSTUS execution failed with exit code {e.returncode}")
+        logging.error(f"Stderr: {e.stderr}")
+        logging.error(f"Stdout: {e.stdout}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "AUGUSTUS execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+    # 4. Structured result return
+    output_files = [str(outfile)] if outfile else []
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": output_files
+    }

Biomni/mcp_generated/mcp_augustus/app/augustus_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_augustus/app/augustus_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_augustus'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_augustus/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-augustus:
+    build: .
+    image: mcp-augustus:latest
+    container_name: mcp-augustus
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=augustus
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_augustus/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - augustus
+  - python=3.10
+    

Biomni/mcp_generated/mcp_augustus/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_bactopia/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install bactopia via conda (e.g., from bioconda)
+RUN conda install -c bioconda bactopia -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/bactopia_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/bactopia_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/bactopia_server.py"]
+        

Biomni/mcp_generated/mcp_bactopia/app/bactopia_server.py

@@ -0,0 +1,287 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Union
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bactopia'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bactopia_run(
+    sample: str,
+    outdir: str,
+    datasets: str,
+    r1: Optional[str] = None,
+    r2: Optional[str] = None,
+    se: Optional[str] = None,
+    fastqs: Optional[str] = None,
+    accession: Optional[str] = None,
+    accessions: Optional[str] = None,
+    profile: str = "conda",
+    cpus: int = 2,
+    max_memory: int = 8,
+    resume: bool = False,
+) -> dict:
+    """
+    Run the main Bactopia analysis pipeline for a bacterial genome.
+    
+    Args:
+        sample: Name of the sample.
+        outdir: Directory to store output results.
+        datasets: Path to the Bactopia datasets directory.
+        r1: Path to forward reads (Paired-end).
+        r2: Path to reverse reads (Paired-end).
+        se: Path to single-end reads.
+        fastqs: Path to a FOFN (file-of-filenames) for multiple samples.
+        accession: A single ENA/SRA accession (e.g., SRX000000).
+        accessions: A file containing a list of ENA/SRA accessions.
+        profile: Nextflow profile to use (e.g., conda, docker, singularity).
+        cpus: Number of CPUs to allocate.
+        max_memory: Maximum memory in GB to allocate.
+        resume: Whether to resume a previous run.
+    """
+    # Input validation
+    out_path = Path(outdir)
+    ds_path = Path(datasets)
+    
+    if not ds_path.exists():
+        return {"error": f"Datasets directory not found at {datasets}"}
+
+    cmd = ["bactopia", "--sample", sample, "--outdir", str(out_path), "--datasets", str(ds_path)]
+    
+    # Input source logic
+    if r1 and r2:
+        if not Path(r1).exists() or not Path(r2).exists():
+            return {"error": "R1 or R2 file does not exist"}
+        cmd += ["--R1", r1, "--R2", r2]
+    elif se:
+        if not Path(se).exists():
+            return {"error": "Single-end file does not exist"}
+        cmd += ["--SE", se]
+    elif fastqs:
+        if not Path(fastqs).exists():
+            return {"error": "Fastqs list file does not exist"}
+        cmd += ["--fastqs", fastqs]
+    elif accession:
+        cmd += ["--accession", accession]
+    elif accessions:
+        if not Path(accessions).exists():
+            return {"error": "Accessions list file does not exist"}
+        cmd += ["--accessions", accessions]
+    else:
+        return {"error": "No input source provided (R1/R2, SE, fastqs, accession, or accessions required)"}
+
+    # Performance and Nextflow options
+    cmd += ["-profile", profile]
+    cmd += ["--max_cpus", str(cpus)]
+    cmd += ["--max_memory", f"{max_memory}.GB"]
+    
+    if resume:
+        cmd.append("-resume")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_directory": str(out_path.absolute())
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def bactopia_prepare(
+    path: str,
+    recursive: bool = False,
+    extension: str = ".fastq.gz",
+    output_file: Optional[str] = None
+) -> dict:
+    """
+    Prepare a FASTQ list (FOFN) for Bactopia from a directory of sequencing files.
+    
+    Args:
+        path: Directory containing FASTQ files.
+        recursive: Search for FASTQs in subdirectories.
+        extension: File extension to look for.
+        output_file: Optional path to save the generated list.
+    """
+    input_path = Path(path)
+    if not input_path.is_dir():
+        return {"error": f"Path {path} is not a directory"}
+
+    cmd = ["bactopia", "prepare", str(input_path), "--extension", extension]
+    if recursive:
+        cmd.append("--recursive")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        if output_file:
+            out_p = Path(output_file)
+            out_p.write_text(result.stdout)
+            return {
+                "command_executed": " ".join(cmd),
+                "stdout": "File list generated and saved.",
+                "output_file": str(out_p.absolute())
+            }
+            
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def bactopia_search(
+    query: str,
+    limit: int = 10,
+    output_file: Optional[str] = None
+) -> dict:
+    """
+    Search for bacterial genome accessions in ENA/SRA.
+    
+    Args:
+        query: Search query (e.g., "Staphylococcus aureus").
+        limit: Maximum number of results to return.
+        output_file: Optional path to save the accession list.
+    """
+    cmd = ["bactopia", "search", query, "--limit", str(limit)]
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        if output_file:
+            out_p = Path(output_file)
+            out_p.write_text(result.stdout)
+            return {
+                "command_executed": " ".join(cmd),
+                "stdout": f"Search results saved to {output_file}",
+                "output_file": str(out_p.absolute())
+            }
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def bactopia_datasets(
+    outdir: str,
+    species: Optional[str] = None,
+    include_genus: bool = False,
+    limit: int = 100
+) -> dict:
+    """
+    Download and setup Bactopia datasets/databases.
+    
+    Args:
+        outdir: Directory to save the datasets.
+        species: Optional species name to download specific datasets (e.g., "Salmonella enterica").
+        include_genus: Include genus-level datasets.
+        limit: Limit the number of genomes used for building datasets.
+    """
+    out_path = Path(outdir)
+    cmd = ["bactopia", "datasets", "--outdir", str(out_path)]
+    
+    if species:
+        cmd += ["--species", species]
+    if include_genus:
+        cmd.append("--include_genus")
+    cmd += ["--limit", str(limit)]
+
+    try:
+        # This can be a long-running process
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "datasets_path": str(out_path.absolute())
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def bactopia_tool(
+    tool_name: str,
+    bactopia_dir: str,
+    outdir: str,
+    profile: str = "conda",
+    cpus: int = 2,
+    extra_params: Optional[List[str]] = None
+) -> dict:
+    """
+    Run a Bactopia Tool (comparative analysis) on existing Bactopia outputs.
+    Common tools include: pangenome, roary, iqtree, pirate, summary, etc.
+    
+    Args:
+        tool_name: Name of the Bactopia Tool to run.
+        bactopia_dir: Directory containing previous Bactopia results.
+        outdir: Directory to store tool results.
+        profile: Nextflow profile to use.
+        cpus: Number of CPUs to allocate.
+        extra_params: List of additional command line arguments for the specific tool.
+    """
+    b_path = Path(bactopia_dir)
+    o_path = Path(outdir)
+    
+    if not b_path.exists():
+        return {"error": f"Bactopia results directory not found at {bactopia_dir}"}
+
+    cmd = [
+        "bactopia", tool_name,
+        "--bactopia", str(b_path),
+        "--outdir", str(o_path),
+        "-profile", profile,
+        "--max_cpus", str(cpus)
+    ]
+    
+    if extra_params:
+        cmd.extend(extra_params)
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_directory": str(o_path.absolute())
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bactopia/app/bactopia_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bactopia/app/bactopia_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bactopia'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bactopia/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bactopia/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bactopia:
+    build: .
+    image: mcp-bactopia:latest
+    container_name: mcp-bactopia
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bactopia
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_bactopia/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - bactopia
+  - python=3.10
+    

Biomni/mcp_generated/mcp_bactopia/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_bedops/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install bedops via conda (e.g., from bioconda)
+RUN conda install -c bioconda bedops -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/bedops_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/bedops_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/bedops_server.py"]
+        

Biomni/mcp_generated/mcp_bedops/app/bedops_server.py

@@ -0,0 +1,827 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# MCP decorator is commented out as per instructions
+# import mcp
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bedops'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bedops_complement(
+    files: List[Path],
+    chop_to_limits: bool = False,
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Computes the complement of one or more BED files.
+
+    This corresponds to the `bedops -c` or `bedops --complement` operation.
+    It finds the regions within chromosome boundaries that are not covered by
+    any intervals in the input file(s).
+
+    Args:
+        files: A list of one or more input BED/Starch files. Must be sorted.
+        chop_to_limits: If True, chop complementary regions to chromosome limits
+                        defined by the first input file (-L flag).
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if not files:
+        raise ValueError("At least one input file must be provided for the complement operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--complement")
+    if chop_to_limits:
+        cmd.append("-L")
+
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops complement failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_difference(
+    files: List[Path],
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Computes the difference between a reference BED file and one or more other BED files.
+
+    This corresponds to the `bedops -d` or `bedops --difference` operation.
+    It returns regions from the first (reference) file that do not overlap
+    with any regions in the subsequent files.
+
+    Args:
+        files: A list of two or more input BED/Starch files. The first file is
+               the reference. All files must be sorted.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if len(files) < 2:
+        raise ValueError("At least two input files (a reference and one other) must be provided for the difference operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--difference")
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops difference failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_element_of(
+    files: List[Path],
+    overlap_criterion: str = "100%",
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Finds elements in the reference file that overlap other files by a specified amount.
+
+    This corresponds to the `bedops -e` or `bedops --element-of` operation.
+    It returns elements from the first (reference) file that overlap elements
+    in any of the other files by at least the specified amount.
+
+    Args:
+        files: A list of two or more input BED/Starch files. The first file is
+               the reference. All files must be sorted.
+        overlap_criterion: The required overlap, as base pairs (e.g., '1') or
+                           percentage (e.g., '50%'). Defaults to '100%'.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' or 'S' format. The first (reference)
+                   file is NOT padded with this operation.
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if len(files) < 2:
+        raise ValueError("At least two input files (a reference and one other) must be provided for the element-of operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.extend(["--element-of", overlap_criterion])
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops element-of failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_intersect(
+    files: List[Path],
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Computes the intersection of two or more BED files.
+
+    This corresponds to the `bedops -i` or `bedops --intersect` operation.
+    It returns regions that are common to all input files.
+
+    Args:
+        files: A list of two or more input BED/Starch files. All files must be sorted.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if len(files) < 2:
+        raise ValueError("At least two input files must be provided for the intersect operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--intersect")
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops intersect failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_merge(
+    files: List[Path],
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Merges overlapping regions from one or more BED files.
+
+    This corresponds to the `bedops -m` or `bedops --merge` operation.
+    It combines overlapping or adjacent intervals into a single, larger interval.
+
+    Args:
+        files: A list of one or more input BED/Starch files. Must be sorted.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if not files:
+        raise ValueError("At least one input file must be provided for the merge operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--merge")
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops merge failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_not_element_of(
+    files: List[Path],
+    overlap_criterion: str = "100%",
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Finds elements in the reference file that DO NOT overlap other files by a specified amount.
+
+    This corresponds to the `bedops -n` or `bedops --not-element-of` operation.
+    It is the inverse of the `element-of` operation.
+
+    Args:
+        files: A list of two or more input BED/Starch files. The first file is
+               the reference. All files must be sorted.
+        overlap_criterion: The required overlap, as base pairs (e.g., '1') or
+                           percentage (e.g., '50%'). Defaults to '100%'.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' or 'S' format. The first (reference)
+                   file is NOT padded with this operation.
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if len(files) < 2:
+        raise ValueError("At least two input files (a reference and one other) must be provided for the not-element-of operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.extend(["--not-element-of", overlap_criterion])
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops not-element-of failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_partition(
+    files: List[Path],
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Partitions the input BED file(s) into disjoint segments.
+
+    This corresponds to the `bedops -p` or `bedops --partition` operation.
+    It breaks the input regions into non-overlapping segments, reporting each
+    new segment and which input files it came from.
+
+    Args:
+        files: A list of one or more input BED/Starch files. Must be sorted.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if not files:
+        raise ValueError("At least one input file must be provided for the partition operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--partition")
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops partition failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_symmdiff(
+    files: List[Path],
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Computes the symmetric difference of two or more BED files.
+
+    This corresponds to the `bedops -s` or `bedops --symmdiff` operation.
+    It returns regions that are unique to any of the input files (i.e., not
+    present in their intersection).
+
+    Args:
+        files: A list of two or more input BED/Starch files. All files must be sorted.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if len(files) < 2:
+        raise ValueError("At least two input files must be provided for the symmetric difference operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--symmdiff")
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops symmdiff failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_everything(
+    files: List[Path],
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Returns the union of all elements from input files without merging.
+
+    This corresponds to the `bedops -u` or `bedops --everything` operation.
+    It effectively concatenates the input files while maintaining sort order
+    and preserving all original columns.
+
+    Args:
+        files: A list of one or more input BED/Starch files. Must be sorted.
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if not files:
+        raise ValueError("At least one input file must be provided for the everything operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.append("--everything")
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops everything failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+@mcp.tool()
+def bedops_chop(
+    files: List[Path],
+    bp: int = 1,
+    stagger: Optional[int] = None,
+    exclusive_chop: bool = False,
+    chrom: Optional[str] = None,
+    ec: bool = False,
+    header: bool = False,
+    range_str: Optional[str] = None,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Chops elements into fixed-size, potentially staggered sub-elements.
+
+    This corresponds to the `bedops -w` or `bedops --chop` operation.
+
+    Args:
+        files: A list of one or more input BED/Starch files. Must be sorted.
+        bp: The size in base pairs of each chopped element. Defaults to 1.
+        stagger: The stagger distance in nucleotides. If not set, no staggering is done.
+        exclusive_chop: If True, removes single-base elements that can result
+                        from chopping (-x flag).
+        chrom: Process data for the given chromosome only.
+        ec: Error check input files (slower).
+        header: Accept headers (VCF, GFF, SAM, BED, WIG) in any input file.
+        range_str: Pad coordinates. Use 'L:R' format (e.g., '-10:20') or a
+                   single value 'S' for symmetric padding (e.g., '100').
+        output_file: Optional path to save the output. If not provided,
+                     output is returned as a string in the result dictionary.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a
+        list of output files generated.
+    """
+    if not files:
+        raise ValueError("At least one input file must be provided for the chop operation.")
+    for file_path in files:
+        if not file_path.exists():
+            raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    cmd = ["bedops"]
+
+    if chrom:
+        cmd.extend(["--chrom", chrom])
+    if ec:
+        cmd.append("--ec")
+    if header:
+        cmd.append("--header")
+    if range_str:
+        cmd.extend(["--range", range_str])
+
+    cmd.extend(["--chop", str(bp)])
+    if stagger is not None:
+        cmd.extend(["--stagger", str(stagger)])
+    if exclusive_chop:
+        cmd.append("-x")
+
+    cmd.extend([str(p) for p in files])
+
+    try:
+        if output_file:
+            with open(output_file, "w") as f:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f, stderr=subprocess.PIPE
+                )
+            stdout_capture = ""
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_capture,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"bedops chop failed with exit code {e.returncode}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Command: {' '.join(cmd)}"
+        ) from e
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bedops/app/bedops_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bedops/app/bedops_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bedops'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bedops/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bedops/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bedops:
+    build: .
+    image: mcp-bedops:latest
+    container_name: mcp-bedops
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bedops
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_bedops/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - bedops
+  - python=3.10
+    

Biomni/mcp_generated/mcp_bedops/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_biobambam/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install biobambam via conda (e.g., from bioconda)
+RUN conda install -c bioconda biobambam -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/biobambam_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/biobambam_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/biobambam_server.py"]
+        

Biomni/mcp_generated/mcp_biobambam/app/biobambam_server.py

@@ -0,0 +1,497 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Union
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_biobambam'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bamsort(
+    input_file: str,
+    output_file: str,
+    memory_limit: str = "1G",
+    tmp_prefix: Optional[str] = None,
+    create_index: bool = False,
+    index_filename: Optional[str] = None,
+    sort_order: str = "coordinate",
+    threads: int = 1,
+    compression_level: int = 1,
+    recalculate_md_nm: bool = False,
+    reference_file: Optional[str] = None,
+    verbose: bool = False,
+) -> dict:
+    """
+    Sorts BAM files by coordinate or query name using bamsort.
+
+    Args:
+        input_file: Path to the input BAM file.
+        output_file: Path for the sorted output BAM file.
+        memory_limit: Main memory to use (e.g., '1G', '512M').
+        tmp_prefix: Temporary file prefix.
+        create_index: Whether to create an index for the output BAM file.
+        index_filename: Name for the index file.
+        sort_order: Sort order ('coordinate' or 'queryname').
+        threads: Number of threads to use.
+        compression_level: Compression level (0-9).
+        recalculate_md_nm: Recalculate MD and NM tags (requires reference).
+        reference_file: Reference FASTA file for MD/NM recalculation.
+        verbose: Enable verbose output.
+    """
+    in_path = Path(input_file)
+    out_path = Path(output_file)
+    
+    if not in_path.exists():
+        return {"error": f"Input file {input_file} does not exist"}
+    if sort_order not in ["coordinate", "queryname"]:
+        return {"error": "sort_order must be 'coordinate' or 'queryname'"}
+    if not (0 <= compression_level <= 9):
+        return {"error": "compression_level must be between 0 and 9"}
+
+    cmd = ["bamsort", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"M={memory_limit}")
+    cmd.append(f"sortorder={sort_order}")
+    cmd.append(f"threads={threads}")
+    cmd.append(f"level={compression_level}")
+    
+    if tmp_prefix: cmd.append(f"T={tmp_prefix}")
+    if create_index: cmd.append("index=1")
+    if index_filename: cmd.append(f"indexfilename={index_filename}")
+    if recalculate_md_nm:
+        if not reference_file:
+            return {"error": "reference_file is required for recalculate_md_nm"}
+        cmd.append("calmd=1")
+        cmd.append(f"reference={reference_file}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd), "return_code": e.returncode}
+
+@mcp.tool()
+def bammarkduplicates(
+    input_file: str,
+    output_file: str,
+    metrics_file: Optional[str] = None,
+    tmp_prefix: Optional[str] = None,
+    create_index: bool = False,
+    index_filename: Optional[str] = None,
+    remove_duplicates: bool = False,
+    compression_level: int = 1,
+    verbose: bool = False,
+) -> dict:
+    """
+    Marks or removes duplicate reads in a coordinate-sorted BAM file.
+
+    Args:
+        input_file: Input BAM file (must be coordinate sorted).
+        output_file: Output BAM file with duplicates marked.
+        metrics_file: Path for the output metrics file.
+        tmp_prefix: Temporary file prefix.
+        create_index: Create index for output BAM.
+        index_filename: Name for the index file.
+        remove_duplicates: Remove duplicate reads instead of marking.
+        compression_level: Compression level (0-9).
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bammarkduplicates", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"level={compression_level}")
+    
+    if metrics_file: cmd.append(f"M={metrics_file}")
+    if tmp_prefix: cmd.append(f"T={tmp_prefix}")
+    if create_index: cmd.append("index=1")
+    if index_filename: cmd.append(f"indexfilename={index_filename}")
+    if remove_duplicates: cmd.append("rmdup=1")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        outputs = [output_file]
+        if metrics_file: outputs.append(metrics_file)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": outputs
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamsormadup(
+    input_file: str,
+    output_file: str,
+    tmp_prefix: Optional[str] = None,
+    memory_limit: str = "1G",
+    threads: int = 1,
+    compression_level: int = 1,
+    create_index: bool = False,
+    index_filename: Optional[str] = None,
+    remove_duplicates: bool = False,
+    verbose: bool = False,
+) -> dict:
+    """
+    Combined sorting and duplicate marking in a single pass.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output BAM file.
+        tmp_prefix: Temporary file prefix.
+        memory_limit: Memory limit.
+        threads: Number of threads.
+        compression_level: Compression level (0-9).
+        create_index: Create index for output.
+        index_filename: Index filename.
+        remove_duplicates: Remove duplicates.
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamsormadup", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"M={memory_limit}")
+    cmd.append(f"threads={threads}")
+    cmd.append(f"level={compression_level}")
+    
+    if tmp_prefix: cmd.append(f"T={tmp_prefix}")
+    if create_index: cmd.append("index=1")
+    if index_filename: cmd.append(f"indexfilename={index_filename}")
+    if remove_duplicates: cmd.append("rmdup=1")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamtofastq(
+    input_file: str,
+    fastq_1: str,
+    fastq_2: Optional[str] = None,
+    singles: Optional[str] = None,
+    orphans_1: Optional[str] = None,
+    orphans_2: Optional[str] = None,
+    collate: bool = False,
+    gzip: bool = False,
+    compression_level: int = 1,
+    reads_per_file: int = 0,
+    verbose: bool = False,
+) -> dict:
+    """
+    Converts BAM files to FASTQ format.
+
+    Args:
+        input_file: Input BAM file.
+        fastq_1: Output FASTQ file (Read 1).
+        fastq_2: Output FASTQ file (Read 2).
+        singles: Output FASTQ for single-end reads.
+        orphans_1: Output FASTQ for orphan Read 1.
+        orphans_2: Output FASTQ for orphan Read 2.
+        collate: Collate reads by name before conversion.
+        gzip: Compress output with gzip.
+        compression_level: Gzip compression level (1-9).
+        reads_per_file: Split output into files with N reads (0 = no split).
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamtofastq", f"filename={input_file}", f"F={fastq_1}"]
+    outputs = [fastq_1]
+
+    if fastq_2:
+        cmd.append(f"F2={fastq_2}")
+        outputs.append(fastq_2)
+    if singles:
+        cmd.append(f"S={singles}")
+        outputs.append(singles)
+    if orphans_1:
+        cmd.append(f"O={orphans_1}")
+        outputs.append(orphans_1)
+    if orphans_2:
+        cmd.append(f"O2={orphans_2}")
+        outputs.append(orphans_2)
+    if collate: cmd.append("collate=1")
+    if gzip: cmd.append("gz=1")
+    if compression_level != 1: cmd.append(f"level={compression_level}")
+    if reads_per_file > 0: cmd.append(f"readsperfile={reads_per_file}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": outputs
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamcollate2(
+    input_file: str,
+    output_file: str,
+    tmp_prefix: Optional[str] = None,
+    compression_level: int = 1,
+    verbose: bool = False,
+) -> dict:
+    """
+    Collates a BAM file by read name.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output collated BAM file.
+        tmp_prefix: Temporary file prefix.
+        compression_level: Compression level (0-9).
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamcollate2", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"level={compression_level}")
+    if tmp_prefix: cmd.append(f"T={tmp_prefix}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamadapterclip(
+    input_file: str,
+    output_file: str,
+    threads: int = 1,
+    compression_level: int = 1,
+    verbose: bool = False,
+) -> dict:
+    """
+    Clips adapter sequences from reads in a BAM file.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output clipped BAM file.
+        threads: Number of threads.
+        compression_level: Compression level (0-9).
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamadapterclip", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"threads={threads}")
+    cmd.append(f"level={compression_level}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamreset(
+    input_file: str,
+    output_file: str,
+    compression_level: int = 1,
+    reset_flags: bool = False,
+    verbose: bool = False,
+) -> dict:
+    """
+    Resets alignment information in a BAM file.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output reset BAM file.
+        compression_level: Compression level (0-9).
+        reset_flags: Reset flags to 0.
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamreset", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"level={compression_level}")
+    if reset_flags: cmd.append("resetflags=1")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamchecksort(
+    input_file: str,
+    verbose: bool = False,
+) -> dict:
+    """
+    Checks if a BAM file is sorted.
+
+    Args:
+        input_file: Input BAM file.
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamchecksort", f"I={input_file}"]
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "is_sorted": "sorted" in result.stdout.lower() or result.returncode == 0
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd), "is_sorted": False}
+
+@mcp.tool()
+def bamrecompress(
+    input_file: str,
+    output_file: str,
+    compression_level: int = 1,
+    threads: int = 1,
+    verbose: bool = False,
+) -> dict:
+    """
+    Recompresses a BAM file.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output recompressed BAM file.
+        compression_level: Compression level (0-9).
+        threads: Number of threads.
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamrecompress", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"level={compression_level}")
+    cmd.append(f"threads={threads}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamfilterrg(
+    input_file: str,
+    output_file: str,
+    read_group: str,
+    compression_level: int = 1,
+    verbose: bool = False,
+) -> dict:
+    """
+    Filters a BAM file by read group.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output filtered BAM file.
+        read_group: Read group ID to keep.
+        compression_level: Compression level (0-9).
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamfilterrg", f"I={input_file}", f"O={output_file}", f"rg={read_group}"]
+    cmd.append(f"level={compression_level}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+@mcp.tool()
+def bamfillquery(
+    input_file: str,
+    output_file: str,
+    compression_level: int = 1,
+    verbose: bool = False,
+) -> dict:
+    """
+    Fills query information in a BAM file.
+
+    Args:
+        input_file: Input BAM file.
+        output_file: Output BAM file.
+        compression_level: Compression level (0-9).
+        verbose: Enable verbose output.
+    """
+    if not Path(input_file).exists():
+        return {"error": f"Input file {input_file} does not exist"}
+
+    cmd = ["bamfillquery", f"I={input_file}", f"O={output_file}"]
+    cmd.append(f"level={compression_level}")
+    if verbose: cmd.append("verbose=1")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_file]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": e.stderr, "command_executed": " ".join(cmd)}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_biobambam/app/biobambam_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_biobambam/app/biobambam_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_biobambam'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_biobambam/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_biobambam/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-biobambam:
+    build: .
+    image: mcp-biobambam:latest
+    container_name: mcp-biobambam
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=biobambam
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_biobambam/environment.yaml

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - biobambam
+  - python=3.10
+    

Biomni/mcp_generated/mcp_biobambam/requirements.txt

@@ -0,0 +1,2 @@
+fastmcp
+mcp

Biomni/mcp_generated/mcp_bioconductor-affyio/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install bioconductor-affyio via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-affyio -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/bioconductor-affyio_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/bioconductor-affyio_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/bioconductor-affyio_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-affyio/app/bioconductor-affyio_server.py

@@ -0,0 +1,216 @@
+import subprocess
+import json
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_affyio'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def affyio_read_celfile_header(
+    filename: str,
+    info: str = "full"
+) -> Dict[str, Any]:
+    """
+    Read the header information from an Affymetrix CEL file.
+    
+    Args:
+        filename: Path to the CEL file.
+        info: Level of information to extract ('full' or 'minimal').
+    """
+    file_path = Path(filename)
+    if not file_path.exists():
+        return {"error": f"File not found: {filename}"}
+
+    if info not in ["full", "minimal"]:
+        info = "full"
+
+    # R script to extract header and convert to JSON
+    r_command = f"""
+    library(affyio)
+    library(jsonlite)
+    header <- read.celfile.header("{str(file_path)}", info="{info}")
+    cat(toJSON(header, auto_unbox = TRUE))
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"read.celfile.header('{filename}')",
+            "header_data": json.loads(result.stdout),
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+    except json.JSONDecodeError:
+        return {"error": "Failed to parse R output", "raw_stdout": result.stdout}
+
+@mcp.tool()
+def affyio_read_celfile(
+    filename: str,
+    output_csv: str,
+    intensity_only: bool = True
+) -> Dict[str, Any]:
+    """
+    Read an Affymetrix CEL file and export the intensity data to a CSV file.
+    
+    Args:
+        filename: Path to the CEL file.
+        output_csv: Path where the intensity data should be saved.
+        intensity_only: If True, only the intensity values are extracted.
+    """
+    input_path = Path(filename)
+    output_path = Path(output_csv)
+    
+    if not input_path.exists():
+        return {"error": f"Input file not found: {filename}"}
+
+    intensity_val = "TRUE" if intensity_only else "FALSE"
+
+    r_command = f"""
+    library(affyio)
+    data <- read.celfile("{str(input_path)}", intensity.only={intensity_val})
+    # If intensity.only is TRUE, it returns a list with INTENSITY
+    # If FALSE, it returns a list with INTENSITY, MASKS, OUTLIERS
+    write.csv(data$INTENSITY, "{str(output_path)}")
+    """
+
+    try:
+        subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"read.celfile('{filename}')",
+            "status": "Success",
+            "output_file": str(output_path)
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stderr": e.stderr,
+            "stdout": e.stdout
+        }
+
+@mcp.tool()
+def affyio_check_cdf_type(
+    filename: str
+) -> Dict[str, Any]:
+    """
+    Identify the type of an Affymetrix CDF file (e.g., text, binary, gzipped).
+    
+    Args:
+        filename: Path to the CDF file.
+    """
+    file_path = Path(filename)
+    if not file_path.exists():
+        return {"error": f"File not found: {filename}"}
+
+    r_command = f"""
+    library(affyio)
+    type <- check.cdf.type("{str(file_path)}")
+    cat(type)
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"check.cdf.type('{filename}')",
+            "cdf_type": result.stdout.strip(),
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": "R execution failed", "stderr": e.stderr}
+
+@mcp.tool()
+def affyio_read_cdffile_summary(
+    filename: str
+) -> Dict[str, Any]:
+    """
+    Read an Affymetrix CDF file and return a summary of its contents.
+    Note: Full CDF lists are extremely large; this tool returns structural metadata.
+    
+    Args:
+        filename: Path to the CDF file.
+    """
+    file_path = Path(filename)
+    if not file_path.exists():
+        return {"error": f"File not found: {filename}"}
+
+    r_command = f"""
+    library(affyio)
+    library(jsonlite)
+    cdf_data <- read.cdffile.list("{str(file_path)}")
+    summary_info <- list(
+        filename = "{filename}",
+        num_probesets = length(cdf_data),
+        probeset_names = head(names(cdf_data), 10)
+    )
+    cat(toJSON(summary_info, auto_unbox = TRUE))
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"read.cdffile.list('{filename}')",
+            "summary": json.loads(result.stdout),
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": "R execution failed", "stderr": e.stderr}
+
+@mcp.tool()
+def affyio_get_package_version() -> Dict[str, Any]:
+    """
+    Check the installed version of the affyio package and its dependencies.
+    """
+    r_command = """
+    library(affyio)
+    v <- as.character(packageVersion("affyio"))
+    cat(v)
+    """
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "package": "affyio",
+            "version": result.stdout.strip(),
+            "r_version": subprocess.run(["Rscript", "--version"], capture_output=True, text=True).stderr.strip()
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Could not determine package version. Ensure bioconductor-affyio is installed.",
+            "stderr": e.stderr
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-affyio/app/bioconductor-affyio_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-affyio/app/bioconductor-affyio_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_affyio'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-affyio/app/requirements.txt

@@ -0,0 +1 @@
+