Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_ariba/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 ariba via conda (e.g., from bioconda)
+RUN conda install -c bioconda ariba -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/ariba_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/ariba_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/ariba_server.py"]
+        

Biomni/mcp_generated/mcp_ariba/app/ariba_server.py

@@ -0,0 +1,509 @@
+import subprocess
+import tempfile
+import os
+from pathlib import Path
+from typing import Optional, List, Literal
+
+# MCP decorator is not needed for the final code, as per instructions.
+# Assuming it's provided by the MCP framework.
+# from mcp import tool as mcp_tool
+# For linting purposes, we can create a dummy decorator.
+class mcp:
+    def tool(func):
+        return func
+
+@mcp.tool
+def pubmlstget(
+    pubmlst_db: str,
+    outdir: Path,
+    force: bool = False,
+    noverify: bool = False,
+):
+    """
+    Download data from a pubmlst database.
+
+    Args:
+        pubmlst_db: Name of the pubmlst database to download.
+        outdir: Output directory to save the downloaded data.
+        force: Overwrite existing files if they exist.
+        noverify: Do not verify the SSL certificate.
+    """
+    # Input validation
+    if not pubmlst_db:
+        raise ValueError("pubmlst_db must be provided.")
+
+    try:
+        outdir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise IOError(f"Could not create output directory {outdir}: {e}")
+
+    # Command construction
+    cmd = ["ariba", "pubmlstget"]
+    if force:
+        cmd.append("--force")
+    if noverify:
+        cmd.append("--noverify")
+    cmd.extend([pubmlst_db, str(outdir)])
+
+    # Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        output_files = [str(p) for p in outdir.rglob("*") if p.is_file()]
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA pubmlstget failed",
+            "return_code": e.returncode,
+        }
+
+@mcp.tool
+def getref(
+    ref_name: Literal[
+        "argannot", "card", "megares", "plasmidfinder", "resfinder",
+        "srst2_argannot", "vfdb_core", "vfdb_full", "virfinder"
+    ],
+    outdir: Path,
+    force: bool = False,
+    metadata_only: bool = False,
+):
+    """
+    Download reference data from NCBI/RefSeq or other sources.
+
+    Args:
+        ref_name: Name of reference data to download.
+        outdir: Output directory to save the reference data.
+        force: Overwrite existing files if they exist.
+        metadata_only: Only download metadata, not the sequences.
+    """
+    # Input validation
+    try:
+        outdir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise IOError(f"Could not create output directory {outdir}: {e}")
+
+    # Command construction
+    cmd = ["ariba", "getref"]
+    if force:
+        cmd.append("--force")
+    if metadata_only:
+        cmd.append("--metadata_only")
+    cmd.extend([ref_name, str(outdir)])
+
+    # Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        output_files = [str(p) for p in outdir.rglob("*") if p.is_file()]
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA getref failed",
+            "return_code": e.returncode,
+        }
+
+@mcp.tool
+def prepareref(
+    fasta_in: Path,
+    metadata_in: Path,
+    outdir: Path,
+    min_length: int = 1,
+    max_length: int = 10000,
+    max_n: int = 5,
+    no_cdhit: bool = False,
+    cdhit_clusters: Optional[Path] = None,
+    cdhit_threads: int = 1,
+    cdhit_mem: int = 400,
+    force: bool = False,
+    tmp_dir: Optional[Path] = None,
+    verbose: bool = False,
+    debug: bool = False,
+):
+    """
+    Prepare reference data for use with ARIBA.
+
+    Args:
+        fasta_in: Input FASTA file of sequences.
+        metadata_in: Input TSV file of metadata.
+        outdir: Output directory for prepared reference.
+        min_length: Minimum sequence length.
+        max_length: Maximum sequence length.
+        max_n: Maximum number of Ns allowed in a sequence.
+        no_cdhit: Do not run cd-hit.
+        cdhit_clusters: File of cd-hit clusters. Implies --no_cdhit.
+        cdhit_threads: Threads to use for cd-hit.
+        cdhit_mem: Memory for cd-hit in MB.
+        force: Overwrite existing files.
+        tmp_dir: Use this directory for temporary files.
+        verbose: Print STDOUT and STDERR from external programs.
+        debug: Print debugging messages.
+    """
+    # Input validation
+    if not fasta_in.is_file():
+        raise FileNotFoundError(f"Input FASTA file not found: {fasta_in}")
+    if not metadata_in.is_file():
+        raise FileNotFoundError(f"Input metadata file not found: {metadata_in}")
+    if cdhit_clusters and not cdhit_clusters.is_file():
+        raise FileNotFoundError(f"cd-hit clusters file not found: {cdhit_clusters}")
+    if min_length <= 0:
+        raise ValueError("min_length must be a positive integer.")
+    if cdhit_threads <= 0:
+        raise ValueError("cdhit_threads must be a positive integer.")
+
+    try:
+        outdir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise IOError(f"Could not create output directory {outdir}: {e}")
+
+    # Command construction
+    cmd = ["ariba", "prepareref",
+           "--fasta_in", str(fasta_in),
+           "--metadata_in", str(metadata_in),
+           "--outdir", str(outdir),
+           "--min_length", str(min_length),
+           "--max_length", str(max_length),
+           "--max_N", str(max_n),
+           "--cdhit_threads", str(cdhit_threads),
+           "--cdhit_mem", str(cdhit_mem)]
+
+    if no_cdhit:
+        cmd.append("--no_cdhit")
+    if cdhit_clusters:
+        cmd.extend(["--cdhit_clusters", str(cdhit_clusters)])
+    if force:
+        cmd.append("--force")
+    if tmp_dir:
+        cmd.extend(["--tmp_dir", str(tmp_dir)])
+    if verbose:
+        cmd.append("--verbose")
+    if debug:
+        cmd.append("--debug")
+
+    # Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        output_files = [str(p) for p in outdir.rglob("*") if p.is_file()]
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA prepareref failed",
+            "return_code": e.returncode,
+        }
+
+@mcp.tool
+def run(
+    ref_dir: Path,
+    reads1: Path,
+    reads2: Path,
+    outdir: Path,
+    assembly_cov: int = 10,
+    gene_cov_cutoff: float = 0.95,
+    gene_nt_extend: int = 10,
+    local_th: float = 0.9,
+    min_gene_cov: int = 1,
+    assembled_threshold: float = 0.95,
+    nucmer_min_id: int = 90,
+    nucmer_min_len: int = 50,
+    nucmer_breaklen: int = 10,
+    nucmer_max_gap: int = 20,
+    assembler: Literal["fermilite", "spades"] = "fermilite",
+    spades_options: str = "--careful",
+    threads: int = 1,
+    force: bool = False,
+    tmp_dir: Optional[Path] = None,
+    verbose: bool = False,
+    debug: bool = False,
+    noclean: bool = False,
+    unique_map_only: bool = False,
+    other_ref_fasta: Optional[Path] = None,
+    filestem: Optional[str] = None,
+):
+    """
+    Run the main ARIBA pipeline to identify genes from paired sequencing reads.
+
+    Args:
+        ref_dir: Reference directory, created by 'prepareref'.
+        reads1: First paired-end reads file.
+        reads2: Second paired-end reads file.
+        outdir: Output directory for results.
+        assembly_cov: Minimum coverage of internal contig flank.
+        gene_cov_cutoff: Minimum proportion of gene length covered by reads.
+        gene_nt_extend: Max nucleotides to extend assembly past gene ends.
+        local_th: Minimum proportion of bases in local assembly identical to reference.
+        min_gene_cov: Minimum read coverage depth on any base of a gene.
+        assembled_threshold: Minimum proportion of bases in a gene covered by local assembly.
+        nucmer_min_id: nucmer --minid option.
+        nucmer_min_len: nucmer --mincluster option.
+        nucmer_breaklen: nucmer --breaklen option.
+        nucmer_max_gap: nucmer --maxgap option.
+        assembler: Assembler to use.
+        spades_options: Options to pass to spades.
+        threads: Number of threads to use.
+        force: Overwrite existing output files.
+        tmp_dir: Use this directory for temporary files.
+        verbose: Print STDOUT and STDERR from external programs.
+        debug: Print debugging messages.
+        noclean: Do not clean up intermediate files.
+        unique_map_only: Only use uniquely mapping reads.
+        other_ref_fasta: FASTA file of other reference sequences (e.g., host genome).
+        filestem: Filestem to use for output files.
+    """
+    # Input validation
+    if not ref_dir.is_dir():
+        raise FileNotFoundError(f"Reference directory not found: {ref_dir}")
+    if not reads1.is_file():
+        raise FileNotFoundError(f"Reads file 1 not found: {reads1}")
+    if not reads2.is_file():
+        raise FileNotFoundError(f"Reads file 2 not found: {reads2}")
+    if other_ref_fasta and not other_ref_fasta.is_file():
+        raise FileNotFoundError(f"Other reference FASTA not found: {other_ref_fasta}")
+    if threads <= 0:
+        raise ValueError("threads must be a positive integer.")
+
+    try:
+        outdir.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise IOError(f"Could not create output directory {outdir}: {e}")
+
+    # Command construction
+    cmd = ["ariba", "run",
+           "--assembly_cov", str(assembly_cov),
+           "--gene_cov_cutoff", str(gene_cov_cutoff),
+           "--gene_nt_extend", str(gene_nt_extend),
+           "--local_th", str(local_th),
+           "--min_gene_cov", str(min_gene_cov),
+           "--assembled_threshold", str(assembled_threshold),
+           "--nucmer_min_id", str(nucmer_min_id),
+           "--nucmer_min_len", str(nucmer_min_len),
+           "--nucmer_breaklen", str(nucmer_breaklen),
+           "--nucmer_max_gap", str(nucmer_max_gap),
+           "--assembler", assembler,
+           "--spades_options", spades_options,
+           "--threads", str(threads)]
+
+    if force: cmd.append("--force")
+    if verbose: cmd.append("--verbose")
+    if debug: cmd.append("--debug")
+    if noclean: cmd.append("--noclean")
+    if unique_map_only: cmd.append("--unique_map_only")
+    if tmp_dir: cmd.extend(["--tmp_dir", str(tmp_dir)])
+    if other_ref_fasta: cmd.extend(["--other_ref_fasta", str(other_ref_fasta)])
+    if filestem: cmd.extend(["--filestem", filestem])
+
+    cmd.extend([str(ref_dir), str(reads1), str(reads2), str(outdir)])
+
+    # Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        output_files = [str(p) for p in outdir.rglob("*") if p.is_file()]
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA run failed",
+            "return_code": e.returncode,
+        }
+
+@mcp.tool
+def summary(
+    out_prefix: Path,
+    in_dirs: List[Path],
+    preset: Literal["all", "assembled", "flags", "variants"] = "all",
+    cluster_cols: Optional[str] = None,
+    col_sep: str = ".",
+    row_sep: str = ".",
+    force: bool = False,
+    verbose: bool = False,
+    debug: bool = False,
+):
+    """
+    Summarise multiple ARIBA reports into a single file.
+
+    Args:
+        out_prefix: Output file prefix.
+        in_dirs: List of directories containing ARIBA results.
+        preset: Output preset.
+        cluster_cols: Columns to use for clustering.
+        col_sep: Separator between column names in output file.
+        row_sep: Separator between sample name and cluster name in output file.
+        force: Overwrite existing files.
+        verbose: Print STDOUT and STDERR from external programs.
+        debug: Print debugging messages.
+    """
+    # Input validation
+    if not in_dirs:
+        raise ValueError("At least one input directory must be provided in in_dirs.")
+    for d in in_dirs:
+        if not d.is_dir():
+            raise FileNotFoundError(f"Input directory not found: {d}")
+        report_path = d / "report.tsv"
+        if not report_path.is_file():
+            raise FileNotFoundError(f"Expected report file not found in {d}: {report_path}")
+
+    try:
+        out_prefix.parent.mkdir(parents=True, exist_ok=True)
+    except Exception as e:
+        raise IOError(f"Could not create output directory {out_prefix.parent}: {e}")
+
+    # Command construction
+    cmd = ["ariba", "summary",
+           "--preset", preset,
+           "--col_sep", col_sep,
+           "--row_sep", row_sep]
+
+    if cluster_cols:
+        cmd.extend(["--cluster_cols", cluster_cols])
+    if force:
+        cmd.append("--force")
+    if verbose:
+        cmd.append("--verbose")
+    if debug:
+        cmd.append("--debug")
+
+    cmd.append(str(out_prefix))
+    cmd.extend([str(d) for d in in_dirs])
+
+    # Subprocess execution
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        output_files = [str(p) for p in out_prefix.parent.glob(f"{out_prefix.name}*")]
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA summary failed",
+            "return_code": e.returncode,
+        }
+
+@mcp.tool
+def version():
+    """
+    Print the ARIBA version number and exit.
+    """
+    cmd = ["ariba", "version"]
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "version": result.stdout.strip(),
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA version command failed",
+            "return_code": e.returncode,
+        }
+
+@mcp.tool
+def test():
+    """
+    Run the ARIBA test suite to verify installation and functionality.
+    """
+    cmd = ["ariba", "test"]
+    try:
+        # The test command can be long-running and produce a lot of output.
+        # We capture it as usual.
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "test_passed": "OK" in result.stderr,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("ariba command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "ARIBA test suite failed",
+            "return_code": e.returncode,
+        }

