Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_bioawk/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 bioawk via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioawk -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/bioawk_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/bioawk_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/bioawk_server.py"]
+        

Biomni/mcp_generated/mcp_bioawk/app/bioawk_server.py

@@ -0,0 +1,132 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# Assume 'mcp' is a globally available module in the execution environment.
+# from some_mcp_library import mcp
+
+@mcp.tool
+def bioawk(
+    program: Optional[str] = None,
+    program_file: Optional[Path] = None,
+    input_files: Optional[List[Path]] = None,
+    output_file: Optional[Path] = None,
+    format: Optional[str] = None,
+    tab_separator: bool = False,
+    include_header: bool = False,
+    variables: Optional[List[str]] = None,
+    field_separator: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Executes the bioawk command, a powerful stream editor for biological data formats.
+
+    bioawk is an extension of awk that understands common biological data formats
+    like FASTA, FASTQ, SAM, VCF, BED, and GFF. At least one of 'program' or
+    'program_file' must be provided.
+
+    Args:
+        program: The AWK program string to execute. Mutually exclusive with 'program_file'.
+        program_file: Path to a file containing the AWK program. Mutually exclusive with 'program'.
+        input_files: A list of input files to process. If not provided, bioawk reads from standard input.
+        output_file: Path to a file where the output (stdout) will be saved. If not provided, stdout is captured and returned.
+        format: Input format (-c). Supported formats include 'fasta', 'fastq', 'sam', 'vcf', 'bed', 'gff'.
+        tab_separator: Use tab as the input and output field separator (-t flag).
+        include_header: Include header in the output for formats like VCF/SAM (-H flag).
+        variables: A list of 'var=value' strings to define AWK variables (-v flag).
+        field_separator: The input field separator string (-F flag).
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not program and not program_file:
+        raise ValueError("Either 'program' or 'program_file' must be provided.")
+    if program and program_file:
+        raise ValueError("'program' and 'program_file' are mutually exclusive and cannot be used together.")
+
+    if program_file:
+        if not program_file.is_file():
+            raise FileNotFoundError(f"Program file not found: {program_file}")
+
+    if input_files:
+        for file_path in input_files:
+            if not file_path.is_file():
+                raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    VALID_FORMATS = {"fasta", "fastq", "sam", "vcf", "bed", "gff"}
+    if format and format.lower() not in VALID_FORMATS:
+        raise ValueError(f"Invalid format '{format}'. Must be one of {VALID_FORMATS}.")
+
+    if variables:
+        for var in variables:
+            if "=" not in var:
+                raise ValueError(f"Invalid variable assignment '{var}'. Must be in 'var=value' format.")
+
+    # --- Command Construction ---
+    cmd = ["bioawk"]
+
+    if format:
+        cmd.extend(["-c", format.lower()])
+    if tab_separator:
+        cmd.append("-t")
+    if include_header:
+        cmd.append("-H")
+    if field_separator:
+        cmd.extend(["-F", field_separator])
+    if variables:
+        for var in variables:
+            cmd.extend(["-v", var])
+
+    # The program or program_file argument must come after options but before input files.
+    if program_file:
+        cmd.extend(["-f", str(program_file)])
+    elif program:
+        cmd.append(program)
+
+    if input_files:
+        cmd.extend([str(p) for p in input_files])
+
+    command_executed = " ".join(cmd)
+
+    # --- Subprocess Execution ---
+    try:
+        if output_file:
+            # Create parent directories if they don't exist
+            output_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_file, "w") as f_out:
+                result = subprocess.run(
+                    cmd,
+                    check=True,
+                    stdout=f_out,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                )
+            stdout_content = f"Output successfully written to {output_file}"
+            output_files_list = [str(output_file)]
+        else:
+            result = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            stdout_content = result.stdout
+            output_files_list = []
+
+        return {
+            "command_executed": command_executed,
+            "stdout": stdout_content,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("bioawk command not found. Please ensure it is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        # Return a structured error response if the command fails
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or f"bioawk exited with error code {e.returncode}",
+            "output_files": [],
+            "error": f"Command failed with exit code {e.returncode}"
+        }

Biomni/mcp_generated/mcp_bioawk/app/bioawk_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_bioawk/app/bioawk_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioawk'
+
+
+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_bioawk/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioawk/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioawk/requirements.txt

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

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

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-ancombc/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-bsgenome/app/bioconductor-bsgenome_server.py

@@ -0,0 +1,204 @@
+import subprocess
+import tempfile
+import shutil
+import re
+from pathlib import Path
+from typing import Optional, List
+
+# This is a placeholder for the actual decorator.
+# In a real MCP environment, you would use `@mcp.tool()`.
+def mcp_tool_placeholder(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+@mcp_tool_placeholder()
+def forge_bsgenome_data_pkg(
+    organism: str,
+    common_name: str,
+    organism_abbreviation: str,
+    provider: str,
+    provider_version: str,
+    release_date: str,
+    package_version: str,
+    author: str,
+    maintainer: str,
+    seqs_srcdir: Path,
+    output_pkg_path: Path,
+    circ_seqs: Optional[List[str]] = None,
+    seqfiles_prefix: Optional[str] = None,
+    seqfiles_suffix: Optional[str] = None,
+    license_str: str = "Artistic-2.0",
+    title: Optional[str] = None,
+    description: Optional[str] = None,
+    organism_biocview: Optional[str] = None,
+) -> dict:
+    """
+    Creates a Bioconductor BSgenome data package from a set of FASTA files.
+
+    This tool wraps the `forgeBSgenomeDataPkg` function from the R/Bioconductor
+    BSgenome package. It automates the creation of the necessary seed file and
+    executes an R script to build the package source directory, which is then
+    returned as a gzipped tarball.
+
+    Args:
+        organism: Full organism name (e.g., "Homo sapiens").
+        common_name: Common name for the organism (e.g., "Human").
+        organism_abbreviation: Abbreviation for the organism, used in package naming (e.g., "Hsapiens").
+        provider: Source of the genome data (e.g., "UCSC").
+        provider_version: Version or build of the genome from the provider (e.g., "hg38").
+        release_date: Release date of the genome build (e.g., "Dec. 2013").
+        package_version: Version for the new BSgenome package, in X.Y.Z format (e.g., "1.0.0").
+        author: The author of this BSgenome package.
+        maintainer: The maintainer of the package, including email (e.g., "Your Name <you@example.com>").
+        seqs_srcdir: Input directory containing the genome sequence files (e.g., FASTA files).
+        output_pkg_path: Path to save the final gzipped tarball of the package source (e.g., 'MyPackage.tar.gz').
+        circ_seqs: Optional list of sequence names that are circular (e.g., ["chrM"]).
+        seqfiles_prefix: Optional prefix for the sequence files within `seqs_srcdir`.
+        seqfiles_suffix: Optional suffix for the sequence files (e.g., ".fa", ".fasta").
+        license_str: The license for the generated package.
+        title: Optional title for the package. A default will be generated if not provided.
+        description: Optional description for the package. A default will be generated if not provided.
+        organism_biocview: Optional Bioconductor view term for the organism (e.g., "Homo_sapiens").
+    
+    Returns:
+        A dictionary containing the execution details and path to the output file.
+    """
+    # 1. Input Validation
+    if not seqs_srcdir.is_dir():
+        raise ValueError(f"Input directory '{seqs_srcdir}' does not exist or is not a directory.")
+    if not re.match(r"^\d+\.\d+\.\d+$", package_version):
+        raise ValueError(f"Package version '{package_version}' is not in X.Y.Z format.")
+    for name_part in [organism_abbreviation, provider]:
+        if not name_part.isalnum():
+             raise ValueError(f"Package name component '{name_part}' contains invalid characters. Use only alphanumerics.")
+    if not output_pkg_path.parent.exists():
+        output_pkg_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. Generate derived values
+    sanitized_provider_version = re.sub(r'[^a-zA-Z0-9.]', '', provider_version)
+    package_name = f"BSgenome.{organism_abbreviation}.{provider}.{sanitized_provider_version}"
+    bsgenome_objname = organism_abbreviation
+
+    if title is None:
+        title = f"Full genome sequences for {organism} ({provider} version {provider_version})"
+    if description is None:
+        description = (
+            f"Full genome sequences for {organism} ({common_name}) as provided by "
+            f"{provider} ({provider_version}, {release_date}) and stored in Biostrings objects."
+        )
+    
+    organism_biocview_val = organism_biocview if organism_biocview else organism.replace(" ", "_")
+
+    # 3. Create seed file content
+    seed_content = [
+        f"Package: {package_name}",
+        f"Title: {title}",
+        f"Description: {description}",
+        f"Version: {package_version}",
+        f"Author: {author}",
+        f"Maintainer: {maintainer}",
+        f"License: {license_str}",
+        f"organism: {organism}",
+        f"common_name: {common_name}",
+        f"provider: {provider}",
+        f"provider_version: {provider_version}",
+        f"release_date: {release_date}",
+        f"BSgenomeObjname: {bsgenome_objname}",
+        f"organism_biocview: {organism_biocview_val}",
+        f"seqs_srcdir: {seqs_srcdir.resolve()}",
+    ]
+
+    if circ_seqs:
+        r_vector = ', '.join(f'"{seq}"' for seq in circ_seqs)
+        seed_content.append(f"circ_seqs: c({r_vector})")
+    if seqfiles_prefix:
+        seed_content.append(f"seqfiles_prefix: {seqfiles_prefix}")
+    if seqfiles_suffix:
+        seed_content.append(f"seqfiles_suffix: {seqfiles_suffix}")
+
+    seed_file_text = "\n".join(seed_content)
+
+    # 4. Create R script
+    r_script_text = f"""
+    # Ensure BiocManager and BSgenome are installed
+    if (!requireNamespace("BiocManager", quietly = TRUE)) {{
+        install.packages("BiocManager", repos="http://cran.us.r-project.org")
+    }}
+    if (!requireNamespace("BSgenome", quietly = TRUE)) {{
+        BiocManager::install("BSgenome", update=FALSE, ask=FALSE)
+    }}
+
+    library(BSgenome)
+
+    # Forge the package
+    tryCatch({{
+        forgeBSgenomeDataPkg(seed_file="seed.txt", destdir=".")
+        cat("BSgenome package '{package_name}' successfully forged.\\n")
+    }}, error = function(e) {{
+        cat("Error during package forging:\\n")
+        cat(conditionMessage(e), "\\n")
+        quit(status = 1)
+    }})
+    """
+
+    # 5. Execute in a temporary directory
+    with tempfile.TemporaryDirectory() as tmpdir:
+        work_dir = Path(tmpdir)
+        seed_file_path = work_dir / "seed.txt"
+        r_script_path = work_dir / "run_forge.R"
+
+        seed_file_path.write_text(seed_file_text)
+        r_script_path.write_text(r_script_text)
+
+        cmd = ["Rscript", str(r_script_path)]
+        command_executed = " ".join(cmd)
+
+        try:
+            process = subprocess.run(
+                cmd,
+                cwd=work_dir,
+                check=True,
+                capture_output=True,
+                text=True,
+                encoding='utf-8',
+            )
+
+            # 6. Package the result
+            created_pkg_dir = work_dir / package_name
+            if not created_pkg_dir.is_dir():
+                raise FileNotFoundError(
+                    f"BSgenome package directory '{package_name}' was not created. "
+                    f"Check R script output for errors.\nStderr: {process.stderr}"
+                )
+
+            archive_base_name = str(output_pkg_path.with_suffix(''))
+            archive_path_str = shutil.make_archive(
+                base_name=archive_base_name,
+                format='gztar',
+                root_dir=work_dir,
+                base_dir=package_name
+            )
+            
+            final_archive_path = Path(archive_path_str)
+            if final_archive_path != output_pkg_path:
+                final_archive_path.rename(output_pkg_path)
+
+            return {
+                "command_executed": command_executed,
+                "stdout": process.stdout,
+                "stderr": process.stderr,
+                "output_files": {"bsgenome_package_archive": str(output_pkg_path)}
+            }
+
+        except subprocess.CalledProcessError as e:
+            # Using .decode() in case the output is not valid utf-8 on error
+            stdout = e.stdout if isinstance(e.stdout, str) else e.stdout.decode('utf-8', errors='replace')
+            stderr = e.stderr if isinstance(e.stderr, str) else e.stderr.decode('utf-8', errors='replace')
+            return {
+                "command_executed": command_executed,
+                "stdout": stdout,
+                "stderr": stderr,
+                "error": "R script execution failed.",
+                "return_code": e.returncode,
+            }

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

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

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

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

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

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

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

Biomni/mcp_generated/mcp_bioconductor-go.db/app/bioconductor-go.db_server.py

@@ -0,0 +1,196 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# MCP decorator is not imported as per instructions.
+# It is assumed to be available in the execution environment.
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_go_db'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def list_go_db_columns() -> Dict[str, Any]:
+    """
+    Lists all available columns for querying in the Bioconductor GO.db.
+
+    This function executes an R script to load the GO.db package and
+    extract the names of all queryable columns. It is useful for discovering
+    what data can be retrieved using the `query_go_db` function.
+
+    Requirements:
+    - R must be installed and in the system's PATH.
+    - The R packages 'BiocManager', 'AnnotationDbi', and 'GO.db' must be installed.
+      (e.g., in R: BiocManager::install(c("AnnotationDbi", "GO.db")))
+    """
+    r_script = "library(GO.db); cat(columns(GO.db), sep='\\n')"
+    command = ["Rscript", "-e", r_script]
+    command_executed = " ".join(command)
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        # The columns are returned as a newline-separated string
+        columns_list = result.stdout.strip().split('\n')
+        return {
+            "command_executed": command_executed,
+            "stdout": f"Available columns: {', '.join(columns_list)}",
+            "stderr": result.stderr,
+            "columns": columns_list,
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: 'Rscript' not found. Please ensure R is installed and in your PATH.",
+            "error": "Dependency not found"
+        }
+    except subprocess.CalledProcessError as e:
+        stderr = e.stderr
+        if "there is no package called" in stderr:
+            stderr += "\n\nHint: Please ensure the 'GO.db' and 'AnnotationDbi' R packages are installed."
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": stderr,
+            "error": "R script execution failed"
+        }
+
+@mcp.tool()
+def query_go_db(
+    go_ids: List[str],
+    columns: Optional[List[str]] = None,
+    output_file: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Query the Bioconductor GO.db to retrieve information about Gene Ontology terms.
+
+    This tool uses R/Bioconductor's GO.db annotation package to fetch details
+    for a given list of GO IDs. You can specify which columns of data to retrieve.
+
+    Requirements:
+    - R must be installed and in the system's PATH.
+    - The R packages 'BiocManager', 'AnnotationDbi', and 'GO.db' must be installed.
+      (e.g., in R: BiocManager::install(c("AnnotationDbi", "GO.db")))
+
+    Args:
+        go_ids: A list of Gene Ontology (GO) IDs to query (e.g., ['GO:0005575', 'GO:0008150']).
+        columns: A list of columns to retrieve. Defaults to ['GOID', 'TERM', 'DEFINITION', 'ONTOLOGY'].
+                 Use the `list_go_db_columns` tool to see all available columns.
+        output_file: Optional path to save the output as a tab-separated (TSV) file.
+                     If not provided, the output is returned in stdout.
+    """
+    # --- Input Validation ---
+    if not go_ids:
+        raise ValueError("The 'go_ids' list cannot be empty.")
+
+    for go_id in go_ids:
+        if not isinstance(go_id, str) or not go_id.startswith("GO:"):
+            raise ValueError(f"Invalid GO ID format: '{go_id}'. Expected format is 'GO:#######'.")
+
+    if columns is None:
+        # Default columns provide the most common information
+        columns_to_query = ["GOID", "TERM", "DEFINITION", "ONTOLOGY"]
+    else:
+        if not isinstance(columns, list) or not all(isinstance(c, str) for c in columns):
+            raise TypeError("The 'columns' parameter must be a list of strings.")
+        columns_to_query = columns
+
+    # --- R Script Construction ---
+    # Convert Python lists to R vector syntax: c("item1", "item2")
+    r_go_ids = 'c({})'.format(','.join(f'"{gid}"' for gid in go_ids))
+    r_columns = 'c({})'.format(','.join(f'"{col}"' for col in columns_to_query))
+
+    # Using a temporary file for the output if no output_file is specified by the user
+    # This avoids complex stdout redirection and ensures clean capture
+    temp_dir = tempfile.TemporaryDirectory()
+    final_output_path = Path(output_file) if output_file else Path(temp_dir.name) / "go_query_results.tsv"
+
+    r_script = f"""
+    # Suppress package startup messages for cleaner output
+    suppressPackageStartupMessages(library(AnnotationDbi))
+    suppressPackageStartupMessages(library(GO.db))
+
+    go_keys <- {r_go_ids}
+    cols_to_get <- {r_columns}
+    output_path <- "{str(final_output_path)}"
+
+    # Perform the query
+    results <- tryCatch(
+        AnnotationDbi::select(GO.db, keys=go_keys, columns=cols_to_get, keytype="GOID"),
+        error = function(e) {{
+            write(paste("Error during AnnotationDbi::select:", e$message), stderr())
+            return(NULL)
+        }}
+    )
+
+    # Write results to the specified output file
+    if (!is.null(results)) {{
+        write.table(
+            results,
+            file=output_path,
+            sep="\\t",
+            row.names=FALSE,
+            quote=FALSE
+        )
+    }}
+    """
+
+    command = ["Rscript", "-e", r_script]
+    command_executed = " ".join(command)
+    output_files_list = []
+
+    try:
+        # --- Subprocess Execution ---
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        stdout_content = ""
+        if final_output_path.exists() and final_output_path.stat().st_size > 0:
+            output_files_list.append(str(final_output_path))
+            # If no output file was requested by the user, read the temp file content for stdout
+            if not output_file:
+                stdout_content = final_output_path.read_text()
+        else:
+            # Handle cases where the R script runs but produces no output (e.g., no matches)
+            stdout_content = "Query executed successfully, but no results were found for the given GO IDs."
+
+        return {
+            "command_executed": command_executed,
+            "stdout": stdout_content,
+            "stderr": result.stderr,
+            "output_files": output_files_list,
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: 'Rscript' not found. Please ensure R is installed and in your PATH.",
+            "error": "Dependency not found"
+        }
+    except subprocess.CalledProcessError as e:
+        stderr = e.stderr
+        if "there is no package called" in stderr:
+            stderr += "\n\nHint: Please ensure the 'GO.db' and 'AnnotationDbi' R packages are installed."
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": stderr,
+            "error": "R script execution failed"
+        }
+    finally:
+        # Clean up the temporary directory
+        temp_dir.cleanup()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-go.db/app/requirements.txt

@@ -0,0 +1 @@
+

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

Biomni/mcp_generated/mcp_bioconductor-hoodscanr/app/bioconductor-hoodscanr_server.py

@@ -0,0 +1,340 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_hoodscanr'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def hoodscanr_estimate_radius(
+    input_spe_path: str,
+    k: int = 6,
+    method: str = "mean",
+) -> Dict[str, Any]:
+    """
+    Estimate the search radius for neighborhood scanning based on the k-nearest neighbors 
+    of cells in a SpatialExperiment object.
+
+    Args:
+        input_spe_path: Path to the input SpatialExperiment object saved as an RDS file.
+        k: Number of nearest neighbors to consider for radius estimation. Default is 6.
+        method: Method to summarize distances ('mean' or 'median'). Default is 'mean'.
+    """
+    input_path = Path(input_spe_path)
+    if not input_path.exists():
+        return {"error": f"Input file {input_spe_path} does not exist."}
+    
+    if k <= 0:
+        return {"error": "Parameter 'k' must be a positive integer."}
+    
+    if method not in ["mean", "median"]:
+        return {"error": "Parameter 'method' must be either 'mean' or 'median'."}
+
+    # R script to estimate radius
+    r_command = f"""
+    library(hoodscanR)
+    library(SpatialExperiment)
+    spe <- readRDS('{input_spe_path}')
+    radius <- estimate_radius(spe, k = {k}, method = '{method}')
+    cat(radius)
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"hoodscanR::estimate_radius(spe, k={k}, method='{method}')",
+            "estimated_radius": float(result.stdout.strip()),
+            "stdout": result.stdout,
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+    except ValueError:
+        return {
+            "error": "Could not parse radius from R output",
+            "stdout": result.stdout
+        }
+
+@mcp.tool()
+def hoodscanr_hoodscan(
+    input_spe_path: str,
+    output_spe_path: str,
+    radius: float,
+    focal_cell_type: Optional[str] = None,
+    neighbor_cell_type: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Perform cellular neighborhood scanning on a SpatialExperiment object.
+
+    Args:
+        input_spe_path: Path to the input SpatialExperiment RDS file.
+        output_spe_path: Path where the updated SpatialExperiment RDS file will be saved.
+        radius: The search radius for identifying neighbors.
+        focal_cell_type: Optional; specific cell type to act as the center of neighborhoods.
+        neighbor_cell_type: Optional; specific cell type to look for in the neighborhood.
+    """
+    input_path = Path(input_spe_path)
+    if not input_path.exists():
+        return {"error": f"Input file {input_spe_path} does not exist."}
+    
+    if radius <= 0:
+        return {"error": "Radius must be a positive number."}
+
+    focal_arg = f"'{focal_cell_type}'" if focal_cell_type else "NULL"
+    neighbor_arg = f"'{neighbor_cell_type}'" if neighbor_cell_type else "NULL"
+
+    r_command = f"""
+    library(hoodscanR)
+    library(SpatialExperiment)
+    spe <- readRDS('{input_spe_path}')
+    spe <- hoodscan(spe, radius = {radius}, focal_cell_type = {focal_arg}, neighbor_cell_type = {neighbor_arg})
+    saveRDS(spe, '{output_spe_path}')
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"hoodscanR::hoodscan(spe, radius={radius})",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_spe_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def hoodscanr_calc_colocalisation(
+    input_spe_path: str,
+    output_csv_path: str,
+    focal_cell_type: Optional[str] = None,
+    neighbor_cell_type: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Calculate the colocalisation matrix between cell types based on neighborhood scanning results.
+
+    Args:
+        input_spe_path: Path to the SpatialExperiment RDS file (must have been processed by hoodscan).
+        output_csv_path: Path to save the colocalisation matrix as a CSV file.
+        focal_cell_type: Optional; filter for specific focal cell types.
+        neighbor_cell_type: Optional; filter for specific neighbor cell types.
+    """
+    input_path = Path(input_spe_path)
+    if not input_path.exists():
+        return {"error": f"Input file {input_spe_path} does not exist."}
+
+    focal_arg = f"'{focal_cell_type}'" if focal_cell_type else "NULL"
+    neighbor_arg = f"'{neighbor_cell_type}'" if neighbor_cell_type else "NULL"
+
+    r_command = f"""
+    library(hoodscanR)
+    library(SpatialExperiment)
+    spe <- readRDS('{input_spe_path}')
+    coloc_mat <- calc_colocalisation(spe, focal_cell_type = {focal_arg}, neighbor_cell_type = {neighbor_arg})
+    write.csv(as.matrix(coloc_mat), '{output_csv_path}')
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": "hoodscanR::calc_colocalisation(spe)",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_csv_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def hoodscanr_calc_spatial_correlation(
+    input_spe_path: str,
+    output_csv_path: str,
+    focal_cell_type: Optional[str] = None,
+    neighbor_cell_type: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Calculate the spatial correlation between cell types.
+
+    Args:
+        input_spe_path: Path to the SpatialExperiment RDS file.
+        output_csv_path: Path to save the spatial correlation matrix as a CSV file.
+        focal_cell_type: Optional; filter for specific focal cell types.
+        neighbor_cell_type: Optional; filter for specific neighbor cell types.
+    """
+    input_path = Path(input_spe_path)
+    if not input_path.exists():
+        return {"error": f"Input file {input_spe_path} does not exist."}
+
+    focal_arg = f"'{focal_cell_type}'" if focal_cell_type else "NULL"
+    neighbor_arg = f"'{neighbor_cell_type}'" if neighbor_cell_type else "NULL"
+
+    r_command = f"""
+    library(hoodscanR)
+    library(SpatialExperiment)
+    spe <- readRDS('{input_spe_path}')
+    corr_mat <- calc_spatial_correlation(spe, focal_cell_type = {focal_arg}, neighbor_cell_type = {neighbor_arg})
+    write.csv(as.matrix(corr_mat), '{output_csv_path}')
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": "hoodscanR::calc_spatial_correlation(spe)",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_csv_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def hoodscanr_plot_colocalisation(
+    input_spe_path: str,
+    output_plot_path: str,
+    focal_cell_type: Optional[str] = None,
+    neighbor_cell_type: Optional[str] = None,
+    width: int = 8,
+    height: int = 6,
+) -> Dict[str, Any]:
+    """
+    Generate a heatmap of the colocalisation matrix.
+
+    Args:
+        input_spe_path: Path to the SpatialExperiment RDS file.
+        output_plot_path: Path to save the plot (e.g., 'plot.png' or 'plot.pdf').
+        focal_cell_type: Optional; filter for specific focal cell types.
+        neighbor_cell_type: Optional; filter for specific neighbor cell types.
+        width: Width of the output plot in inches. Default is 8.
+        height: Height of the output plot in inches. Default is 6.
+    """
+    input_path = Path(input_spe_path)
+    if not input_path.exists():
+        return {"error": f"Input file {input_spe_path} does not exist."}
+
+    focal_arg = f"'{focal_cell_type}'" if focal_cell_type else "NULL"
+    neighbor_arg = f"'{neighbor_cell_type}'" if neighbor_cell_type else "NULL"
+
+    r_command = f"""
+    library(hoodscanR)
+    library(SpatialExperiment)
+    library(ggplot2)
+    spe <- readRDS('{input_spe_path}')
+    p <- plot_colocalisation(spe, focal_cell_type = {focal_arg}, neighbor_cell_type = {neighbor_arg})
+    ggsave('{output_plot_path}', plot = p, width = {width}, height = {height})
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": "hoodscanR::plot_colocalisation(spe)",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_plot_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def hoodscanr_plot_spatial_correlation(
+    input_spe_path: str,
+    output_plot_path: str,
+    focal_cell_type: Optional[str] = None,
+    neighbor_cell_type: Optional[str] = None,
+    width: int = 8,
+    height: int = 6,
+) -> Dict[str, Any]:
+    """
+    Generate a heatmap of the spatial correlation matrix.
+
+    Args:
+        input_spe_path: Path to the SpatialExperiment RDS file.
+        output_plot_path: Path to save the plot (e.g., 'plot.png' or 'plot.pdf').
+        focal_cell_type: Optional; filter for specific focal cell types.
+        neighbor_cell_type: Optional; filter for specific neighbor cell types.
+        width: Width of the output plot in inches. Default is 8.
+        height: Height of the output plot in inches. Default is 6.
+    """
+    input_path = Path(input_spe_path)
+    if not input_path.exists():
+        return {"error": f"Input file {input_spe_path} does not exist."}
+
+    focal_arg = f"'{focal_cell_type}'" if focal_cell_type else "NULL"
+    neighbor_arg = f"'{neighbor_cell_type}'" if neighbor_cell_type else "NULL"
+
+    r_command = f"""
+    library(hoodscanR)
+    library(SpatialExperiment)
+    library(ggplot2)
+    spe <- readRDS('{input_spe_path}')
+    p <- plot_spatial_correlation(spe, focal_cell_type = {focal_arg}, neighbor_cell_type = {neighbor_arg})
+    ggsave('{output_plot_path}', plot = p, width = {width}, height = {height})
+    """
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_command],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": "hoodscanR::plot_spatial_correlation(spe)",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_plot_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-hoodscanr/app/bioconductor-hoodscanr_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-hoodscanr/app/bioconductor-hoodscanr_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_hoodscanr'
+
+
+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-org.mm.eg.db/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-org.mm.eg.db via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-org.mm.eg.db -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-org.mm.eg.db_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-org.mm.eg.db_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-org.mm.eg.db_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-org.mm.eg.db/app/bioconductor-org.mm.eg.db_server.py

@@ -0,0 +1,279 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# MCP.TOOL DECORATOR (should not be included in the final output)
+# This is a placeholder for the actual decorator.
+def mcp_tool_placeholder(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+# In a real MCP environment, the following line would be:
+# import mcp
+# and the decorator would be @mcp.tool()
+mcp = type("mcp", (), {"tool": mcp_tool_placeholder})
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_org_mm_eg_db'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def org_mm_eg_db_query(
+    keys: List[str],
+    keytype: str,
+    columns: List[str],
+    output_file: Path,
+) -> dict:
+    """
+    Performs an annotation query on the org.Mm.eg.db database.
+
+    This tool uses the AnnotationDbi::select function to retrieve annotations
+    for a given set of keys. It maps identifiers from a specified keytype to
+    the desired annotation columns.
+
+    Args:
+        keys: A list of identifiers to query (e.g., ["14189", "14190"]).
+        keytype: The type of identifier being provided in `keys`.
+                 Use the `org_mm_eg_db_list_keytypes` tool to see available options.
+                 Example: "ENTREZID".
+        columns: A list of annotation columns to retrieve.
+                 Use the `org_mm_eg_db_list_columns` tool to see available options.
+                 Example: ["SYMBOL", "GENENAME", "GO"].
+        output_file: The path to save the resulting annotation table in TSV format.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the output file path.
+    """
+    if not keys:
+        raise ValueError("The 'keys' list cannot be empty.")
+    if not keytype:
+        raise ValueError("The 'keytype' parameter cannot be empty.")
+    if not columns:
+        raise ValueError("The 'columns' list cannot be empty.")
+
+    # Convert Python lists to R vector strings, e.g., c("item1", "item2")
+    r_keys = 'c({})'.format(', '.join(f'"{key}"' for key in keys))
+    r_columns = 'c({})'.format(', '.join(f'"{col}"' for col in columns))
+
+    r_script_content = f"""
+    # Suppress startup messages for cleaner output
+    suppressPackageStartupMessages(library("AnnotationDbi"))
+    suppressPackageStartupMessages(library("org.Mm.eg.db"))
+
+    # Define parameters
+    keys_to_query <- {r_keys}
+    cols_to_fetch <- {r_columns}
+    key_type <- "{keytype}"
+    output_path <- "{output_file}"
+
+    # Perform the query
+    # Use tryCatch to handle potential errors, like invalid keytypes or columns
+    results <- tryCatch(
+        {{
+            AnnotationDbi::select(
+                org.Mm.eg.db,
+                keys = keys_to_query,
+                columns = cols_to_fetch,
+                keytype = key_type
+            )
+        }},
+        error = function(e) {{
+            stop(paste("AnnotationDbi::select failed:", e$message))
+        }}
+    )
+
+    # Write the output
+    write.table(
+        results,
+        file = output_path,
+        sep = "\\t",
+        row.names = FALSE,
+        quote = FALSE
+    )
+    """
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as tmp_script:
+        tmp_script.write(r_script_content)
+        script_path = tmp_script.name
+
+    cmd = ["Rscript", script_path]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        # Clean up the temporary script file
+        Path(script_path).unlink()
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_file)],
+        }
+    except subprocess.CalledProcessError as e:
+        # Clean up the temporary script file even on error
+        Path(script_path).unlink()
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+
+
+@mcp.tool()
+def org_mm_eg_db_list_columns() -> dict:
+    """
+    Lists all available annotation columns in the org.Mm.eg.db database.
+
+    These column names can be used in the `columns` parameter of the
+    `org_mm_eg_db_query` tool.
+
+    Returns:
+        A dictionary containing the command executed and a list of available columns in stdout.
+    """
+    r_script_content = """
+    suppressPackageStartupMessages(library("org.Mm.eg.db"))
+    cat(columns(org.Mm.eg.db), sep = "\\n")
+    """
+    cmd = ["Rscript", "-e", r_script_content]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+
+
+@mcp.tool()
+def org_mm_eg_db_list_keytypes() -> dict:
+    """
+    Lists all available keytypes in the org.Mm.eg.db database.
+
+    Keytypes define the type of primary identifiers that can be used for querying
+    in the `keytype` parameter of the `org_mm_eg_db_query` and
+    `org_mm_eg_db_list_keys` tools.
+
+    Returns:
+        A dictionary containing the command executed and a list of available keytypes in stdout.
+    """
+    r_script_content = """
+    suppressPackageStartupMessages(library("org.Mm.eg.db"))
+    cat(keytypes(org.Mm.eg.db), sep = "\\n")
+    """
+    cmd = ["Rscript", "-e", r_script_content]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+
+
+@mcp.tool()
+def org_mm_eg_db_list_keys(
+    keytype: str,
+    output_file: Optional[Path] = None,
+) -> dict:
+    """
+    Lists all primary keys for a given keytype from the org.Mm.eg.db database.
+
+    Args:
+        keytype: The type of identifiers to retrieve. Use the
+                 `org_mm_eg_db_list_keytypes` tool to see available options.
+        output_file: Optional. If provided, saves the list of keys to this file,
+                     one key per line. Otherwise, keys are printed to stdout.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the output file path if provided.
+    """
+    if not keytype:
+        raise ValueError("The 'keytype' parameter cannot be empty.")
+
+    if output_file:
+        r_script_content = f"""
+        suppressPackageStartupMessages(library("org.Mm.eg.db"))
+        key_type <- "{keytype}"
+        output_path <- "{output_file}"
+        keys_list <- keys(org.Mm.eg.db, keytype = key_type)
+        write.table(
+            keys_list,
+            file = output_path,
+            col.names = FALSE,
+            row.names = FALSE,
+            quote = FALSE
+        )
+        """
+    else:
+        r_script_content = f"""
+        suppressPackageStartupMessages(library("org.Mm.eg.db"))
+        key_type <- "{keytype}"
+        keys_list <- keys(org.Mm.eg.db, keytype = key_type)
+        cat(keys_list, sep = "\\n")
+        """
+
+    cmd = ["Rscript", "-e", r_script_content]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        output_files = [str(output_file)] if output_file else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-org.mm.eg.db/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-org.mm.eg.db/docker-compose.yml

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

@@ -0,0 +1,10 @@
+
+name: mcp-tool
+channels:
+  - bioconda
+  - conda-forge
+  - defaults
+dependencies:
+  - bioconductor-org.mm.eg.db
+  - python=3.10
+    

Biomni/mcp_generated/mcp_bioconductor-org.mm.eg.db/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-poem/app/bioconductor-poem_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-poem/app/bioconductor-poem_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_poem'
+
+
+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-seraster/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-seraster via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-seraster -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-seraster_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-seraster_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-seraster_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-seraster/environment.yaml

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

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

Biomni/mcp_generated/mcp_bioconductor-spatialomicsoverlay/app/bioconductor-spatialomicsoverlay_server.py

@@ -0,0 +1,197 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, Literal, List
+import textwrap
+
+# from mcp import tool as mcp_tool
+# The @mcp.tool decorator is commented out as 'mcp' is not available for import.
+# In a real MCP environment, this would be uncommented.
+
+# @mcp_tool()
+def spatial_overlay(
+    spe_object: Path,
+    tissue_data: Path,
+    image_data: Path,
+    sample_id: str,
+    image_resolution: float,
+    output_file: Path,
+    fluorescence_data: Optional[Path] = None,
+    flip: Literal["none", "h", "v", "both"] = "none",
+    show_scale_bar: bool = True,
+    show_legend: bool = True,
+    point_alpha: Optional[float] = None,
+    point_size: Optional[float] = None,
+    point_color: Optional[str] = None,
+) -> dict:
+    """
+    Generates a spatial overlay plot using the Bioconductor spatialomicsOverlay package.
+
+    This tool overlays spatial transcriptomics data (from a SpatialExperiment or Seurat
+    object) onto high-resolution histology images, allowing for visualization of
+    gene expression or other features in their spatial context.
+
+    Args:
+        spe_object: Path to the input SpatialExperiment or Seurat object in RDS format.
+        tissue_data: Path to the tissue segmentation data in CSV or TSV format.
+        image_data: Path to the image data in CSV or TSV format.
+        sample_id: The sample ID within the object to plot.
+        image_resolution: The resolution of the image (e.g., pixels per micron).
+        output_file: Path to save the output plot (e.g., plot.png, plot.pdf).
+        fluorescence_data: Optional path to fluorescence data in CSV or TSV format.
+        flip: Image flip orientation. Can be 'none', 'h' (horizontal), 'v' (vertical), or 'both'.
+        show_scale_bar: If True, a scale bar is added to the plot.
+        show_legend: If True, a legend is added to the plot.
+        point_alpha: Optional opacity for the data points (value between 0.0 and 1.0).
+        point_size: Optional size for the data points.
+        point_color: Optional color for the data points (e.g., 'blue', '#FF0000').
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and a list of output files.
+    """
+    # 1. Input Validation
+    if not spe_object.is_file():
+        raise FileNotFoundError(f"Input SPE object not found: {spe_object}")
+    if not tissue_data.is_file():
+        raise FileNotFoundError(f"Input tissue data not found: {tissue_data}")
+    if not image_data.is_file():
+        raise FileNotFoundError(f"Input image data not found: {image_data}")
+    if fluorescence_data and not fluorescence_data.is_file():
+        raise FileNotFoundError(f"Input fluorescence data not found: {fluorescence_data}")
+
+    if point_alpha is not None and not (0.0 <= point_alpha <= 1.0):
+        raise ValueError("point_alpha must be between 0.0 and 1.0")
+    if point_size is not None and point_size < 0:
+        raise ValueError("point_size must be a non-negative number")
+
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. R Script Generation
+    # This R script is generated on-the-fly to call the spatialomicsOverlay functions.
+    r_script_content = textwrap.dedent("""\
+        suppressPackageStartupMessages(library(optparse))
+        suppressPackageStartupMessages(library(spatialomicsOverlay))
+        suppressPackageStartupMessages(library(SpatialExperiment))
+        suppressPackageStartupMessages(library(ggplot2))
+        suppressPackageStartupMessages(library(SeuratObject))
+
+        option_list <- list(
+            make_option(c("--spe_object"), type="character", help="Path to the SpatialExperiment/Seurat RDS object"),
+            make_option(c("--tissue_data"), type="character", help="Path to the tissue segmentation data (CSV/TSV)"),
+            make_option(c("--image_data"), type="character", help="Path to the image data (CSV/TSV)"),
+            make_option(c("--sample_id"), type="character", help="Sample ID to plot"),
+            make_option(c("--image_resolution"), type="double", help="Resolution of the image"),
+            make_option(c("--output_file"), type="character", help="Path for the output plot"),
+            make_option(c("--fluorescence_data"), type="character", default=NULL, help="Path to optional fluorescence data"),
+            make_option(c("--flip"), type="character", default="none", help="Image flip orientation (none, h, v, both)"),
+            make_option(c("--show_scale_bar"), action="store_true", default=FALSE, help="Flag to show scale bar"),
+            make_option(c("--show_legend"), action="store_true", default=FALSE, help="Flag to show legend"),
+            make_option(c("--point_alpha"), type="double", default=NULL, help="Alpha for points"),
+            make_option(c("--point_size"), type="double", default=NULL, help="Size for points"),
+            make_option(c("--point_color"), type="character", default=NULL, help="Color for points")
+        )
+
+        opt_parser <- OptionParser(option_list=option_list)
+        opt <- parse_args(opt_parser)
+
+        if (is.null(opt$spe_object) || is.null(opt$tissue_data) || is.null(opt$image_data) || is.null(opt$sample_id) || is.null(opt$image_resolution) || is.null(opt$output_file)) {
+            print_help(opt_parser)
+            stop("Missing one or more required arguments.", call.=FALSE)
+        }
+
+        # Load data
+        spe <- readRDS(opt$spe_object)
+        tissue <- read.csv(opt$tissue_data, row.names=1)
+        image <- read.csv(opt$image_data, row.names=1)
+        fluor <- if (!is.null(opt$fluorescence_data)) read.csv(opt$fluorescence_data, row.names=1) else NULL
+
+        # Prepare additional arguments for geom_point
+        geom_args <- list()
+        if (!is.null(opt$point_alpha)) geom_args$alpha <- opt$point_alpha
+        if (!is.null(opt$point_size)) geom_args$size <- opt$point_size
+        if (!is.null(opt$point_color)) geom_args$color <- opt$point_color
+
+        # Generate plot by calling spatialOverlay with dynamic arguments
+        plot_obj <- do.call(spatialOverlay, c(
+            list(
+                object = spe,
+                tissue = tissue,
+                sample = opt$sample_id,
+                image = image,
+                res = opt$image_resolution,
+                fluor = fluor,
+                flip = opt$flip,
+                scaleBar = opt$show_scale_bar,
+                legend = opt$show_legend
+            ),
+            geom_args
+        ))
+
+        # Save the generated plot
+        ggsave(opt$output_file, plot=plot_obj, width=10, height=10, units="in")
+
+        cat("Plot saved successfully to:", opt$output_file, "\\n")
+    """)
+
+    # 3. Command Construction
+    r_script_path = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = [
+            "Rscript",
+            r_script_path,
+            "--spe_object", str(spe_object.resolve()),
+            "--tissue_data", str(tissue_data.resolve()),
+            "--image_data", str(image_data.resolve()),
+            "--sample_id", sample_id,
+            "--image_resolution", str(image_resolution),
+            "--output_file", str(output_file.resolve()),
+            "--flip", flip,
+        ]
+
+        if fluorescence_data:
+            cmd.extend(["--fluorescence_data", str(fluorescence_data.resolve())])
+        if show_scale_bar:
+            cmd.append("--show_scale_bar")
+        if show_legend:
+            cmd.append("--show_legend")
+        if point_alpha is not None:
+            cmd.extend(["--point_alpha", str(point_alpha)])
+        if point_size is not None:
+            cmd.extend(["--point_size", str(point_size)])
+        if point_color is not None:
+            cmd.extend(["--point_color", point_color])
+
+        # 4. Subprocess Execution
+        command_executed = " ".join(cmd)
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        # 5. Structured Result Return
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_file.resolve())]
+        }
+
+    except subprocess.CalledProcessError as e:
+        # Enhanced error reporting
+        error_message = (
+            f"R script execution failed with return code {e.returncode}.\n"
+            f"Stderr:\n{e.stderr}\n"
+            f"Stdout:\n{e.stdout}"
+        )
+        raise RuntimeError(error_message) from e
+
+    finally:
+        # Clean up the temporary R script
+        if r_script_path and Path(r_script_path).exists():
+            Path(r_script_path).unlink()

Biomni/mcp_generated/mcp_bioconductor-spatialomicsoverlay/app/bioconductor-spatialomicsoverlay_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-spatialomicsoverlay/app/bioconductor-spatialomicsoverlay_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_spatialomicsoverlay'
+
+
+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-spatialomicsoverlay/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-spatialomicsoverlay/requirements.txt

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

Biomni/mcp_generated/mcp_checkm-genome/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 checkm-genome via conda (e.g., from bioconda)
+RUN conda install -c bioconda checkm-genome -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/checkm-genome_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/checkm-genome_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/checkm-genome_server.py"]
+        

Biomni/mcp_generated/mcp_checkm-genome/app/checkm-genome_server.py

@@ -0,0 +1,1238 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Dict, Any, Union
+
+# Helper function to execute CheckM commands
+def _run_checkm_command(
+    command: List[str],
+    output_dir: Optional[Path] = None,
+    log_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+    pplacer_path: Optional[Path] = None,
+    hmmer_path: Optional[Path] = None,
+    prodigal_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Internal helper function to execute CheckM commands and handle common options.
+
+    Args:
+        command: A list of strings representing the CheckM subcommand and its specific arguments.
+        output_dir: An optional Path to a directory where the tool is expected to write output files.
+                    Used for collecting output_files in the result.
+        log_file: An optional Path to a file where stdout/stderr should be redirected.
+        quiet: If True, suppress CheckM's stdout.
+        debug: If True, enable CheckM's debug mode.
+        force: If True, force overwrite of existing files.
+        tmpdir: An optional Path to a temporary directory for CheckM.
+        threads: Number of threads for CheckM to use.
+        pplacer_path: Path to the pplacer executable.
+        hmmer_path: Path to HMMER executables.
+        prodigal_path: Path to the Prodigal executable.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    cmd = ["checkm"] + command
+
+    if quiet:
+        cmd.append("-q")
+    if debug:
+        cmd.append("-d")
+    if force:
+        cmd.append("--force")
+    if tmpdir:
+        if not tmpdir.is_dir():
+            raise ValueError(f"Temporary directory '{tmpdir}' does not exist or is not a directory.")
+        cmd.extend(["--tmpdir", str(tmpdir)])
+    if threads > 1:
+        cmd.extend(["-t", str(threads)])
+    if pplacer_path:
+        if not pplacer_path.is_file():
+            raise ValueError(f"pplacer executable '{pplacer_path}' not found.")
+        cmd.extend(["--pplacer_path", str(pplacer_path)])
+    if hmmer_path:
+        if not hmmer_path.is_file():
+            raise ValueError(f"HMMER executable '{hmmer_path}' not found.")
+        cmd.extend(["--hmmer_path", str(hmmer_path)])
+    if prodigal_path:
+        if not prodigal_path.is_file():
+            raise ValueError(f"Prodigal executable '{prodigal_path}' not found.")
+        cmd.extend(["--prodigal_path", str(prodigal_path)])
+
+    stdout_output = ""
+    stderr_output = ""
+    output_files = []
+
+    try:
+        process = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        stdout_output = process.stdout
+        stderr_output = process.stderr
+    except subprocess.CalledProcessError as e:
+        stdout_output = e.stdout
+        stderr_output = e.stderr
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": stdout_output,
+            "stderr": stderr_output,
+            "output_files": [],
+            "error": str(e),
+        }
+
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(log_file, "w") as f:
+            f.write(f"Command: {' '.join(cmd)}\n\n")
+            f.write("STDOUT:\n")
+            f.write(stdout_output)
+            f.write("\nSTDERR:\n")
+            f.write(stderr_output)
+
+    if output_dir and output_dir.is_dir():
+        output_files.extend([str(p) for p in output_dir.rglob("*") if p.is_file()])
+
+    return {
+        "command_executed": " ".join(cmd),
+        "stdout": stdout_output,
+        "stderr": stderr_output,
+        "output_files": output_files,
+    }
+
+# Helper function to add plotting arguments
+def _add_plotting_args(
+    cmd: List[str],
+    image_file: Optional[Path] = None,
+    image_type: Optional[str] = None,
+    font_size: Optional[int] = None,
+    dpi: Optional[int] = None,
+    width: Optional[float] = None,
+    height: Optional[float] = None,
+    title: Optional[str] = None,
+    label: Optional[str] = None,
+    color: Optional[str] = None,
+    marker_size: Optional[int] = None,
+    line_width: Optional[int] = None,
+) -> None:
+    """
+    Internal helper function to append common plotting arguments to a command list.
+    Only appends arguments if their values are explicitly provided (not None).
+    """
+    if image_file:
+        cmd.extend(["--image_file", str(image_file)])
+    if image_type:
+        cmd.extend(["--image_type", image_type])
+    if font_size is not None:
+        cmd.extend(["--font_size", str(font_size)])
+    if dpi is not None:
+        cmd.extend(["--dpi", str(dpi)])
+    if width is not None:
+        cmd.extend(["--width", str(width)])
+    if height is not None:
+        cmd.extend(["--height", str(height)])
+    if title:
+        cmd.extend(["--title", title])
+    if label:
+        cmd.extend(["--label", label])
+    if color:
+        cmd.extend(["--color", color])
+    if marker_size is not None:
+        cmd.extend(["--marker_size", str(marker_size)])
+    if line_width is not None:
+        cmd.extend(["--line_width", str(line_width)])
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_checkm_genome'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def data(
+    download_folder: Optional[Path] = None,
+    output_file: Optional[Path] = None,
+    force: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """
+    Downloads and installs the CheckM reference data.
+
+    Args:
+        download_folder: Folder to download data to. If not specified, CheckM's default data folder is used.
+        output_file: File to write output to. If not specified, output goes to stdout.
+        force: Force overwrite of existing files.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    cmd = ["data"]
+
+    if download_folder:
+        download_folder.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--download_folder", str(download_folder)])
+
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--file", str(output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        log_file=output_file,
+        force=force,
+        quiet=quiet,
+        debug=debug,
+    )
+
+
+@mcp.tool()
+def lineage_wf(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    reduced_tree: bool = False,
+    output_alignment_files: bool = False,
+    output_nucleotide_sequences: bool = False,
+    tab_output_file: Optional[Path] = None,
+    skip_gtdb_r207: bool = False,
+    skip_gtdb_r207_cpr: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+    pplacer_path: Optional[Path] = None,
+    hmmer_path: Optional[Path] = None,
+    prodigal_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Performs a lineage-specific workflow for assessing genome quality.
+    This is the recommended workflow for most users.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        reduced_tree: Use a reduced tree for phylogenetic placement.
+        output_alignment_files: Output alignment files.
+        output_nucleotide_sequences: Output nucleotide sequences.
+        tab_output_file: File to write tab-separated output to.
+        skip_gtdb_r207: Skip GTDB R207 marker set.
+        skip_gtdb_r207_cpr: Skip GTDB R207 CPR marker set.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+        pplacer_path: Path to pplacer executable.
+        hmmer_path: Path to HMMER executables.
+        prodigal_path: Path to Prodigal executable.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["lineage_wf", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if reduced_tree:
+        cmd.append("-r")
+    if output_alignment_files:
+        cmd.append("--ali")
+    if output_nucleotide_sequences:
+        cmd.append("--nt")
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+    if skip_gtdb_r207:
+        cmd.append("--skip_gtdb_r207")
+    if skip_gtdb_r207_cpr:
+        cmd.append("--skip_gtdb_r207_cpr")
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+        pplacer_path=pplacer_path,
+        hmmer_path=hmmer_path,
+        prodigal_path=prodigal_path,
+    )
+
+
+@mcp.tool()
+def taxonomy_wf(
+    taxonomy_level: str,
+    taxonomy_id: str,
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    output_alignment_files: bool = False,
+    output_nucleotide_sequences: bool = False,
+    tab_output_file: Optional[Path] = None,
+    skip_gtdb_r207: bool = False,
+    skip_gtdb_r207_cpr: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+    pplacer_path: Optional[Path] = None,
+    hmmer_path: Optional[Path] = None,
+    prodigal_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Performs a taxonomy-specific workflow for assessing genome quality.
+
+    Args:
+        taxonomy_level: Taxonomy level (e.g., 'domain', 'phylum', 'class', 'order', 'family', 'genus', 'species').
+        taxonomy_id: Taxonomy identifier (e.g., 'Bacteria', 'Firmicutes', 'Bacilli').
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        output_alignment_files: Output alignment files.
+        output_nucleotide_sequences: Output nucleotide sequences.
+        tab_output_file: File to write tab-separated output to.
+        skip_gtdb_r207: Skip GTDB R207 marker set.
+        skip_gtdb_r207_cpr: Skip GTDB R207 CPR marker set.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+        pplacer_path: Path to pplacer executable.
+        hmmer_path: Path to HMMER executables.
+        prodigal_path: Path to Prodigal executable.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    valid_levels = ['domain', 'phylum', 'class', 'order', 'family', 'genus', 'species']
+    if taxonomy_level not in valid_levels:
+        raise ValueError(f"Invalid taxonomy_level: '{taxonomy_level}'. Must be one of {valid_levels}.")
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["taxonomy_wf", taxonomy_level, taxonomy_id, str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if output_alignment_files:
+        cmd.append("--ali")
+    if output_nucleotide_sequences:
+        cmd.append("--nt")
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+    if skip_gtdb_r207:
+        cmd.append("--skip_gtdb_r207")
+    if skip_gtdb_r207_cpr:
+        cmd.append("--skip_gtdb_r207_cpr")
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+        pplacer_path=pplacer_path,
+        hmmer_path=hmmer_path,
+        prodigal_path=prodigal_path,
+    )
+
+
+@mcp.tool()
+def tree_wf(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    full_tree: bool = False,
+    output_alignment_files: bool = False,
+    output_nucleotide_sequences: bool = False,
+    tab_output_file: Optional[Path] = None,
+    skip_gtdb_r207: bool = False,
+    skip_gtdb_r207_cpr: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+    pplacer_path: Optional[Path] = None,
+    hmmer_path: Optional[Path] = None,
+    prodigal_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Performs a tree-specific workflow for assessing genome quality.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        full_tree: Use a full tree for phylogenetic placement instead of the default reduced tree.
+        output_alignment_files: Output alignment files.
+        output_nucleotide_sequences: Output nucleotide sequences.
+        tab_output_file: File to write tab-separated output to.
+        skip_gtdb_r207: Skip GTDB R207 marker set.
+        skip_gtdb_r207_cpr: Skip GTDB R207 CPR marker set.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+        pplacer_path: Path to pplacer executable.
+        hmmer_path: Path to HMMER executables.
+        prodigal_path: Path to Prodigal executable.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["tree_wf", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if full_tree:
+        cmd.append("--full_tree")
+    if output_alignment_files:
+        cmd.append("--ali")
+    if output_nucleotide_sequences:
+        cmd.append("--nt")
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+    if skip_gtdb_r207:
+        cmd.append("--skip_gtdb_r207")
+    if skip_gtdb_r207_cpr:
+        cmd.append("--skip_gtdb_r207_cpr")
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+        pplacer_path=pplacer_path,
+        hmmer_path=hmmer_path,
+        prodigal_path=prodigal_path,
+    )
+
+
+@mcp.tool()
+def tree(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    reduced_tree: bool = False,
+    output_alignment_files: bool = False,
+    output_nucleotide_sequences: bool = False,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+    pplacer_path: Optional[Path] = None,
+    hmmer_path: Optional[Path] = None,
+    prodigal_path: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Constructs a phylogenetic tree from a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        reduced_tree: Use a reduced tree for phylogenetic placement.
+        output_alignment_files: Output alignment files.
+        output_nucleotide_sequences: Output nucleotide sequences.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+        pplacer_path: Path to pplacer executable.
+        hmmer_path: Path to HMMER executables.
+        prodigal_path: Path to Prodigal executable.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["tree", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if reduced_tree:
+        cmd.append("-r")
+    if output_alignment_files:
+        cmd.append("--ali")
+    if output_nucleotide_sequences:
+        cmd.append("--nt")
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+        pplacer_path=pplacer_path,
+        hmmer_path=hmmer_path,
+        prodigal_path=prodigal_path,
+    )
+
+
+@mcp.tool()
+def qa(
+    marker_gene_folder: Path,
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    skip_gtdb_r207: bool = False,
+    skip_gtdb_r207_cpr: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Performs quality assessment on a set of genomes using marker genes.
+
+    Args:
+        marker_gene_folder: Folder containing marker gene files (output from `checkm tree` or `checkm lineage_wf`).
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        skip_gtdb_r207: Skip GTDB R207 marker set.
+        skip_gtdb_r207_cpr: Skip GTDB R207 CPR marker set.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not marker_gene_folder.is_dir():
+        raise ValueError(f"Marker gene folder '{marker_gene_folder}' does not exist or is not a directory.")
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["qa", str(marker_gene_folder), str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+    if skip_gtdb_r207:
+        cmd.append("--skip_gtdb_r207")
+    if skip_gtdb_r207_cpr:
+        cmd.append("--skip_gtdb_r207_cpr")
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def plot(
+    checkm_output_folder: Path,
+    image_folder: Path,
+    output_file: Optional[Path] = None,
+    image_file: Optional[Path] = None,
+    image_type: str = 'png',
+    font_size: int = 12,
+    dpi: int = 300,
+    width: float = 10.0,
+    height: float = 8.0,
+    title: Optional[str] = None,
+    label: Optional[str] = None,
+    color: Optional[str] = None,
+    marker_size: int = 10,
+    line_width: int = 1,
+    force: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """
+    Generates various plots for visualizing genome quality.
+
+    Args:
+        checkm_output_folder: Folder containing CheckM output files (e.g., from `lineage_wf`).
+        image_folder: Folder to write image files to.
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        image_file: File to write the main image to. If not specified, 'checkm_plot.png' in image_folder.
+        image_type: Image type (e.g., 'png', 'pdf', 'svg').
+        font_size: Font size for plots.
+        dpi: DPI for plots.
+        width: Width of plots in inches.
+        height: Height of plots in inches.
+        title: Title for plots.
+        label: Label for plots.
+        color: Color for plots (e.g., 'red', '#FF0000').
+        marker_size: Marker size for plots.
+        line_width: Line width for plots.
+        force: Force overwrite of existing files.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not checkm_output_folder.is_dir():
+        raise ValueError(f"CheckM output folder '{checkm_output_folder}' does not exist or is not a directory.")
+    image_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["plot", str(checkm_output_folder), str(image_folder)]
+
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+
+    _add_plotting_args(
+        cmd,
+        image_file=image_file,
+        image_type=image_type,
+        font_size=font_size,
+        dpi=dpi,
+        width=width,
+        height=height,
+        title=title,
+        label=label,
+        color=color,
+        marker_size=marker_size,
+        line_width=line_width,
+    )
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=image_folder,
+        log_file=output_file,
+        force=force,
+        quiet=quiet,
+        debug=debug,
+    )
+
+
+@mcp.tool()
+def ssu_finder(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Identifies SSU rRNA genes in genome files.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["ssu_finder", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def unique_markers(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Identifies unique marker genes for a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["unique_markers", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def profile(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Profiles the distribution of marker genes across a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["profile", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def tetra(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Calculates tetranucleotide frequencies for a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["tetra", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def dist(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Calculates genomic characteristics distributions for a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["dist", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def coverage(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    tab_output_file: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    force: bool = False,
+    tmpdir: Optional[Path] = None,
+    threads: int = 1,
+) -> Dict[str, Any]:
+    """
+    Calculates coverage statistics for a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        tab_output_file: File to write tab-separated output to.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+        force: Force overwrite of existing files.
+        tmpdir: Temporary directory.
+        threads: Number of threads to use.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["coverage", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+    if tab_output_file:
+        tab_output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--tab_file", str(tab_output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        quiet=quiet,
+        debug=debug,
+        force=force,
+        tmpdir=tmpdir,
+        threads=threads,
+    )
+
+
+@mcp.tool()
+def len_hist(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    image_file: Optional[Path] = None,
+    image_type: str = 'png',
+    font_size: int = 12,
+    dpi: int = 300,
+    width: float = 10.0,
+    height: float = 8.0,
+    title: Optional[str] = None,
+    label: Optional[str] = None,
+    color: Optional[str] = None,
+    force: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """
+    Generates a length histogram for a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        image_file: File to write the image to. If not specified, 'len_hist.png' in output_folder.
+        image_type: Image type (e.g., 'png', 'pdf', 'svg').
+        font_size: Font size for plots.
+        dpi: DPI for plots.
+        width: Width of plots in inches.
+        height: Height of plots in inches.
+        title: Title for plots.
+        label: Label for plots.
+        color: Color for plots (e.g., 'red', '#FF0000').
+        force: Force overwrite of existing files.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["len_hist", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+
+    _add_plotting_args(
+        cmd,
+        image_file=image_file,
+        image_type=image_type,
+        font_size=font_size,
+        dpi=dpi,
+        width=width,
+        height=height,
+        title=title,
+        label=label,
+        color=color,
+    )
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        force=force,
+        quiet=quiet,
+        debug=debug,
+    )
+
+
+@mcp.tool()
+def nx_plot(
+    genome_folder: Path,
+    output_folder: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    image_file: Optional[Path] = None,
+    image_type: str = 'png',
+    font_size: int = 12,
+    dpi: int = 300,
+    width: float = 10.0,
+    height: float = 8.0,
+    title: Optional[str] = None,
+    label: Optional[str] = None,
+    color: Optional[str] = None,
+    force: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """
+    Generates an N50/L50 plot for a set of genomes.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_folder: Folder to write output to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        image_file: File to write the image to. If not specified, 'nx_plot.png' in output_folder.
+        image_type: Image type (e.g., 'png', 'pdf', 'svg').
+        font_size: Font size for plots.
+        dpi: DPI for plots.
+        width: Width of plots in inches.
+        height: Height of plots in inches.
+        title: Title for plots.
+        label: Label for plots.
+        color: Color for plots (e.g., 'red', '#FF0000').
+        force: Force overwrite of existing files.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_folder.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["nx_plot", str(genome_folder), str(output_folder)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+
+    _add_plotting_args(
+        cmd,
+        image_file=image_file,
+        image_type=image_type,
+        font_size=font_size,
+        dpi=dpi,
+        width=width,
+        height=height,
+        title=title,
+        label=label,
+        color=color,
+    )
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_folder,
+        log_file=output_file,
+        force=force,
+        quiet=quiet,
+        debug=debug,
+    )
+
+
+@mcp.tool()
+def bin_set(
+    genome_folder: Path,
+    output_bin_set_file: Path,
+    extension: str = "fna",
+    output_file: Optional[Path] = None,
+    force: bool = False,
+    quiet: bool = False,
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """
+    Creates a set of bins from a folder of genome files.
+
+    Args:
+        genome_folder: Folder containing genome files (e.g., .fna, .fasta).
+        output_bin_set_file: File to write the bin set to.
+        extension: Extension for genome files (e.g., 'fna', 'fasta').
+        output_file: File to write summary output to. If not specified, output goes to stdout.
+        force: Force overwrite of existing files.
+        quiet: Suppress stdout.
+        debug: Enable debug mode.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    if not genome_folder.is_dir():
+        raise ValueError(f"Genome folder '{genome_folder}' does not exist or is not a directory.")
+    output_bin_set_file.parent.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["bin_set", str(genome_folder), str(output_bin_set_file)]
+
+    if extension:
+        cmd.extend(["-x", extension])
+    if output_file:
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["-f", str(output_file)])
+
+    return _run_checkm_command(
+        cmd,
+        output_dir=output_bin_set_file.parent,
+        log_file=output_file,
+        force=force,
+        quiet=quiet,
+        debug=debug,
+    )
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_checkm-genome/app/checkm-genome_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_checkm-genome/app/checkm-genome_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_checkm_genome'
+
+
+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_checkm-genome/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_checkm-genome/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_checkm-genome/requirements.txt

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

Biomni/mcp_generated/mcp_dca/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 dca via conda (e.g., from bioconda)
+RUN conda install -c bioconda dca -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/dca_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/dca_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/dca_server.py"]
+        

Biomni/mcp_generated/mcp_dca/app/dca_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_dca/app/dca_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_dca'
+
+
+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_dca/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_dca/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_dca/requirements.txt

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

Biomni/mcp_generated/mcp_echidna/app/echidna_server.py

@@ -0,0 +1,140 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+def tool(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+mcp = type("mcp", (), {"tool": tool})
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_echidna'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_echidna(
+    input_adata: Path,
+    output_prefix: str,
+    timepoint_label: str = "timepoint",
+    counts_layer: str = "counts",
+    clusters: str = "leiden",
+    seed: int = 42,
+    n_steps: int = 10000,
+    learning_rate: float = 0.1,
+    val_split: float = 0.1,
+    patience: int = 30,
+    device: str = "cpu",
+    verbose: bool = True,
+    inverse_gamma: bool = False,
+    eta_mean_init: float = 2.0,
+    lkj_concentration: float = 1.0,
+    q_corr_init: float = 0.01,
+    q_shape_rate_scaler: float = 10.0,
+):
+    """
+    Runs the Echidna model for joint probabilistic modeling of single-cell gene
+    expression and chromosomal copy number variation.
+
+    This tool serves as a command-line wrapper for the `echidna` Python library,
+    which integrates scRNA-seq and bulk WGS data to quantify gene dosage effects.
+    """
+    # --- Input Validation ---
+    if not input_adata.is_file():
+        raise FileNotFoundError(f"Input AnnData file not found: {input_adata}")
+
+    if n_steps <= 0:
+        raise ValueError("n_steps must be a positive integer.")
+    if learning_rate <= 0:
+        raise ValueError("learning_rate must be positive.")
+    if not (0.0 < val_split < 1.0):
+        raise ValueError("val_split must be between 0.0 and 1.0.")
+    if patience < 0:
+        raise ValueError("patience must be a non-negative integer.")
+    if device not in ["cpu", "cuda"]:
+        raise ValueError("device must be either 'cpu' or 'cuda'.")
+    if lkj_concentration <= 0:
+        raise ValueError("lkj_concentration must be positive.")
+
+    # --- Command-line construction ---
+    # Echidna is a library, so we are assuming a hypothetical wrapper script
+    # `run_echidna_script.py` that exposes its functionality via CLI.
+    # This is a common pattern for converting libraries to MCP tools.
+    cmd = [
+        "echidna_runner",  # Hypothetical executable script
+        "--input-adata", str(input_adata),
+        "--output-prefix", output_prefix,
+        "--timepoint-label", timepoint_label,
+        "--counts-layer", counts_layer,
+        "--clusters", clusters,
+        "--seed", str(seed),
+        "--n-steps", str(n_steps),
+        "--learning-rate", str(learning_rate),
+        "--val-split", str(val_split),
+        "--patience", str(patience),
+        "--device", device,
+        "--eta-mean-init", str(eta_mean_init),
+        "--lkj-concentration", str(lkj_concentration),
+        "--q-corr-init", str(q_corr_init),
+        "--q-shape-rate-scaler", str(q_shape_rate_scaler),
+    ]
+
+    if verbose:
+        cmd.append("--verbose")
+    if inverse_gamma:
+        cmd.append("--inverse-gamma")
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = result.stdout
+        stderr = result.stderr
+    except FileNotFoundError:
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: The 'echidna_runner' executable was not found. Please ensure the echidna environment is correctly configured and the wrapper script is in the system's PATH.",
+            "output_files": [],
+            "return_code": 1,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    # --- Structured Result Return ---
+    # Define expected output files based on the hypothetical wrapper's behavior.
+    # This typically includes the updated AnnData object, a saved model, and plots.
+    output_files = [
+        f"{output_prefix}_adata.h5ad",
+        f"{output_prefix}_model.pt",
+        f"{output_prefix}_gene_dosage.csv",
+        f"{output_prefix}_gene_dosage.png",
+    ]
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files,
+        "return_code": 0,
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")