Biomni/mcp_generated/mcp_ariba/app/ariba_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_ariba/app/ariba_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_ariba'
+
+
+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_ariba/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_ariba/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-ariba:
+    build: .
+    image: mcp-ariba:latest
+    container_name: mcp-ariba
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=ariba
+    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_ariba/environment.yaml

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

Biomni/mcp_generated/mcp_ariba/requirements.txt

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

Biomni/mcp_generated/mcp_arvados-python-client/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 arvados-python-client via conda (e.g., from bioconda)
+RUN conda install -c bioconda arvados-python-client -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/arvados-python-client_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/arvados-python-client_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/arvados-python-client_server.py"]
+        

Biomni/mcp_generated/mcp_arvados-python-client/app/arvados-python-client_server.py

@@ -0,0 +1,306 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# MCP-standardized error handling
+class MCPError(Exception):
+    def __init__(self, message, stderr):
+        self.message = message
+        self.stderr = stderr
+        super().__init__(self.message)
+
+def _run_command(cmd: List[str]):
+    """Helper function to run a command and handle exceptions."""
+    try:
+        command_str = " ".join(cmd)
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_str,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except FileNotFoundError:
+        raise MCPError(f"Command '{cmd[0]}' not found. Is arvados-python-client installed and in the PATH?", "")
+    except subprocess.CalledProcessError as e:
+        raise MCPError(f"Command '{' '.join(cmd)}' failed with exit code {e.returncode}", e.stderr)
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_arvados_python_client'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def arv_get(
+    object_locator: str,
+    destination_path: Optional[Path] = None,
+    filename: Optional[str] = None,
+    force: bool = False,
+    recursive: bool = False,
+    progress: bool = False,
+) -> dict:
+    """
+    Downloads an object from Arvados Keep to a local path or standard output.
+
+    Args:
+        object_locator: The UUID or portable data hash (PDH) of the object to download.
+        destination_path: Local path to save the object. If a directory, the original filename is used. If not provided, content is written to stdout.
+        filename: The name of the file to get from a collection.
+        force: Overwrite existing files if they exist.
+        recursive: Recursively download collections.
+        progress: Show a progress bar during download.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list of output files.
+    """
+    cmd = ["arv-get"]
+
+    if force:
+        cmd.append("--force")
+    if recursive:
+        cmd.append("--recursive")
+    if progress:
+        cmd.append("--progress")
+    if filename:
+        cmd.extend(["--filename", filename])
+
+    cmd.append(object_locator)
+
+    output_files = []
+    if destination_path:
+        # Ensure parent directory exists if a full path is given
+        if destination_path.parent and not destination_path.parent.is_dir():
+            destination_path.parent.mkdir(parents=True, exist_ok=True)
+        cmd.append(str(destination_path))
+        output_files.append(str(destination_path))
+
+    try:
+        result = _run_command(cmd)
+        result["output_files"] = output_files
+        return result
+    except MCPError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": e.stderr,
+            "error": e.message,
+            "output_files": [],
+        }
+
+@mcp.tool()
+def arv_put(
+    paths: List[Path],
+    name: Optional[str] = None,
+    owner: Optional[str] = None,
+    portable_data_hash: bool = False,
+    storage_class: Optional[str] = None,
+    num_retries: int = 5,
+    progress: bool = False,
+) -> dict:
+    """
+    Uploads local files or directories to Arvados Keep.
+
+    Args:
+        paths: One or more local file or directory paths to upload.
+        name: Set the name of the new collection.
+        owner: Set the owner project UUID for the new collection.
+        portable_data_hash: Use portable data hash to identify the collection.
+        storage_class: The storage class for the data (e.g., 'default', 'trash').
+        num_retries: Number of times to retry a failed API call.
+        progress: Show a progress bar during upload.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    if not paths:
+        raise ValueError("At least one path must be provided for upload.")
+
+    for p in paths:
+        if not p.exists():
+            raise FileNotFoundError(f"Input path does not exist: {p}")
+
+    cmd = ["arv-put"]
+
+    if name:
+        cmd.extend(["--name", name])
+    if owner:
+        cmd.extend(["--owner", owner])
+    if portable_data_hash:
+        cmd.append("--portable-data-hash")
+    if storage_class:
+        cmd.extend(["--storage-class", storage_class])
+    if progress:
+        cmd.append("--progress")
+    
+    # num_retries is a standard arvados client option
+    cmd.extend(["--num-retries", str(num_retries)])
+
+    cmd.extend([str(p) for p in paths])
+
+    try:
+        result = _run_command(cmd)
+        result["output_files"] = []
+        return result
+    except MCPError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": e.stderr,
+            "error": e.message,
+            "output_files": [],
+        }
+
+@mcp.tool()
+def arv_ls(
+    object_locator: str,
+    path: Optional[str] = None,
+    long_format: bool = False,
+    recursive: bool = False,
+    human_readable: bool = False,
+) -> dict:
+    """
+    Lists the contents of a collection in Arvados Keep.
+
+    Args:
+        object_locator: The UUID or portable data hash (PDH) of the collection to list.
+        path: A path within the collection to list.
+        long_format: Use a long listing format (similar to ls -l).
+        recursive: List subdirectories recursively.
+        human_readable: With long_format, print sizes in human-readable format (e.g., 1K, 234M, 2G).
+
+    Returns:
+        A dictionary containing the command executed, stdout (the listing), and stderr.
+    """
+    cmd = ["arv-ls"]
+
+    if long_format:
+        cmd.append("-l")
+    if recursive:
+        cmd.append("-R")
+    if human_readable:
+        cmd.append("-h")
+
+    cmd.append(object_locator)
+    if path:
+        cmd.append(path)
+
+    try:
+        result = _run_command(cmd)
+        result["output_files"] = []
+        return result
+    except MCPError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": e.stderr,
+            "error": e.message,
+            "output_files": [],
+        }
+
+@mcp.tool()
+def arv_copy(
+    src_locators: List[str],
+    dest_project_uuid: str,
+    name: Optional[str] = None,
+    num_retries: int = 5,
+) -> dict:
+    """
+    Copies one or more objects to a destination project in Arvados.
+
+    Args:
+        src_locators: A list of source object UUIDs or portable data hashes (PDHs).
+        dest_project_uuid: The UUID of the destination project.
+        name: New name for the object(s). If copying multiple objects, this is ignored.
+        num_retries: Number of times to retry a failed API call.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    if not src_locators:
+        raise ValueError("At least one source locator must be provided.")
+    if not dest_project_uuid:
+        raise ValueError("A destination project UUID must be provided.")
+
+    cmd = ["arv-copy"]
+
+    if name and len(src_locators) == 1:
+        cmd.extend(["--name", name])
+    
+    cmd.extend(["--num-retries", str(num_retries)])
+    
+    cmd.extend(src_locators)
+    cmd.append(dest_project_uuid)
+
+    try:
+        result = _run_command(cmd)
+        result["output_files"] = []
+        return result
+    except MCPError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": e.stderr,
+            "error": e.message,
+            "output_files": [],
+        }
+
+@mcp.tool()
+def arv_tag(
+    locator: str,
+    tags_to_add: Optional[List[str]] = None,
+    keys_to_remove: Optional[List[str]] = None,
+    list_tags: bool = False,
+    num_retries: int = 5,
+) -> dict:
+    """
+    Manipulates tags on an Arvados object. It can list, add, or remove tags.
+
+    Args:
+        locator: The UUID or portable data hash (PDH) of the object to tag.
+        tags_to_add: A list of tags to add, in 'key' or 'key=value' format.
+        keys_to_remove: A list of tag keys to remove.
+        list_tags: If True, lists the existing tags on the object.
+        num_retries: Number of times to retry a failed API call.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    cmd = ["arv-tag"]
+    
+    cmd.extend(["--num-retries", str(num_retries)])
+
+    if list_tags:
+        cmd.append("--list")
+    
+    cmd.append(locator)
+
+    if tags_to_add:
+        for tag in tags_to_add:
+            if "=" not in tag and " " in tag:
+                raise ValueError(f"Invalid tag format: '{tag}'. Use 'key=value' or 'key'.")
+        cmd.extend(tags_to_add)
+
+    if keys_to_remove:
+        for key in keys_to_remove:
+            cmd.extend(["--remove", key])
+
+    try:
+        result = _run_command(cmd)
+        result["output_files"] = []
+        return result
+    except MCPError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": e.stderr,
+            "error": e.message,
+            "output_files": [],
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_arvados-python-client/app/arvados-python-client_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_arvados-python-client/app/arvados-python-client_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_arvados_python_client'
+
+
+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_arvados-python-client/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_arvados-python-client/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-arvados-python-client:
+    build: .
+    image: mcp-arvados-python-client:latest
+    container_name: mcp-arvados-python-client
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=arvados-python-client
+    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_arvados-python-client/environment.yaml

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

Biomni/mcp_generated/mcp_arvados-python-client/requirements.txt

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

Biomni/mcp_generated/mcp_bbmap/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bbmap:
+    build: .
+    image: mcp-bbmap:latest
+    container_name: mcp-bbmap
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bbmap
+    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_bbmap/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-affy/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-affy via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-affy -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-affy_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-affy_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-affy_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-affy/app/bioconductor-affy_server.py

@@ -0,0 +1,196 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, Dict, List
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+def tool(func):
+    def wrapper(*args, **kwargs):
+        # In a real scenario, the MCP framework would handle
+        # registration and execution.
+        return func(*args, **kwargs)
+    return wrapper
+mcp = type("mcp", (), {"tool": tool})
+
+
+@mcp.tool
+def run_affy_analysis(
+    cel_files_dir: Path,
+    output_expression_file: Path,
+    method: str = "rma",
+    pheno_data_file: Optional[Path] = None,
+    generate_qc_plot: bool = False,
+    qc_plot_file: Optional[Path] = None,
+) -> Dict:
+    """
+    Performs exploratory analysis of Affymetrix oligonucleotide arrays.
+
+    This tool reads raw Affymetrix data from .CEL files, performs background
+    correction, normalization, and probe summarization using either the RMA
+    (Robust Multi-array Average) or MAS 5.0 algorithm, and outputs a matrix
+    of expression values.
+
+    Args:
+        cel_files_dir: Path to the directory containing the input .CEL files.
+        output_expression_file: Path to write the output expression matrix (tab-separated).
+        method: The processing method to use. Must be one of 'rma' or 'mas5'.
+                Defaults to 'rma'.
+        pheno_data_file: Optional path to a phenodata file describing the samples.
+                         This should be a tab-delimited file with row names matching
+                         the .CEL file names.
+        generate_qc_plot: If True, generate a quality control boxplot of the raw
+                          probe intensities. Defaults to False.
+        qc_plot_file: Path to save the QC plot image (e.g., plot.png).
+                      Required if generate_qc_plot is True.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a
+        list of output files.
+    """
+    # 1. Input Validation
+    if not cel_files_dir.is_dir():
+        raise ValueError(f"Input directory '{cel_files_dir}' does not exist or is not a directory.")
+
+    if pheno_data_file and not pheno_data_file.is_file():
+        raise FileNotFoundError(f"Phenodata file '{pheno_data_file}' not found.")
+
+    method_lower = method.lower()
+    if method_lower not in ["rma", "mas5"]:
+        raise ValueError(f"Invalid method '{method}'. Must be 'rma' or 'mas5'.")
+
+    if generate_qc_plot:
+        if qc_plot_file is None:
+            raise ValueError("qc_plot_file must be provided when generate_qc_plot is True.")
+        if not qc_plot_file.parent.exists():
+            qc_plot_file.parent.mkdir(parents=True, exist_ok=True)
+    elif qc_plot_file is not None:
+        print(f"Warning: qc_plot_file '{qc_plot_file}' is specified but generate_qc_plot is False. The file will not be created.")
+
+    if not output_expression_file.parent.exists():
+        output_expression_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. R Script Generation
+    # This script will be executed by Rscript to perform the analysis.
+    r_script_content = f"""
+    # Load necessary libraries
+    if (!requireNamespace("affy", quietly = TRUE)) {{
+        stop("The 'affy' package is not installed. Please install it from Bioconductor.")
+    }}
+    library(affy)
+
+    # Parse command-line arguments
+    args <- commandArgs(trailingOnly = TRUE)
+    if (length(args) < 3) {{
+      stop("Usage: Rscript script.R <cel_dir> <output_path> <method> [pheno_path_or_NA] [plot_path_or_NA]", call. = FALSE)
+    }}
+
+    cel_dir <- args[1]
+    output_path <- args[2]
+    method <- args[3]
+    pheno_path <- if (length(args) >= 4 && args[4] != "NA") args[4] else NULL
+    plot_path <- if (length(args) >= 5 && args[5] != "NA") args[5] else NULL
+
+    # --- Main Logic ---
+    tryCatch({{
+        # Read the data
+        cat("Reading CEL files from:", cel_dir, "\\n")
+        if (!is.null(pheno_path)) {{
+          cat("Using pheno data from:", pheno_path, "\\n")
+          # read.AnnotatedDataFrame is deprecated, using read.phenoData is more modern
+          pheno <- read.phenoData(pheno_path, header = TRUE, row.names = 1)
+          data <- ReadAffy(celfile.path = cel_dir, phenoData = pheno)
+        }} else {{
+          data <- ReadAffy(celfile.path = cel_dir)
+        }}
+        cat("Finished reading data.\\n")
+
+        # Process the data
+        cat("Processing data with method:", method, "\\n")
+        if (method == "rma") {{
+          eset <- rma(data)
+        }} else if (method == "mas5") {{
+          eset <- mas5(data)
+        }} else {{
+          stop(paste("Invalid method specified:", method))
+        }}
+        cat("Finished processing.\\n")
+
+        # Extract and write expression values
+        cat("Writing expression matrix to:", output_path, "\\n")
+        expression_matrix <- exprs(eset)
+        write.table(expression_matrix, file = output_path, sep = "\\t", quote = FALSE, col.names = NA)
+        cat("Done writing expression matrix.\\n")
+
+        # Generate QC plot if requested
+        if (!is.null(plot_path)) {{
+          cat("Generating QC plot at:", plot_path, "\\n")
+          png(filename = plot_path, width = 800, height = 600)
+          boxplot(data, main = "Raw Probe Intensities", las = 2, col="lightblue")
+          dev.off()
+          cat("Done generating plot.\\n")
+        }}
+
+        cat("Analysis complete.\\n")
+    }}, error = function(e) {{
+        cat("An error occurred:\\n")
+        cat(conditionMessage(e), "\\n")
+        quit(status = 1)
+    }})
+    """
+
+    # 3. Subprocess Execution
+    output_files = {"expression_matrix": str(output_expression_file)}
+    cmd = ["Rscript"]
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R") as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        # Prepare arguments for the R script
+        pheno_path_arg = str(pheno_data_file.resolve()) if pheno_data_file else "NA"
+        plot_path_arg = str(qc_plot_file.resolve()) if generate_qc_plot and qc_plot_file else "NA"
+        
+        cmd.extend([
+            r_script_path,
+            str(cel_files_dir.resolve()),
+            str(output_expression_file.resolve()),
+            method_lower,
+            pheno_path_arg,
+            plot_path_arg
+        ])
+
+        # Execute the command
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True
+        )
+
+        if generate_qc_plot and qc_plot_file:
+            output_files["qc_plot"] = str(qc_plot_file)
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": output_files
+        }
+
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": {}
+        }
+    except Exception as e:
+        raise e
+    finally:
+        # Clean up the temporary R script file
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()

Biomni/mcp_generated/mcp_bioconductor-affy/app/bioconductor-affy_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_bioconductor-affy/app/bioconductor-affy_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_affy'
+
+
+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-affy/environment.yaml

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

Biomni/mcp_generated/mcp_bioconductor-affy/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-alabaster.sfe/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-alabaster.sfe via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-alabaster.sfe -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-alabaster.sfe_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-alabaster.sfe_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-alabaster.sfe_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-alabaster.sfe/app/bioconductor-alabaster.sfe_server.py

@@ -0,0 +1,221 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# It is assumed that the mcp decorator is available in the execution environment.
+# from mcp import tool
+
+# Mock decorator for local testing, not to be included in the final deliverable
+# if 'mcp' not in globals():
+#     class mcp:
+#         @staticmethod
+#         def tool():
+#             def decorator(func):
+#                 return func
+#             return decorator
+
+logger = logging.getLogger(__name__)
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_alabaster_sfe'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def stage_sfe_object(
+    input_rds: Path,
+    output_dir: Path,
+    path: str = "sfe",
+) -> Dict[str, Any]:
+    """
+    Stages a SpatialFeatureExperiment (SFE) object from an RDS file into the alabaster format.
+
+    This tool wraps the 'stageObject' function from the R package 'alabaster.sfe'.
+    It reads an SFE object from a specified RDS file and saves it into a structured
+    directory according to the alabaster specification. This serves as the primary
+    "save" or "serialize" function for SFE objects in the alabaster framework.
+
+    Args:
+        input_rds: Path to the input RDS file containing the SpatialFeatureExperiment object.
+        output_dir: Path to the directory where the staged object assets will be stored.
+        path: The relative path within 'output_dir' to save the object. Defaults to "sfe".
+
+    Returns:
+        A dictionary containing the execution details and the path to the main output metadata file.
+    """
+    # 1. Input Validation
+    if not input_rds.is_file():
+        raise FileNotFoundError(f"Input RDS file not found at: {input_rds}")
+
+    if not path:
+        raise ValueError("'path' cannot be an empty string.")
+
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        raise OSError(f"Failed to create output directory {output_dir}: {e}")
+
+    # 2. R script construction
+    r_script_content = f"""
+    suppressPackageStartupMessages(library(alabaster.sfe))
+    suppressPackageStartupMessages(library(SpatialFeatureExperiment))
+
+    tryCatch({{
+        sfe_object <- readRDS('{input_rds.resolve()}')
+        info <- alabaster.base::stageObject(sfe_object, dir = '{output_dir.resolve()}', path = '{path}')
+        cat(file.path('{output_dir.resolve()}', info$path, "object.json"))
+    }}, error = function(e) {{
+        message("Error during R script execution: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # 3. Subprocess Execution
+    cmd = ["Rscript", "-e", r_script_content]
+    command_executed = " ".join(map(str, cmd))
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+
+        stdout = process.stdout.strip()
+        stderr = process.stderr.strip()
+
+        main_output_file = Path(stdout)
+        if not main_output_file.is_file():
+            raise FileNotFoundError(
+                f"Expected output file not created: {main_output_file}. R stderr: {stderr}"
+            )
+
+        return {
+            "command_executed": command_executed,
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": {
+                "staged_object_json": str(main_output_file)
+            }
+        }
+
+    except FileNotFoundError:
+        error_msg = "Error: 'Rscript' command not found. Please ensure R is installed and in your system's PATH."
+        logger.error(error_msg)
+        raise RuntimeError(error_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Command failed with exit code {e.returncode}")
+        logger.error(f"STDOUT: {e.stdout}")
+        logger.error(f"STDERR: {e.stderr}")
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"STDOUT: {e.stdout}\n"
+            f"STDERR: {e.stderr}"
+        ) from e
+
+@mcp.tool()
+def load_sfe_object(
+    staged_dir: Path,
+    output_rds: Path,
+    path: str = "",
+) -> Dict[str, Any]:
+    """
+    Loads a SpatialFeatureExperiment (SFE) object from the alabaster format into an RDS file.
+
+    This tool wraps the 'loadObject' function from the R package 'alabaster.base'.
+    It reads an SFE object from a staged directory, reconstructs it in memory, and
+    saves the complete object as a single RDS file. This is the "load" or "deserialize"
+    counterpart to the staging function.
+
+    Args:
+        staged_dir: Path to the directory containing the staged object assets.
+        output_rds: Path for the output RDS file where the loaded SFE object will be saved.
+        path: The relative path within 'staged_dir' where the object's 'object.json' is located.
+              If empty, it's assumed to be at the root of 'staged_dir'.
+
+    Returns:
+        A dictionary containing the execution details and the path to the output RDS file.
+    """
+    # 1. Input Validation
+    if not staged_dir.is_dir():
+        raise NotADirectoryError(f"Staged asset directory not found at: {staged_dir}")
+
+    metadata_json_path = staged_dir.joinpath(path, "object.json")
+    if not metadata_json_path.is_file():
+        raise FileNotFoundError(f"Metadata file 'object.json' not found at: {metadata_json_path}")
+
+    try:
+        output_rds.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        raise OSError(f"Failed to create output directory {output_rds.parent}: {e}")
+
+    # 2. R script construction
+    r_script_content = f"""
+    suppressPackageStartupMessages(library(alabaster.sfe))
+    suppressPackageStartupMessages(library(SpatialFeatureExperiment))
+
+    tryCatch({{
+        sfe_object <- alabaster.base::loadObject(
+            '{metadata_json_path.resolve()}',
+            project = '{staged_dir.resolve()}'
+        )
+        saveRDS(sfe_object, file = '{output_rds.resolve()}')
+        cat('{output_rds.resolve()}')
+    }}, error = function(e) {{
+        message("Error during R script execution: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # 3. Subprocess Execution
+    cmd = ["Rscript", "-e", r_script_content]
+    command_executed = " ".join(map(str, cmd))
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+
+        stdout = process.stdout.strip()
+        stderr = process.stderr.strip()
+
+        output_file = Path(stdout)
+        if not output_file.is_file() or output_file != output_rds.resolve():
+            raise FileNotFoundError(
+                f"Expected output RDS file not created at {output_rds}. R stderr: {stderr}"
+            )
+
+        return {
+            "command_executed": command_executed,
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": {
+                "output_rds": str(output_file)
+            }
+        }
+
+    except FileNotFoundError:
+        error_msg = "Error: 'Rscript' command not found. Please ensure R is installed and in your system's PATH."
+        logger.error(error_msg)
+        raise RuntimeError(error_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Command failed with exit code {e.returncode}")
+        logger.error(f"STDOUT: {e.stdout}")
+        logger.error(f"STDERR: {e.stderr}")
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"STDOUT: {e.stdout}\n"
+            f"STDERR: {e.stderr}"
+        ) from e
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-alabaster.sfe/app/bioconductor-alabaster.sfe_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_bioconductor-alabaster.sfe/app/bioconductor-alabaster.sfe_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_alabaster_sfe'
+
+
+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-alabaster.sfe/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-alabaster.sfe/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bioconductor-alabaster.sfe:
+    build: .
+    image: mcp-bioconductor-alabaster.sfe:latest
+    container_name: mcp-bioconductor-alabaster.sfe
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bioconductor-alabaster.sfe
+    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_bioconductor-alabaster.sfe/environment.yaml

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

Biomni/mcp_generated/mcp_bioconductor-alabaster.sfe/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-biocneighbors/environment.yaml

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

Biomni/mcp_generated/mcp_bioconductor-biocneighbors/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-biocsingular/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-biocsingular via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-biocsingular -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 bioconductor-biocsingular_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-biocsingular_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-biocsingular_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-biocsingular/app/bioconductor-biocsingular_server.py

@@ -0,0 +1,224 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_biocsingular'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def biocsingular_run_svd(
+    input_path: str,
+    output_prefix: str,
+    k: int = 5,
+    nu: int = 5,
+    nv: int = 5,
+    algorithm: str = "Irlba",
+    center: bool = True,
+    scale: bool = False,
+    deferred: bool = False,
+) -> Dict[str, Any]:
+    """
+    Perform Singular Value Decomposition (SVD) on a matrix using BiocSingular.
+    Supports various algorithms including Exact, Irlba, and Random SVD.
+
+    Args:
+        input_path: Path to the input matrix file (CSV, TSV, or RDS format).
+        output_prefix: Prefix for the output files (will create .rds and .csv files).
+        k: Number of singular values to compute.
+        nu: Number of left singular vectors to compute.
+        nv: Number of right singular vectors to compute.
+        algorithm: SVD algorithm to use ('Exact', 'Irlba', 'Random', 'FastDot').
+        center: Whether to center the columns of the matrix.
+        scale: Whether to scale the columns of the matrix.
+        deferred: Whether to use deferred centering and scaling (memory efficient).
+    """
+    input_file = Path(input_path)
+    if not input_file.exists():
+        return {"error": f"Input file not found: {input_path}"}
+
+    # Validate algorithm
+    valid_algos = ["Exact", "Irlba", "Random", "FastDot"]
+    if algorithm not in valid_algos:
+        return {"error": f"Invalid algorithm. Must be one of: {', '.join(valid_algos)}"}
+
+    # Construct R script
+    r_script = f"""
+    library(BiocSingular)
+    
+    # Load data
+    ext <- tolower(tools::file_ext("{input_path}"))
+    if (ext == "rds") {{
+        mat <- readRDS("{input_path}")
+    }} else if (ext == "csv") {{
+        mat <- as.matrix(read.csv("{input_path}", row.names=1))
+    }} else {{
+        mat <- as.matrix(read.table("{input_path}", sep="\\t", header=TRUE, row.names=1))
+    }}
+    
+    # Set parameter object
+    param <- {algorithm}Param(deferred = {"TRUE" if deferred else "FALSE"})
+    
+    # Run SVD
+    res <- runSVD(
+        mat, 
+        k = {k}, 
+        nu = {nu}, 
+        nv = {nv}, 
+        BSPARAM = param, 
+        center = {"TRUE" if center else "FALSE"}, 
+        scale = {"TRUE" if scale else "FALSE"}
+    )
+    
+    # Save results
+    saveRDS(res, "{output_prefix}_svd.rds")
+    write.csv(res$u, "{output_prefix}_u.csv")
+    write.csv(res$v, "{output_prefix}_v.csv")
+    write.csv(data.frame(d=res$d), "{output_prefix}_d.csv")
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        output_files = [
+            f"{output_prefix}_svd.rds",
+            f"{output_prefix}_u.csv",
+            f"{output_prefix}_v.csv",
+            f"{output_prefix}_d.csv"
+        ]
+
+        return {
+            "command_executed": f"BiocSingular::runSVD via Rscript",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(Path(f).absolute()) for f in output_files if Path(f).exists()]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def biocsingular_run_pca(
+    input_path: str,
+    output_prefix: str,
+    rank: int = 5,
+    algorithm: str = "Irlba",
+    center: bool = True,
+    scale: bool = False,
+    deferred: bool = False,
+) -> Dict[str, Any]:
+    """
+    Perform Principal Component Analysis (PCA) on a matrix using BiocSingular.
+    Optimized for large-scale genomic data.
+
+    Args:
+        input_path: Path to the input matrix file (CSV, TSV, or RDS format).
+        output_prefix: Prefix for the output files.
+        rank: Number of principal components to compute.
+        algorithm: PCA algorithm to use ('Exact', 'Irlba', 'Random', 'FastDot').
+        center: Whether to center the columns.
+        scale: Whether to scale the columns.
+        deferred: Whether to use deferred centering and scaling.
+    """
+    input_file = Path(input_path)
+    if not input_file.exists():
+        return {"error": f"Input file not found: {input_path}"}
+
+    valid_algos = ["Exact", "Irlba", "Random", "FastDot"]
+    if algorithm not in valid_algos:
+        return {"error": f"Invalid algorithm. Must be one of: {', '.join(valid_algos)}"}
+
+    r_script = f"""
+    library(BiocSingular)
+    
+    # Load data
+    ext <- tolower(tools::file_ext("{input_path}"))
+    if (ext == "rds") {{
+        mat <- readRDS("{input_path}")
+    }} else if (ext == "csv") {{
+        mat <- as.matrix(read.csv("{input_path}", row.names=1))
+    }} else {{
+        mat <- as.matrix(read.table("{input_path}", sep="\\t", header=TRUE, row.names=1))
+    }}
+    
+    # Set parameter object
+    param <- {algorithm}Param(deferred = {"TRUE" if deferred else "FALSE"})
+    
+    # Run PCA
+    res <- runPCA(
+        mat, 
+        rank = {rank}, 
+        BSPARAM = param, 
+        center = {"TRUE" if center else "FALSE"}, 
+        scale = {"TRUE" if scale else "FALSE"}
+    )
+    
+    # Save results
+    saveRDS(res, "{output_prefix}_pca.rds")
+    write.csv(res$x, "{output_prefix}_pcs.csv")
+    write.csv(res$rotation, "{output_prefix}_loadings.csv")
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        output_files = [
+            f"{output_prefix}_pca.rds",
+            f"{output_prefix}_pcs.csv",
+            f"{output_prefix}_loadings.csv"
+        ]
+
+        return {
+            "command_executed": f"BiocSingular::runPCA via Rscript",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(Path(f).absolute()) for f in output_files if Path(f).exists()]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def biocsingular_get_info() -> Dict[str, Any]:
+    """
+    Check if BiocSingular is installed and return version information.
+    """
+    r_script = "library(BiocSingular); cat(as.character(packageVersion('BiocSingular')))"
+    
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "biocsingular_version": result.stdout.strip(),
+            "status": "installed"
+        }
+    except subprocess.CalledProcessError:
+        return {
+            "status": "not_found",
+            "error": "BiocSingular is not installed in the R environment."
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-biocsingular/app/bioconductor-biocsingular_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-biocsingular/app/bioconductor-biocsingular_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_biocsingular'
+
+
+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-biocsingular/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bioconductor-biocsingular:
+    build: .
+    image: mcp-bioconductor-biocsingular:latest
+    container_name: mcp-bioconductor-biocsingular
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bioconductor-biocsingular
+    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_bioconductor-biocsingular/environment.yaml

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

Biomni/mcp_generated/mcp_bioconductor-biocsingular/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-bulksignalr/app/bioconductor-bulksignalr_server.py

@@ -0,0 +1,473 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+# This is a placeholder for the MCP decorator.
+# The actual MCP environment will provide this.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(func):
+            return func
+        return decorator
+
+# --- R Script Templates ---
+
+R_SCRIPT_BULK_DE = """
+# Load libraries
+suppressPackageStartupMessages(library(argparse))
+suppressPackageStartupMessages(library(bulksignalr))
+suppressPackageStartupMessages(library(SingleCellExperiment))
+suppressPackageStartupMessages(library(Matrix))
+
+# Create a parser
+parser <- ArgumentParser(description = "Run bulksignalr bulk_de")
+
+# Add arguments
+parser$add_argument("--counts", type = "character", required = TRUE, help = "Path to the counts matrix file (TSV format)")
+parser$add_argument("--metadata", type = "character", required = TRUE, help = "Path to the metadata file (TSV format)")
+parser$add_argument("--output", type = "character", required = TRUE, help = "Path to the output DE results file (TSV format)")
+parser$add_argument("--design", type = "character", required = TRUE, help = "Design formula for the model (e.g., '~ 0 + group')")
+parser$add_argument("--sample_col", type = "character", default = "sample", help = "Column name for samples in metadata")
+parser$add_argument("--group_col", type = "character", default = "group", help = "Column name for groups in metadata")
+parser$add_argument("--lfc_threshold", type = "double", default = 0, help = "Log-fold change threshold")
+parser$add_argument("--fdr_threshold", type = "double", default = 0.05, help = "FDR threshold")
+parser$add_argument("--min_cells", type = "integer", default = 3, help = "Minimum number of cells expressing a gene")
+parser$add_argument("--min_samples", type = "integer", default = 2, help = "Minimum number of samples in a group")
+parser$add_argument("--n_cores", type = "integer", default = 1, help = "Number of cores to use")
+
+# Parse arguments
+args <- parser$parse_args()
+
+# Read data
+counts <- read.csv(args$counts, sep = "\\t", row.names = 1, check.names = FALSE)
+counts_matrix <- as.matrix(counts)
+metadata <- read.csv(args$metadata, sep = "\\t", row.names = 1, check.names = FALSE)
+
+# Ensure metadata rows match counts columns
+if (!all(colnames(counts_matrix) %in% rownames(metadata))) {
+    stop("Not all column names in the counts matrix are present as row names in the metadata.")
+}
+metadata <- metadata[colnames(counts_matrix), , drop = FALSE]
+
+# Create SingleCellExperiment object
+sce <- SingleCellExperiment(assays = list(counts = counts_matrix),
+                            colData = metadata)
+
+# Run bulk_de
+de_results <- bulk_de(
+    object = sce,
+    design = as.formula(args$design),
+    sample_col = args$sample_col,
+    group_col = args$group_col,
+    lfc_threshold = args$lfc_threshold,
+    fdr_threshold = args$fdr_threshold,
+    min_cells = args$min_cells,
+    min_samples = args$min_samples,
+    n_cores = args$n_cores
+)
+
+# Save results
+write.table(de_results, file = args$output, sep = "\\t", row.names = FALSE, quote = FALSE)
+
+cat("bulk_de analysis completed successfully.\\n")
+"""
+
+R_SCRIPT_BULK_WALK = """
+# Load libraries
+suppressPackageStartupMessages(library(argparse))
+suppressPackageStartupMessages(library(bulksignalr))
+suppressPackageStartupMessages(library(SingleCellExperiment))
+suppressPackageStartupMessages(library(Matrix))
+
+# Create a parser
+parser <- ArgumentParser(description = "Run bulksignalr bulk_walk")
+
+# Add arguments
+parser$add_argument("--counts", type = "character", required = TRUE, help = "Path to the counts matrix file (TSV format)")
+parser$add_argument("--metadata", type = "character", required = TRUE, help = "Path to the metadata file (TSV format)")
+parser$add_argument("--de_results", type = "character", required = TRUE, help = "Path to the DE results file from bulk_de (TSV format)")
+parser$add_argument("--output", type = "character", required = TRUE, help = "Path to the output co-regulation results file (TSV format)")
+parser$add_argument("--sample_col", type = "character", default = "sample", help = "Column name for samples in metadata")
+parser$add_argument("--group_col", type = "character", default = "group", help = "Column name for groups in metadata")
+parser$add_argument("--cor_method", type = "character", choices = c("spearman", "pearson"), default = "spearman", help = "Correlation method")
+parser$add_argument("--cor_threshold", type = "double", default = 0.4, help = "Correlation threshold")
+parser$add_argument("--n_cores", type = "integer", default = 1, help = "Number of cores to use")
+
+# Parse arguments
+args <- parser$parse_args()
+
+# Read data
+counts <- read.csv(args$counts, sep = "\\t", row.names = 1, check.names = FALSE)
+counts_matrix <- as.matrix(counts)
+metadata <- read.csv(args$metadata, sep = "\\t", row.names = 1, check.names = FALSE)
+de_results <- read.csv(args$de_results, sep = "\\t", check.names = FALSE)
+
+# Ensure metadata rows match counts columns
+if (!all(colnames(counts_matrix) %in% rownames(metadata))) {
+    stop("Not all column names in the counts matrix are present as row names in the metadata.")
+}
+metadata <- metadata[colnames(counts_matrix), , drop = FALSE]
+
+# Create SingleCellExperiment object
+sce <- SingleCellExperiment(assays = list(counts = counts_matrix),
+                            colData = metadata)
+colData(sce)[[args$sample_col]] <- colData(sce)[[args$sample_col]]
+colData(sce)[[args$group_col]] <- colData(sce)[[args$group_col]]
+
+# Run bulk_walk
+walk_results <- bulk_walk(
+    object = sce,
+    de_results = de_results,
+    sample_col = args$sample_col,
+    group_col = args$group_col,
+    cor_method = args$cor_method,
+    cor_threshold = args$cor_threshold,
+    n_cores = args$n_cores
+)
+
+# Save results
+write.table(walk_results, file = args$output, sep = "\\t", row.names = FALSE, quote = FALSE)
+
+cat("bulk_walk analysis completed successfully.\\n")
+"""
+
+R_SCRIPT_SIGNAL_WALK = """
+# Load libraries
+suppressPackageStartupMessages(library(argparse))
+suppressPackageStartupMessages(library(bulksignalr))
+suppressPackageStartupMessages(library(SingleCellExperiment))
+suppressPackageStartupMessages(library(Matrix))
+
+# Create a parser
+parser <- ArgumentParser(description = "Run bulksignalr signal_walk")
+
+# Add arguments
+parser$add_argument("--counts", type = "character", required = TRUE, help = "Path to the counts matrix file (TSV format)")
+parser$add_argument("--metadata", type = "character", required = TRUE, help = "Path to the metadata file (TSV format)")
+parser$add_argument("--bulk_walk_results", type = "character", required = TRUE, help = "Path to the bulk_walk results file (TSV format)")
+parser$add_argument("--output", type = "character", required = TRUE, help = "Path to the output signaling results file (TSV format)")
+parser$add_argument("--sample_col", type = "character", default = "sample", help = "Column name for samples in metadata")
+parser$add_argument("--group_col", type = "character", default = "group", help = "Column name for groups in metadata")
+parser$add_argument("--lr_db", type = "character", default = NULL, help = "Optional path to a custom ligand-receptor database file (TSV format)")
+parser$add_argument("--n_perms", type = "integer", default = 1000, help = "Number of permutations for significance testing")
+parser$add_argument("--n_cores", type = "integer", default = 1, help = "Number of cores to use")
+
+# Parse arguments
+args <- parser$parse_args()
+
+# Read data
+counts <- read.csv(args$counts, sep = "\\t", row.names = 1, check.names = FALSE)
+counts_matrix <- as.matrix(counts)
+metadata <- read.csv(args$metadata, sep = "\\t", row.names = 1, check.names = FALSE)
+bulk_walk_results <- read.csv(args$bulk_walk_results, sep = "\\t", check.names = FALSE)
+
+# Load ligand-receptor database
+if (!is.null(args$lr_db)) {
+    lr_db <- read.csv(args$lr_db, sep = "\\t", check.names = FALSE)
+} else {
+    lr_db <- bulksignalr::lr_db
+}
+
+# Ensure metadata rows match counts columns
+if (!all(colnames(counts_matrix) %in% rownames(metadata))) {
+    stop("Not all column names in the counts matrix are present as row names in the metadata.")
+}
+metadata <- metadata[colnames(counts_matrix), , drop = FALSE]
+
+# Create SingleCellExperiment object
+sce <- SingleCellExperiment(assays = list(counts = counts_matrix),
+                            colData = metadata)
+colData(sce)[[args$sample_col]] <- colData(sce)[[args$sample_col]]
+colData(sce)[[args$group_col]] <- colData(sce)[[args$group_col]]
+
+# Run signal_walk
+signal_results <- signal_walk(
+    object = sce,
+    bulk_walk_results = bulk_walk_results,
+    ligand_receptor_db = lr_db,
+    sample_col = args$sample_col,
+    group_col = args$group_col,
+    n_perms = args$n_perms,
+    n_cores = args$n_cores
+)
+
+# Save results
+write.table(signal_results, file = args$output, sep = "\\t", row.names = FALSE, quote = FALSE)
+
+cat("signal_walk analysis completed successfully.\\n")
+"""
+
+# --- MCP Tools ---
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_bulksignalr'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bulk_de(
+    counts_file: Path,
+    metadata_file: Path,
+    design: str,
+    output_file: Path,
+    sample_col: str = "sample",
+    group_col: str = "group",
+    lfc_threshold: float = 0.0,
+    fdr_threshold: float = 0.05,
+    min_cells: int = 3,
+    min_samples: int = 2,
+    n_cores: int = 1,
+):
+    """
+    Performs differential expression analysis using bulksignalr::bulk_de.
+
+    This tool requires an R environment with the 'bulksignalr', 'SingleCellExperiment',
+    'Matrix', and 'argparse' packages installed.
+
+    Args:
+        counts_file: Path to the counts matrix file (TSV format, genes as rows, cells/samples as columns).
+        metadata_file: Path to the metadata file (TSV format, cells/samples as rows).
+        design: Design formula for the model (e.g., '~ 0 + group').
+        output_file: Path to save the differential expression results (TSV format).
+        sample_col: Column name for samples in the metadata file.
+        group_col: Column name for groups in the metadata file.
+        lfc_threshold: Log-fold change threshold for differential expression.
+        fdr_threshold: False discovery rate (FDR) threshold.
+        min_cells: Minimum number of cells a gene must be expressed in to be included.
+        min_samples: Minimum number of samples required within a group for comparison.
+        n_cores: Number of CPU cores to use for parallel processing.
+    """
+    # Input validation
+    if not counts_file.is_file():
+        raise FileNotFoundError(f"Counts file not found: {counts_file}")
+    if not metadata_file.is_file():
+        raise FileNotFoundError(f"Metadata file not found: {metadata_file}")
+    if not design.strip():
+        raise ValueError("Design formula cannot be empty.")
+    if not (0 <= fdr_threshold <= 1):
+        raise ValueError("fdr_threshold must be between 0 and 1.")
+    if lfc_threshold < 0:
+        raise ValueError("lfc_threshold must be non-negative.")
+    if min_cells < 0:
+        raise ValueError("min_cells must be non-negative.")
+    if min_samples < 1:
+        raise ValueError("min_samples must be at least 1.")
+    if n_cores < 1:
+        raise ValueError("n_cores must be at least 1.")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    r_script_path = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R") as r_script_file:
+            r_script_file.write(R_SCRIPT_BULK_DE)
+            r_script_path = r_script_file.name
+
+        cmd = [
+            "Rscript", r_script_path,
+            "--counts", str(counts_file),
+            "--metadata", str(metadata_file),
+            "--output", str(output_file),
+            "--design", design,
+            "--sample_col", sample_col,
+            "--group_col", group_col,
+            "--lfc_threshold", str(lfc_threshold),
+            "--fdr_threshold", str(fdr_threshold),
+            "--min_cells", str(min_cells),
+            "--min_samples", str(min_samples),
+            "--n_cores", str(n_cores),
+        ]
+
+        process = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_file)],
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with return code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+    finally:
+        if r_script_path and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+
+@mcp.tool()
+def bulk_walk(
+    counts_file: Path,
+    metadata_file: Path,
+    de_results_file: Path,
+    output_file: Path,
+    sample_col: str = "sample",
+    group_col: str = "group",
+    cor_method: str = "spearman",
+    cor_threshold: float = 0.4,
+    n_cores: int = 1,
+):
+    """
+    Identifies co-regulated gene clusters using bulksignalr::bulk_walk.
+
+    This tool requires an R environment with the 'bulksignalr', 'SingleCellExperiment',
+    'Matrix', and 'argparse' packages installed.
+
+    Args:
+        counts_file: Path to the counts matrix file (TSV format).
+        metadata_file: Path to the metadata file (TSV format).
+        de_results_file: Path to the differential expression results file from `bulk_de`.
+        output_file: Path to save the co-regulation cluster results (TSV format).
+        sample_col: Column name for samples in the metadata file.
+        group_col: Column name for groups in the metadata file.
+        cor_method: Correlation method to use ('spearman' or 'pearson').
+        cor_threshold: Correlation threshold for defining co-regulation.
+        n_cores: Number of CPU cores to use for parallel processing.
+    """
+    # Input validation
+    if not counts_file.is_file():
+        raise FileNotFoundError(f"Counts file not found: {counts_file}")
+    if not metadata_file.is_file():
+        raise FileNotFoundError(f"Metadata file not found: {metadata_file}")
+    if not de_results_file.is_file():
+        raise FileNotFoundError(f"DE results file not found: {de_results_file}")
+    if cor_method not in ["spearman", "pearson"]:
+        raise ValueError("cor_method must be either 'spearman' or 'pearson'.")
+    if not (0 <= cor_threshold <= 1):
+        raise ValueError("cor_threshold must be between 0 and 1.")
+    if n_cores < 1:
+        raise ValueError("n_cores must be at least 1.")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    r_script_path = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R") as r_script_file:
+            r_script_file.write(R_SCRIPT_BULK_WALK)
+            r_script_path = r_script_file.name
+
+        cmd = [
+            "Rscript", r_script_path,
+            "--counts", str(counts_file),
+            "--metadata", str(metadata_file),
+            "--de_results", str(de_results_file),
+            "--output", str(output_file),
+            "--sample_col", sample_col,
+            "--group_col", group_col,
+            "--cor_method", cor_method,
+            "--cor_threshold", str(cor_threshold),
+            "--n_cores", str(n_cores),
+        ]
+
+        process = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_file)],
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with return code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+    finally:
+        if r_script_path and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+
+@mcp.tool()
+def signal_walk(
+    counts_file: Path,
+    metadata_file: Path,
+    bulk_walk_results_file: Path,
+    output_file: Path,
+    sample_col: str = "sample",
+    group_col: str = "group",
+    ligand_receptor_db_file: Optional[Path] = None,
+    n_perms: int = 1000,
+    n_cores: int = 1,
+):
+    """
+    Identifies potential signaling genes using bulksignalr::signal_walk.
+
+    This tool requires an R environment with the 'bulksignalr', 'SingleCellExperiment',
+    'Matrix', and 'argparse' packages installed.
+
+    Args:
+        counts_file: Path to the counts matrix file (TSV format).
+        metadata_file: Path to the metadata file (TSV format).
+        bulk_walk_results_file: Path to the co-regulation results from `bulk_walk`.
+        output_file: Path to save the signaling analysis results (TSV format).
+        sample_col: Column name for samples in the metadata file.
+        group_col: Column name for groups in the metadata file.
+        ligand_receptor_db_file: Optional path to a custom ligand-receptor database (TSV).
+                                 If not provided, the built-in database is used.
+        n_perms: Number of permutations for significance testing.
+        n_cores: Number of CPU cores to use for parallel processing.
+    """
+    # Input validation
+    if not counts_file.is_file():
+        raise FileNotFoundError(f"Counts file not found: {counts_file}")
+    if not metadata_file.is_file():
+        raise FileNotFoundError(f"Metadata file not found: {metadata_file}")
+    if not bulk_walk_results_file.is_file():
+        raise FileNotFoundError(f"bulk_walk results file not found: {bulk_walk_results_file}")
+    if ligand_receptor_db_file and not ligand_receptor_db_file.is_file():
+        raise FileNotFoundError(f"Ligand-receptor DB file not found: {ligand_receptor_db_file}")
+    if n_perms < 1:
+        raise ValueError("n_perms must be at least 1.")
+    if n_cores < 1:
+        raise ValueError("n_cores must be at least 1.")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    r_script_path = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R") as r_script_file:
+            r_script_file.write(R_SCRIPT_SIGNAL_WALK)
+            r_script_path = r_script_file.name
+
+        cmd = [
+            "Rscript", r_script_path,
+            "--counts", str(counts_file),
+            "--metadata", str(metadata_file),
+            "--bulk_walk_results", str(bulk_walk_results_file),
+            "--output", str(output_file),
+            "--sample_col", sample_col,
+            "--group_col", group_col,
+            "--n_perms", str(n_perms),
+            "--n_cores", str(n_cores),
+        ]
+        if ligand_receptor_db_file:
+            cmd.extend(["--lr_db", str(ligand_receptor_db_file)])
+
+        process = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_file)],
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with return code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+    finally:
+        if r_script_path and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-clusterprofiler/app/bioconductor-clusterprofiler_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_bioconductor-clusterprofiler/app/bioconductor-clusterprofiler_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_clusterprofiler'
+
+
+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-genomeinfodb/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-genomeinfodb via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-genomeinfodb -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-genomeinfodb_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-genomeinfodb_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-genomeinfodb_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-genomeinfodb/app/bioconductor-genomeinfodb_server.py

@@ -0,0 +1,325 @@
+import subprocess
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Optional, List, Dict
+import sys
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Mock the mcp.tool decorator for standalone execution
+class mcp:
+    def tool(func):
+        return func
+
+def _check_rscript():
+    """Checks if Rscript is available in the system PATH."""
+    if not shutil.which("Rscript"):
+        raise EnvironmentError(
+            "Rscript not found in PATH. R and the GenomeInfoDb Bioconductor "
+            "package are required to run these tools."
+        )
+
+@mcp.tool
+def genomeinfodb_list_styles(species: str) -> Dict:
+    """
+    Lists the available chromosome naming styles (e.g., UCSC, NCBI) for a given species.
+
+    This tool wraps the `genomeStyles()` function from the R/Bioconductor GenomeInfoDb package.
+
+    Args:
+        species: The scientific name of the species (e.g., "Homo sapiens", "Mus musculus").
+
+    Returns:
+        A dictionary containing the command executed, stdout (with the list of styles),
+        stderr, and a list of available styles.
+    """
+    _check_rscript()
+    if not species:
+        raise ValueError("The 'species' argument cannot be empty.")
+
+    r_script_content = f"""
+    suppressPackageStartupMessages(library(GenomeInfoDb))
+    tryCatch({{
+        styles <- genomeStyles('{species}')
+        if (length(styles) == 0) {{
+            cat("No styles found for species: {species}\\n", file=stderr())
+        }} else {{
+            cat(paste(names(styles), collapse='\\n'))
+        }}
+    }}, error = function(e) {{
+        cat(paste("Error:", e$message, "\\n"), file=stderr())
+        quit(status = 1)
+    }})
+    """
+
+    command = ["Rscript", "-e", r_script_content]
+    command_executed = " ".join(command)
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        styles_list = result.stdout.strip().split('\n') if result.stdout.strip() else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "styles": styles_list,
+        }
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error executing GenomeInfoDb R script: {e.stderr}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Failed to list genome styles. Check if the species name is correct and GenomeInfoDb is installed.",
+        }
+
+@mcp.tool
+def genomeinfodb_map_seqlevels(
+    target_style: str,
+    species: str,
+    input_file: Path,
+    output_file: Path,
+) -> Dict:
+    """
+    Maps chromosome names from an input file to a specified naming convention (style).
+
+    This tool wraps the `mapSeqlevels()` function from the R/Bioconductor GenomeInfoDb package.
+    It produces a two-column TSV file: 'original' and 'mapped'.
+
+    Args:
+        target_style: The target naming style (e.g., "UCSC", "NCBI", "Ensembl").
+        species: The scientific name of the species (e.g., "Homo sapiens").
+        input_file: Path to a file containing one chromosome name per line.
+        output_file: Path to write the output TSV file with original and mapped names.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the path to the output file.
+    """
+    _check_rscript()
+    if not target_style:
+        raise ValueError("The 'target_style' argument cannot be empty.")
+    if not species:
+        raise ValueError("The 'species' argument cannot be empty.")
+    if not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    r_script_content = f"""
+    suppressPackageStartupMessages(library(GenomeInfoDb))
+    args <- commandArgs(trailingOnly=TRUE)
+    inputFile <- args[1]
+    targetStyle <- args[2]
+    species <- args[3]
+    outputFile <- args[4]
+
+    tryCatch({{
+        seqs <- readLines(inputFile)
+        if (length(seqs) == 0) {{
+            stop("Input file is empty.")
+        }}
+        mapped_seqs <- mapSeqlevels(seqs, style=targetStyle, species=species)
+        output_df <- data.frame(original=seqs, mapped=mapped_seqs)
+        write.table(output_df, file=outputFile, sep='\\t', row.names=FALSE, col.names=TRUE, quote=FALSE)
+    }}, error = function(e) {{
+        cat(paste("Error:", e$message, "\\n"), file=stderr())
+        quit(status = 1)
+    }})
+    """
+
+    command = [
+        "Rscript",
+        "-e",
+        r_script_content,
+        str(input_file),
+        target_style,
+        species,
+        str(output_file),
+    ]
+    command_executed = " ".join(command)
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {"mapped_seqlevels": str(output_file)},
+        }
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error executing GenomeInfoDb R script: {e.stderr}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Failed to map seqlevels. Check parameters and ensure input file is correctly formatted.",
+        }
+
+@mcp.tool
+def genomeinfodb_get_seqinfo(
+    genome: str,
+    output_file: Path,
+) -> Dict:
+    """
+    Fetches sequence information (lengths, circularity) for a given genome assembly.
+
+    This tool wraps the `Seqinfo()` constructor from the R/Bioconductor GenomeInfoDb package.
+    It produces a TSV file containing seqnames, seqlengths, isCircular, and genome.
+
+    Args:
+        genome: The genome assembly identifier (e.g., "hg19", "hg38", "mm10").
+        output_file: Path to write the output TSV file with sequence information.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the path to the output file.
+    """
+    _check_rscript()
+    if not genome:
+        raise ValueError("The 'genome' argument cannot be empty.")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    r_script_content = f"""
+    suppressPackageStartupMessages(library(GenomeInfoDb))
+    args <- commandArgs(trailingOnly=TRUE)
+    genome_id <- args[1]
+    outputFile <- args[2]
+
+    tryCatch({{
+        si <- Seqinfo(genome=genome_id)
+        si_df <- as.data.frame(si)
+        write.table(si_df, file=outputFile, sep='\\t', row.names=TRUE, col.names=NA, quote=FALSE)
+    }}, error = function(e) {{
+        cat(paste("Error:", e$message, "\\n"), file=stderr())
+        quit(status = 1)
+    }})
+    """
+
+    command = ["Rscript", "-e", r_script_content, genome, str(output_file)]
+    command_executed = " ".join(command)
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {"seqinfo": str(output_file)},
+        }
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error executing GenomeInfoDb R script: {e.stderr}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Failed to get seqinfo. Check if the genome identifier is correct.",
+        }
+
+@mcp.tool
+def genomeinfodb_rename_seqlevels(
+    input_file: Path,
+    mapping_file: Path,
+    output_file: Path,
+) -> Dict:
+    """
+    Renames chromosome names from an input file based on a provided mapping file.
+
+    This tool wraps the `renameSeqlevels()` function from the R/Bioconductor GenomeInfoDb package.
+    It produces a two-column TSV file: 'original' and 'renamed'.
+
+    Args:
+        input_file: Path to a file containing one chromosome name per line.
+        mapping_file: Path to a two-column TSV file (old_name<tab>new_name) without a header.
+        output_file: Path to write the output TSV file with original and renamed names.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the path to the output file.
+    """
+    _check_rscript()
+    if not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if not mapping_file.is_file():
+        raise FileNotFoundError(f"Mapping file not found: {mapping_file}")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    r_script_content = f"""
+    suppressPackageStartupMessages(library(GenomeInfoDb))
+    args <- commandArgs(trailingOnly=TRUE)
+    inputFile <- args[1]
+    mappingFile <- args[2]
+    outputFile <- args[3]
+
+    tryCatch({{
+        seqs <- readLines(inputFile)
+        if (length(seqs) == 0) {{
+            stop("Input file is empty.")
+        }}
+        mapping_df <- read.table(mappingFile, sep='\\t', header=FALSE, stringsAsFactors=FALSE, col.names=c("old", "new"))
+        if (nrow(mapping_df) == 0) {{
+            stop("Mapping file is empty.")
+        }}
+        value <- setNames(mapping_df$new, mapping_df$old)
+        renamed_seqs <- renameSeqlevels(seqs, value)
+        output_df <- data.frame(original=seqs, renamed=renamed_seqs)
+        write.table(output_df, file=outputFile, sep='\\t', row.names=FALSE, col.names=TRUE, quote=FALSE)
+    }}, error = function(e) {{
+        cat(paste("Error:", e$message, "\\n"), file=stderr())
+        quit(status = 1)
+    }})
+    """
+
+    command = [
+        "Rscript",
+        "-e",
+        r_script_content,
+        str(input_file),
+        str(mapping_file),
+        str(output_file),
+    ]
+    command_executed = " ".join(command)
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {"renamed_seqlevels": str(output_file)},
+        }
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Error executing GenomeInfoDb R script: {e.stderr}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Failed to rename seqlevels. Check file formats and content.",
+        }

Biomni/mcp_generated/mcp_bioconductor-genomeinfodb/app/bioconductor-genomeinfodb_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_bioconductor-genomeinfodb/app/bioconductor-genomeinfodb_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_genomeinfodb'
+
+
+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-genomeinfodb/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-genomeinfodb/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bioconductor-genomeinfodb:
+    build: .
+    image: mcp-bioconductor-genomeinfodb:latest
+    container_name: mcp-bioconductor-genomeinfodb
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bioconductor-genomeinfodb
+    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_bioconductor-genomeinfodb/environment.yaml

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

Biomni/mcp_generated/mcp_bioconductor-genomeinfodb/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-ggtree/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-ggtree via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-ggtree -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-ggtree_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-ggtree_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-ggtree_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-ggtree/app/bioconductor-ggtree_server.py

@@ -0,0 +1,216 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_ggtree'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_ggtree_script(
+    r_script_content: str,
+    input_tree_file: Optional[Path] = None,
+    input_annotation_file: Optional[Path] = None,
+    output_image_format: str = "png",
+    image_width: int = 800,
+    image_height: int = 600,
+    output_filename_prefix: str = "ggtree_plot",
+) -> Dict[str, Any]:
+    """
+    Executes a custom R script using the bioconductor-ggtree package for phylogenetic tree visualization.
+
+    This tool provides a flexible way to leverage ggtree's capabilities by allowing
+    users to provide arbitrary R code. It also facilitates common tasks like
+    loading tree and annotation files and saving plots.
+
+    Note: The 'bioconductor-ggtree' package is an R library and does not expose
+    direct command-line functions or subcommands. This MCP tool provides a
+    generic R script execution environment where 'ggtree' and its dependencies
+    are available. Users are expected to provide R code that utilizes 'ggtree'
+    functions.
+
+    Args:
+        r_script_content: A string containing the R code to execute. This script
+                          should assume 'ggtree', 'treeio', 'ggplot2', and 'dplyr'
+                          are loaded. It can access input files via variables
+                          `input_tree_file` and `input_annotation_file` (which
+                          will contain the POSIX paths as strings). The script
+                          should write any desired output files to the current
+                          working directory.
+        input_tree_file: Optional path to a phylogenetic tree file (e.g., Newick, Nexus).
+                         If provided, its POSIX path will be available as the
+                         `input_tree_file` variable in the R script.
+        input_annotation_file: Optional path to an annotation data file (e.g., CSV, TSV).
+                               If provided, its POSIX path will be available as the
+                               `input_annotation_file` variable in the R script.
+        output_image_format: The desired format for the output image. Supported: "png", "pdf", "svg", "jpeg", "tiff", "bmp".
+                             This format will be used for the default `ggsave` call
+                             if a ggplot object `p` is found and not explicitly saved
+                             by `r_script_content`.
+        image_width: Width of the output image. For raster formats (png, jpeg, etc.),
+                     this is in pixels. For vector formats (pdf, svg), this is
+                     converted to inches (assuming 96 DPI for conversion from pixels).
+        image_height: Height of the output image. Similar to `image_width`.
+        output_filename_prefix: A prefix for the output image file. The full filename
+                                will be '{prefix}.{format}'. This is used for the
+                                default `ggsave` call.
+
+    Returns:
+        A dictionary containing:
+        - command_executed: The Rscript command that was run.
+        - stdout: Standard output from the R script.
+        - stderr: Standard error from the R script.
+        - output_files: A list of paths to any generated output files.
+        - error: An error message if the R script execution failed.
+    """
+    # Input validation
+    if not r_script_content.strip():
+        raise ValueError("r_script_content cannot be empty.")
+
+    if input_tree_file:
+        if not input_tree_file.is_file():
+            raise FileNotFoundError(f"Input tree file not found: {input_tree_file}")
+        input_tree_file_posix = input_tree_file.as_posix()
+    else:
+        input_tree_file_posix = ""
+
+    if input_annotation_file:
+        if not input_annotation_file.is_file():
+            raise FileNotFoundError(f"Input annotation file not found: {input_annotation_file}")
+        input_annotation_file_posix = input_annotation_file.as_posix()
+    else:
+        input_annotation_file_posix = ""
+
+    supported_formats = {"png", "pdf", "svg", "jpeg", "tiff", "bmp"}
+    if output_image_format.lower() not in supported_formats:
+        raise ValueError(f"Unsupported output image format: {output_image_format}. "
+                         f"Supported formats are: {', '.join(supported_formats)}")
+
+    if image_width <= 0:
+        raise ValueError("Image width must be a positive integer.")
+    if image_height <= 0:
+        raise ValueError("Image height must be a positive integer.")
+    if not output_filename_prefix:
+        raise ValueError("Output filename prefix cannot be empty.")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        work_dir = Path(tmpdir)
+        
+        # Define output image path for default ggsave
+        output_image_name = f"{output_filename_prefix}.{output_image_format.lower()}"
+        
+        # Construct the R script
+        r_code = f"""
+        # Load necessary libraries
+        suppressPackageStartupMessages(library(ggtree))
+        suppressPackageStartupMessages(library(treeio))
+        suppressPackageStartupMessages(library(ggplot2))
+        suppressPackageStartupMessages(library(dplyr)) # Often useful for data manipulation
+
+        # Set working directory for outputs
+        setwd("{work_dir.as_posix()}")
+
+        # Make input file paths available as R variables
+        input_tree_file <- if ("{input_tree_file_posix}" != "") {{
+            "{input_tree_file_posix}"
+        }} else {{
+            NULL
+        }}
+        input_annotation_file <- if ("{input_annotation_file_posix}" != "") {{
+            "{input_annotation_file_posix}"
+        }} else {{
+            NULL
+        }}
+
+        # Parameters for default ggsave
+        output_image_name_param <- "{output_image_name}"
+        image_width_param <- {image_width}
+        image_height_param <- {image_height}
+        output_image_format_param <- "{output_image_format.lower()}"
+
+        # Determine units and DPI for ggsave based on format
+        units_val <- "in" # Default for vector graphics
+        dpi_val <- NULL   # Default for vector graphics
+        
+        if (output_image_format_param %in% c("png", "jpeg", "tiff", "bmp")) {{
+            units_val <- "px"
+            dpi_val <- 300 # Common DPI for raster images
+        }} else {{ # pdf, svg, etc.
+            # Convert pixels to inches for vector formats if input was in pixels
+            # Assuming 96 DPI for screen pixels to inches conversion if no specific DPI is given
+            image_width_param <- image_width_param / 96
+            image_height_param <- image_height_param / 96
+        }}
+
+        # User-provided R script content
+        # This is where the user's custom ggtree logic should go.
+        # The user's script can use 'input_tree_file', 'input_annotation_file',
+        # 'output_image_name_param', 'image_width_param', 'image_height_param',
+        # 'units_val', 'dpi_val' if they wish to override or extend the default
+        # saving behavior.
+        {r_script_content}
+
+        # Attempt to save the last ggplot object 'p' if it exists and
+        # the user's script hasn't explicitly saved a plot with the default name.
+        # This provides a fallback for simple plotting tasks.
+        if (exists("p") && inherits(p, "ggplot")) {{
+            if (!file.exists(output_image_name_param)) {{ # Only save if user script didn't already save to this name
+                message(paste0("Saving ggplot object 'p' to ", output_image_name_param, " using default parameters."))
+                ggsave(output_image_name_param, plot = p, width = image_width_param, height = image_height_param, units = units_val, dpi = dpi_val)
+            }} else {{
+                message(paste0("File '", output_image_name_param, "' already exists. Skipping default ggsave."))
+            }}
+        }} else {{
+            message("No 'p' (ggplot object) found or saved by user script. No default image output will be generated.")
+        }}
+        """
+
+        r_script_file = work_dir / "run_ggtree.R"
+        r_script_file.write_text(r_code)
+
+        command = ["Rscript", r_script_file.as_posix()]
+
+        # Execute the R script
+        try:
+            process = subprocess.run(
+                command,
+                cwd=work_dir,
+                capture_output=True,
+                text=True,
+                check=True,
+                env=os.environ # Inherit environment to ensure R is found
+            )
+            stdout = process.stdout
+            stderr = process.stderr
+        except subprocess.CalledProcessError as e:
+            return {
+                "command_executed": " ".join(command),
+                "stdout": e.stdout,
+                "stderr": e.stderr,
+                "output_files": [],
+                "error": f"Rscript execution failed with exit code {e.returncode}",
+            }
+        except FileNotFoundError:
+            return {
+                "command_executed": " ".join(command),
+                "stdout": "",
+                "stderr": "Rscript command not found. Is R installed and in PATH?",
+                "output_files": [],
+                "error": "Rscript executable not found.",
+            }
+
+        # Collect output files
+        output_files = [f.as_posix() for f in work_dir.iterdir() if f.is_file() and f != r_script_file]
+
+        return {
+            "command_executed": " ".join(command),
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": output_files,
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-ggtree/app/bioconductor-ggtree_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_bioconductor-ggtree/app/bioconductor-ggtree_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_ggtree'
+
+
+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-ggtree/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-ggtree/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bioconductor-ggtree:
+    build: .
+    image: mcp-bioconductor-ggtree:latest
+    container_name: mcp-bioconductor-ggtree
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bioconductor-ggtree
+    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
+