Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_abundancebin/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 abundancebin via conda (e.g., from bioconda)
+RUN conda install -c bioconda abundancebin -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/abundancebin_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/abundancebin_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/abundancebin_server.py"]
+        

Biomni/mcp_generated/mcp_abundancebin/app/abundancebin_server.py

@@ -0,0 +1,136 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, List
+
+# Assume @mcp.tool() is defined in the execution environment.
+# No import is needed for the final code.
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_abundancebin'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def abundancebin(
+    input_file: Path,
+    kmer_len: int = 20,
+    output: Optional[Path] = None,
+    exclude: Optional[int] = None,
+    exclude_max: Optional[int] = None,
+    output_fasta: bool = False,
+    bin_num: Optional[int] = None,
+    recursive_classification: bool = False,
+):
+    """
+    Performs abundance-based binning on a given input FASTA/FASTQ file.
+
+    This tool uses k-mer frequency to classify sequences into bins. It can either
+    classify into a specified number of bins or use a recursive classification approach.
+
+    Args:
+        input_file: Path to the input FASTA/FASTQ file.
+        kmer_len: The length of the k-mer to use for composition analysis (default: 20).
+        output: Path to the output log file. If not provided, defaults to '<input_file>.log'.
+        exclude: Exclude contigs with coverage lower than this count.
+        exclude_max: Exclude contigs with coverage higher than this count.
+        output_fasta: If True, output binned sequences into separate FASTA files.
+        bin_num: The specific number of bins to classify sequences into.
+        recursive_classification: If True, undergo recursive classification instead of specifying a bin number.
+                                  This is mutually exclusive with 'bin_num'.
+    
+    Returns:
+        A dictionary containing the execution details and paths to output files.
+    """
+    # 1. Input Validation
+    if not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    if bin_num is not None and recursive_classification:
+        raise ValueError("Parameters 'bin_num' and 'recursive_classification' are mutually exclusive. Please provide only one.")
+
+    if kmer_len <= 0:
+        raise ValueError("kmer_len must be a positive integer.")
+
+    # 2. Command Construction
+    # Determine the output file path based on the tool's default behavior
+    if output:
+        output_path = output
+    else:
+        output_path = input_file.with_suffix(".log")
+
+    # Ensure the output directory exists
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    cmd = [
+        "abundancebin",
+        "-input", str(input_file),
+        "-kmer_len", str(kmer_len),
+        "-output", str(output_path)
+    ]
+
+    if exclude is not None:
+        cmd.extend(["-exclude", str(exclude)])
+
+    if exclude_max is not None:
+        cmd.extend(["-exclude_max", str(exclude_max)])
+
+    if output_fasta:
+        cmd.append("-OUTPUT_FASTA")
+
+    if bin_num is not None:
+        cmd.extend(["-bin_num", str(bin_num)])
+
+    if recursive_classification:
+        cmd.append("-RECURSIVE_CLASSIFICATION")
+
+    command_executed = " ".join(cmd)
+    logger.info(f"Executing command: {command_executed}")
+
+    # 3. Subprocess Execution and Error Handling
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        # The tool might generate more files if -OUTPUT_FASTA is used.
+        # For simplicity, we return the main log file. The user can infer others.
+        output_files = [str(output_path)] if output_path.exists() else []
+
+        # 4. Structured Result Return (Success)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files
+        }
+
+    except FileNotFoundError:
+        error_message = "abundancebin command not found. Please ensure the tool is installed and in your system's PATH."
+        logger.error(error_message)
+        # Re-raising is often better to signal a fatal environment error.
+        raise RuntimeError(error_message) from None
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"abundancebin failed with exit code {e.returncode}")
+        logger.error(f"Stderr: {e.stderr}")
+        logger.error(f"Stdout: {e.stdout}")
+        
+        # 4. Structured Result Return (Failure)
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_abundancebin/app/abundancebin_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_abundancebin/app/abundancebin_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_abundancebin'
+
+
+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_abundancebin/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_abundancebin/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_abundancebin/requirements.txt

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

Biomni/mcp_generated/mcp_anarci/app/anarci_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_anarci/app/anarci_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_anarci'
+
+
+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_anarci/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-biostrings/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-biostrings via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-biostrings -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY bioconductor-biostrings_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-biostrings_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-biostrings_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-biostrings/app/bioconductor-biostrings_server.py

@@ -0,0 +1,144 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# Mock the decorator for standalone execution
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(func):
+            return func
+        return decorator
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_biostrings'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def rscript(
+    script_file: Optional[Path] = None,
+    expressions: Optional[List[str]] = None,
+    script_args: Optional[List[str]] = None,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+    vanilla: bool = False,
+    save: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    restore: bool = False,
+) -> Dict[str, Any]:
+    """
+    Executes an R script or R expressions using the Rscript command-line tool.
+
+    This tool serves as a wrapper for Rscript, allowing for the execution of R code
+    from a file or directly from string expressions. It mirrors the functionality
+    provided by `Rscript --help`.
+
+    Args:
+        script_file: Path to the R script file to be executed. Mutually exclusive with 'expressions'.
+        expressions: A list of R expressions to be executed. Mutually exclusive with 'script_file'.
+        script_args: A list of arguments to be passed to the R script itself.
+        verbose: If True, enables verbose output, printing information on progress.
+        default_packages: A comma-separated string of package names to be loaded by default.
+        vanilla: If True, combines --no-save, --no-restore, --no-site-file, --no-init-file, and --no-environ.
+                 If set, it overrides the individual flags (save, restore, etc.).
+        save: If True, the workspace is saved at the end of the session. Ignored if 'vanilla' is True.
+        no_environ: If True, site and user environment files are not read. Ignored if 'vanilla' is True.
+        no_site_file: If True, the site-wide Rprofile is not read. Ignored if 'vanilla' is True.
+        no_init_file: If True, the user's R profile is not read. Ignored if 'vanilla' is True.
+        restore: If True, previously saved objects are restored at startup. Ignored if 'vanilla' is True.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files (always empty).
+    """
+    # 1. Input Validation
+    if not script_file and not expressions:
+        raise ValueError("Either 'script_file' or 'expressions' must be provided.")
+    if script_file and expressions:
+        raise ValueError("'script_file' and 'expressions' are mutually exclusive and cannot be used together.")
+    if script_file and not script_file.is_file():
+        raise FileNotFoundError(f"The specified script file does not exist: {script_file}")
+    if expressions and not expressions:
+        raise ValueError("'expressions' list cannot be empty if provided.")
+
+    # 2. Command Construction
+    cmd = ["Rscript"]
+
+    if verbose:
+        cmd.append("--verbose")
+
+    if default_packages:
+        cmd.extend(["--default-packages", default_packages])
+
+    if vanilla:
+        cmd.append("--vanilla")
+    else:
+        # These options are combined and handled by the --vanilla flag in Rscript
+        if save:
+            cmd.append("--save")
+        if no_environ:
+            cmd.append("--no-environ")
+        if no_site_file:
+            cmd.append("--no-site-file")
+        if no_init_file:
+            cmd.append("--no-init-file")
+        if restore:
+            cmd.append("--restore")
+
+    # Add expressions or script file to the command
+    if expressions:
+        for expr in expressions:
+            cmd.extend(["-e", expr])
+    elif script_file:
+        cmd.append(str(script_file))
+
+    # Add arguments for the R script itself
+    if script_args:
+        cmd.extend(script_args)
+
+    command_str = " ".join(cmd)
+    logging.info(f"Executing command: {command_str}")
+
+    # 3. Subprocess Execution and Error Handling
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = result.stdout
+        stderr = result.stderr
+    except FileNotFoundError:
+        # This error occurs if 'Rscript' is not in the system's PATH
+        return {
+            "command_executed": command_str,
+            "stdout": "",
+            "stderr": "Error: 'Rscript' command not found. Please ensure R is installed and accessible in your system's PATH.",
+            "output_files": []
+        }
+    except subprocess.CalledProcessError as e:
+        # This error occurs if the R script itself fails (non-zero exit code)
+        logging.error(f"Rscript execution failed with return code {e.returncode}")
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": []
+        }
+
+    # 4. Structured Result Return
+    # Rscript itself does not have a dedicated output file parameter. Any files
+    # created are determined by the R code within the script.
+    return {
+        "command_executed": command_str,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": []
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-biostrings/app/bioconductor-biostrings_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-biostrings/app/bioconductor-biostrings_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_biostrings'
+
+
+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-biostrings/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-biostrings/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-despace/app/bioconductor-despace_server.py

@@ -0,0 +1,303 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, List
+
+# MCP is a placeholder for the Model Context Protocol library.
+# In a real environment, this would be: from mcp import tool
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(func):
+            return func
+        return decorator
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_despace'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def cluster_scrnaseq(
+    sc_object_path: Path,
+    output_rds_path: Path,
+    s_topics: int = 10,
+    n_top_genes: int = 2000,
+) -> dict:
+    """
+    Performs clustering on single-cell RNA-seq data as a preprocessing step for DeSpace.
+
+    This tool wraps the `cluster_scRNAseq` function from the DeSpace R package. It takes a
+    Seurat object, identifies highly variable genes, performs dimensionality reduction,
+    and identifies clusters based on topic modeling.
+
+    Args:
+        sc_object_path: Path to the input single-cell Seurat object (.rds file).
+        output_rds_path: Path to save the clustered single-cell Seurat object (.rds file).
+        s_topics: The number of topics (S) for topic modeling, representing putative cell types.
+        n_top_genes: Number of highly variable genes to use for clustering.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and the path to the output file.
+    """
+    # --- Input Validation ---
+    if not sc_object_path.is_file():
+        raise FileNotFoundError(f"Input single-cell object not found: {sc_object_path}")
+    if not output_rds_path.parent.exists():
+        output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+        logging.info(f"Created output directory: {output_rds_path.parent}")
+
+    if s_topics <= 0:
+        raise ValueError("s_topics must be a positive integer.")
+    if n_top_genes <= 0:
+        raise ValueError("n_top_genes must be a positive integer.")
+
+    # --- Command Construction ---
+    # This assumes a wrapper R script 'cluster_scrnaseq.R' is in the system's PATH.
+    cmd = [
+        "Rscript", "cluster_scrnaseq.R",
+        "--sc_object_path", str(sc_object_path),
+        "--output_rds_path", str(output_rds_path),
+        "--s_topics", str(s_topics),
+        "--n_top_genes", str(n_top_genes),
+    ]
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    # --- Subprocess Execution ---
+    try:
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+        logging.info("Single-cell clustering completed successfully.")
+    except FileNotFoundError:
+        err_msg = "Error: 'Rscript' command not found. Please ensure R and the required wrapper scripts are in the system's PATH."
+        logging.error(err_msg)
+        return {"command_executed": command_executed, "stdout": "", "stderr": err_msg, "output_files": []}
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Single-cell clustering failed with exit code {e.returncode}.")
+        return {"command_executed": command_executed, "stdout": e.stdout, "stderr": e.stderr, "output_files": []}
+
+    # --- Structured Result Return ---
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [str(output_rds_path)]
+    }
+
+@mcp.tool()
+def cluster_sp_data(
+    sp_object_path: Path,
+    output_rds_path: Path,
+    resolution: float = 0.8,
+) -> dict:
+    """
+    Performs clustering on spatial transcriptomics data as a preprocessing step for DeSpace.
+
+    This tool wraps the `cluster_sp_data` function from the DeSpace R package. It takes a
+    spatial Seurat object, normalizes the data, finds variable features, and performs
+    graph-based clustering.
+
+    Args:
+        sp_object_path: Path to the input spatial Seurat object (.rds file).
+        output_rds_path: Path to save the clustered spatial Seurat object (.rds file).
+        resolution: Clustering resolution for the Louvain algorithm.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and the path to the output file.
+    """
+    # --- Input Validation ---
+    if not sp_object_path.is_file():
+        raise FileNotFoundError(f"Input spatial object not found: {sp_object_path}")
+    if not output_rds_path.parent.exists():
+        output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+        logging.info(f"Created output directory: {output_rds_path.parent}")
+
+    if resolution <= 0.0:
+        raise ValueError("resolution must be a positive float.")
+
+    # --- Command Construction ---
+    # This assumes a wrapper R script 'cluster_sp_data.R' is in the system's PATH.
+    cmd = [
+        "Rscript", "cluster_sp_data.R",
+        "--sp_object_path", str(sp_object_path),
+        "--output_rds_path", str(output_rds_path),
+        "--resolution", str(resolution),
+    ]
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    # --- Subprocess Execution ---
+    try:
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+        logging.info("Spatial data clustering completed successfully.")
+    except FileNotFoundError:
+        err_msg = "Error: 'Rscript' command not found. Please ensure R and the required wrapper scripts are in the system's PATH."
+        logging.error(err_msg)
+        return {"command_executed": command_executed, "stdout": "", "stderr": err_msg, "output_files": []}
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Spatial data clustering failed with exit code {e.returncode}.")
+        return {"command_executed": command_executed, "stdout": e.stdout, "stderr": e.stderr, "output_files": []}
+
+    # --- Structured Result Return ---
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [str(output_rds_path)]
+    }
+
+@mcp.tool()
+def run_despace(
+    sc_object_path: Path,
+    sp_object_path: Path,
+    output_rds_path: Path,
+    sc_assay: str = "RNA",
+    sc_slot: str = "counts",
+    sp_assay: str = "Spatial",
+    sp_slot: str = "counts",
+    num_markers_sc: int = 10,
+    num_markers_sp: int = 10,
+    s_topics: int = 10,
+    n_top_genes: int = 2000,
+    resolution: float = 0.8,
+    sample_id: Optional[str] = None,
+    num_threads: int = 1,
+    save_model: bool = False,
+    model_path: Optional[Path] = None,
+) -> dict:
+    """
+    Runs the main DeSpace algorithm to integrate single-cell and spatial transcriptomics data.
+
+    This tool wraps the `DeSpace` R function. It can perform clustering internally if not
+    already present in the input objects, or it can use pre-computed clusters. The main
+    output is a Seurat object with cell-type deconvolution results.
+
+    Args:
+        sc_object_path: Path to the single-cell Seurat object (.rds file).
+        sp_object_path: Path to the spatial transcriptomics Seurat object (.rds file).
+        output_rds_path: Path to save the resulting Seurat object with DeSpace results.
+        sc_assay: Assay to use from the single-cell Seurat object.
+        sc_slot: Slot to use from the single-cell assay (e.g., 'counts', 'data').
+        sp_assay: Assay to use from the spatial Seurat object.
+        sp_slot: Slot to use from the spatial assay (e.g., 'counts', 'data').
+        num_markers_sc: Number of markers to use for each single-cell cluster.
+        num_markers_sp: Number of markers to use for each spatial cluster.
+        s_topics: The number of topics (S) for topic modeling, used if sc-data is not pre-clustered.
+        n_top_genes: Number of highly variable genes, used if sc-data is not pre-clustered.
+        resolution: Clustering resolution, used if sp-data is not pre-clustered.
+        sample_id: Optional identifier for the sample, used for saving the model.
+        num_threads: Number of parallel threads to use.
+        save_model: If True, save the trained DeSpace model.
+        model_path: Path to save the DeSpace model file. Required if save_model is True.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not sc_object_path.is_file():
+        raise FileNotFoundError(f"Single-cell input file not found: {sc_object_path}")
+    if not sp_object_path.is_file():
+        raise FileNotFoundError(f"Spatial input file not found: {sp_object_path}")
+
+    if not output_rds_path.parent.exists():
+        output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+        logging.info(f"Created output directory: {output_rds_path.parent}")
+
+    if num_markers_sc <= 0:
+        raise ValueError("num_markers_sc must be a positive integer.")
+    if num_markers_sp <= 0:
+        raise ValueError("num_markers_sp must be a positive integer.")
+    if s_topics <= 0:
+        raise ValueError("s_topics must be a positive integer.")
+    if n_top_genes <= 0:
+        raise ValueError("n_top_genes must be a positive integer.")
+    if resolution <= 0.0:
+        raise ValueError("resolution must be a positive float.")
+    if num_threads <= 0:
+        raise ValueError("num_threads must be a positive integer.")
+
+    if save_model:
+        if model_path is None:
+            raise ValueError("model_path must be provided when save_model is True.")
+        if not model_path.parent.exists():
+            model_path.parent.mkdir(parents=True, exist_ok=True)
+            logging.info(f"Created model output directory: {model_path.parent}")
+
+    # --- Command Construction ---
+    # This assumes a wrapper R script 'run_despace.R' is in the system's PATH.
+    cmd = [
+        "Rscript", "run_despace.R",
+        "--sc_object_path", str(sc_object_path),
+        "--sp_object_path", str(sp_object_path),
+        "--output_rds_path", str(output_rds_path),
+        "--sc_assay", sc_assay,
+        "--sc_slot", sc_slot,
+        "--sp_assay", sp_assay,
+        "--sp_slot", sp_slot,
+        "--num_markers_sc", str(num_markers_sc),
+        "--num_markers_sp", str(num_markers_sp),
+        "--s_topics", str(s_topics),
+        "--n_top_genes", str(n_top_genes),
+        "--resolution", str(resolution),
+        "--num_threads", str(num_threads),
+    ]
+
+    if sample_id:
+        cmd.extend(["--sample_id", sample_id])
+    
+    if save_model and model_path:
+        cmd.append("--save_model")
+        cmd.extend(["--model_path", str(model_path)])
+
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    # --- Subprocess Execution ---
+    try:
+        process = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+        logging.info("DeSpace execution completed successfully.")
+    except FileNotFoundError:
+        err_msg = "Error: 'Rscript' command not found. Please ensure R and the required wrapper scripts are in the system's PATH."
+        logging.error(err_msg)
+        return {"command_executed": command_executed, "stdout": "", "stderr": err_msg, "output_files": []}
+    except subprocess.CalledProcessError as e:
+        logging.error(f"DeSpace execution failed with exit code {e.returncode}.")
+        return {"command_executed": command_executed, "stdout": e.stdout, "stderr": e.stderr, "output_files": []}
+
+    # --- Structured Result Return ---
+    output_files: List[str] = [str(output_rds_path)]
+    if save_model and model_path:
+        output_files.append(str(model_path))
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-despace/app/bioconductor-despace_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-despace/app/bioconductor-despace_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_despace'
+
+
+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-despace/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-despace/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-geomxtools/app/bioconductor-geomxtools_server.py

@@ -0,0 +1,688 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List
+
+# In a real MCP environment, this would be imported.
+# from mcp import tool as mcp_tool
+# For this exercise, we assume the decorator @mcp.tool() is available.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(func):
+            return func
+        return decorator
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_geomxtools'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def read_nanostring_geomx_set(
+    dcc_files_dir: Path,
+    pkc_files: List[Path],
+    pheno_data_file: Path,
+    output_rds_path: Path,
+    pheno_data_sheet: Optional[str] = None,
+    pheno_data_dcc_col_name: str = "Sample_ID",
+    protocol_data_col_names: Optional[List[str]] = None,
+    experiment_data_col_names: Optional[List[str]] = None,
+) -> dict:
+    """
+    Reads NanoString GeoMx files (DCC, PKC, annotation) and creates a NanoStringGeomxSet object.
+
+    This tool is a wrapper around the `readNanoStringGeoMxSet` function from the
+    R/Bioconductor package `GeomxTools`. It processes raw data into a structured
+    R object for downstream analysis.
+
+    Args:
+        dcc_files_dir: Path to the directory containing DCC files.
+        pkc_files: A list of paths to PKC files.
+        pheno_data_file: Path to the sample annotation file (e.g., an Excel file).
+        output_rds_path: Path for the output RDS file which will contain the NanoStringGeomxSet object.
+        pheno_data_sheet: Optional name of the worksheet in the Excel annotation file.
+        pheno_data_dcc_col_name: Column name in the annotation file that matches DCC file names.
+        protocol_data_col_names: Optional list of column names in annotation to be added to protocolData.
+        experiment_data_col_names: Optional list of column names in annotation to be added to experimentData.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output RDS file.
+    """
+    # --- Input Validation ---
+    if not dcc_files_dir.is_dir():
+        raise ValueError(f"DCC files directory not found: {dcc_files_dir}")
+    if not pkc_files:
+        raise ValueError("At least one PKC file must be provided.")
+    for pkc_file in pkc_files:
+        if not pkc_file.is_file():
+            raise ValueError(f"PKC file not found: {pkc_file}")
+    if not pheno_data_file.is_file():
+        raise ValueError(f"Phenotype data file not found: {pheno_data_file}")
+    
+    output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    # Safely create R vectors from Python lists
+    r_protocol_cols = f'c({", ".join(f"{col}" for col in protocol_data_col_names)})' if protocol_data_col_names else "NULL"
+    r_experiment_cols = f'c({", ".join(f"{col}" for col in experiment_data_col_names)})' if experiment_data_col_names else "NULL"
+    r_pheno_sheet = f'"{pheno_data_sheet}"' if pheno_data_sheet else "NULL"
+    pkc_files_r_vector = f'c({", ".join(f"{str(p)}" for p in pkc_files)})'
+
+    r_script_content = f"""
+    library(GeomxTools)
+    
+    tryCatch({{
+        dcc_dir <- "{dcc_files_dir}"
+        pkc_files_vec <- {pkc_files_r_vector}
+        pheno_file <- "{pheno_data_file}"
+        output_path <- "{output_rds_path}"
+        pheno_dcc_col <- "{pheno_data_dcc_col_name}"
+
+        dcc_files <- list.files(dcc_dir, pattern = "\\\\.dcc$", full.names = TRUE, recursive = TRUE)
+        if (length(dcc_files) == 0) {{
+            stop("No .dcc files found in the specified directory.")
+        }}
+
+        geomx_data <- readNanoStringGeoMxSet(
+            dccFiles = dcc_files,
+            pkcFiles = pkc_files_vec,
+            phenoDataFile = pheno_file,
+            phenoDataSheet = {r_pheno_sheet},
+            phenoDataDccColName = pheno_dcc_col,
+            protocolDataColNames = {r_protocol_cols},
+            experimentDataColNames = {r_experiment_cols}
+        )
+
+        saveRDS(geomx_data, file = output_path)
+        cat("Successfully created NanoStringGeomxSet object and saved to", output_path, "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_rds_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+@mcp.tool()
+def set_segment_qc_flags(
+    input_rds_path: Path,
+    output_rds_path: Path,
+    min_segment_reads: Optional[int] = 1000,
+    percent_aligned: Optional[float] = 80,
+    percent_saturation: Optional[float] = 50,
+    min_negative_count: Optional[int] = 10,
+    max_ntc_count: Optional[int] = 1000,
+    min_nuclei: Optional[int] = 200,
+    min_area: Optional[int] = 16000,
+) -> dict:
+    """
+    Sets segment QC flags in a NanoStringGeomxSet object based on specified cutoffs.
+
+    Args:
+        input_rds_path: Path to the input RDS file containing a NanoStringGeomxSet object.
+        output_rds_path: Path for the output RDS file with QC flags applied.
+        min_segment_reads: Minimum number of reads in a segment.
+        percent_aligned: Minimum percentage of reads aligned.
+        percent_saturation: Minimum percentage of reads saturated.
+        min_negative_count: Minimum negative probe counts.
+        max_ntc_count: Maximum counts observed in NTC wells.
+        min_nuclei: Minimum number of nuclei in a segment.
+        min_area: Minimum area of a segment.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output RDS file.
+    """
+    # --- Input Validation ---
+    if not input_rds_path.is_file():
+        raise ValueError(f"Input RDS file not found: {input_rds_path}")
+    output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    r_script_content = f"""
+    library(GeomxTools)
+    
+    tryCatch({{
+        input_rds <- "{input_rds_path}"
+        output_rds <- "{output_rds_path}"
+        
+        geomx_data <- readRDS(input_rds)
+        
+        qc_cutoffs <- list()
+        if (!is.null({min_segment_reads or 'NULL'})) {{ qc_cutoffs$minSegmentReads <- {min_segment_reads} }}
+        if (!is.null({percent_aligned or 'NULL'})) {{ qc_cutoffs$percentAligned <- {percent_aligned} }}
+        if (!is.null({percent_saturation or 'NULL'})) {{ qc_cutoffs$percentSaturation <- {percent_saturation} }}
+        if (!is.null({min_negative_count or 'NULL'})) {{ qc_cutoffs$minNegativeCount <- {min_negative_count} }}
+        if (!is.null({max_ntc_count or 'NULL'})) {{ qc_cutoffs$maxNTCCount <- {max_ntc_count} }}
+        if (!is.null({min_nuclei or 'NULL'})) {{ qc_cutoffs$minNuclei <- {min_nuclei} }}
+        if (!is.null({min_area or 'NULL'})) {{ qc_cutoffs$minArea <- {min_area} }}
+        
+        geomx_data_qc <- setSegmentQCFlags(geomx_data, qcCutoffs = qc_cutoffs)
+        
+        saveRDS(geomx_data_qc, file = output_rds)
+        cat("Successfully applied segment QC flags and saved to", output_rds, "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_rds_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+@mcp.tool()
+def set_bioprobe_qc_flags(
+    input_rds_path: Path,
+    output_rds_path: Path,
+    min_probe_ratio: float = 0.1,
+    percent_fail_grubbs: float = 20,
+    remove_local_outliers: bool = True,
+) -> dict:
+    """
+    Sets probe QC flags in a NanoStringGeomxSet object.
+
+    Args:
+        input_rds_path: Path to the input RDS file containing a NanoStringGeomxSet object.
+        output_rds_path: Path for the output RDS file with QC flags applied.
+        min_probe_ratio: Minimum ratio of probes to the geometric mean of all probes.
+        percent_fail_grubbs: Percentage of segments that must fail Grubbs test for a probe to be flagged.
+        remove_local_outliers: If TRUE, local outliers will be removed.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output RDS file.
+    """
+    # --- Input Validation ---
+    if not input_rds_path.is_file():
+        raise ValueError(f"Input RDS file not found: {input_rds_path}")
+    output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    r_script_content = f"""
+    library(GeomxTools)
+    
+    tryCatch({{
+        input_rds <- "{input_rds_path}"
+        output_rds <- "{output_rds_path}"
+        
+        geomx_data <- readRDS(input_rds)
+        
+        qc_cutoffs <- list(
+            minProbeRatio = {min_probe_ratio},
+            percentFailGrubbs = {percent_fail_grubbs}
+        )
+        
+        geomx_data_qc <- setBioProbeQCFlags(
+            geomx_data, 
+            qcCutoffs = qc_cutoffs, 
+            removeLocalOutliers = {str(remove_local_outliers).upper()}
+        )
+        
+        saveRDS(geomx_data_qc, file = output_rds)
+        cat("Successfully applied bioprobe QC flags and saved to", output_rds, "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_rds_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+@mcp.tool()
+def subset_geomx_set(
+    input_rds_path: Path,
+    output_rds_path: Path,
+    subset_by_pdata: bool = True,
+    subset_column: Optional[str] = None,
+    subset_values: Optional[List[str]] = None,
+) -> dict:
+    """
+    Subsets a NanoStringGeomxSet object based on phenotype (pData) or feature (fData) annotations.
+
+    Args:
+        input_rds_path: Path to the input RDS file containing a NanoStringGeomxSet object.
+        output_rds_path: Path for the output subsetted RDS file.
+        subset_by_pdata: If True, subset by sample annotations (pData). If False, subset by feature annotations (fData).
+        subset_column: The column name in pData or fData to use for subsetting.
+        subset_values: A list of values to keep from the subset_column.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output RDS file.
+    """
+    # --- Input Validation ---
+    if not input_rds_path.is_file():
+        raise ValueError(f"Input RDS file not found: {input_rds_path}")
+    if not subset_column or not subset_values:
+        raise ValueError("subset_column and subset_values must be provided for subsetting.")
+    output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    subset_values_r = f'c({", ".join(f"{v}" for v in subset_values)})'
+    
+    r_script_content = f"""
+    library(GeomxTools)
+    library(Biobase)
+
+    tryCatch({{
+        object <- readRDS("{input_rds_path}")
+        subset_col <- "{subset_column}"
+        subset_vals <- {subset_values_r}
+        
+        if ({str(subset_by_pdata).upper()}) {{
+            logic <- pData(object)[[subset_col]] %in% subset_vals
+            logic[is.na(logic)] <- FALSE
+            subset_object <- object[, logic]
+        }} else {{
+            logic <- fData(object)[[subset_col]] %in% subset_vals
+            logic[is.na(logic)] <- FALSE
+            subset_object <- object[logic, ]
+        }}
+
+        saveRDS(subset_object, file = "{output_rds_path}")
+        cat("Successfully subset object and saved to", "{output_rds_path}", "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_rds_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+@mcp.tool()
+def aggregate_counts(
+    input_rds_path: Path,
+    output_rds_path: Path,
+    elt: str = "exprs",
+) -> dict:
+    """
+    Aggregates probe-level counts to the target level in a NanoStringGeomxSet object.
+
+    Args:
+        input_rds_path: Path to the input RDS file containing a NanoStringGeomxSet object.
+        output_rds_path: Path for the output RDS file with aggregated counts.
+        elt: The name of the assay data element to aggregate.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output RDS file.
+    """
+    # --- Input Validation ---
+    if not input_rds_path.is_file():
+        raise ValueError(f"Input RDS file not found: {input_rds_path}")
+    output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    r_script_content = f"""
+    library(GeomxTools)
+    
+    tryCatch({{
+        geomx_data <- readRDS("{input_rds_path}")
+        aggregated_data <- aggregateCounts(geomx_data, elt = "{elt}")
+        
+        saveRDS(aggregated_data, file = "{output_rds_path}")
+        cat("Successfully aggregated counts and saved to", "{output_rds_path}", "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_rds_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+@mcp.tool()
+def normalize_geomx(
+    input_rds_path: Path,
+    output_rds_path: Path,
+    norm_method: str,
+    from_elt: str = "exprs",
+    to_elt: str = "exprs_norm",
+    housekeepers: Optional[List[str]] = None,
+) -> dict:
+    """
+    Normalizes the count data in a NanoStringGeomxSet object.
+
+    Args:
+        input_rds_path: Path to the input RDS file containing a NanoStringGeomxSet object.
+        output_rds_path: Path for the output RDS file with normalized data.
+        norm_method: Normalization method. Must be one of 'quant', 'neg', 'hk'.
+        from_elt: The assay data element to use for normalization.
+        to_elt: The name of the new assay data element to store normalized values.
+        housekeepers: A list of housekeeper gene names, required if norm_method is 'hk'.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output RDS file.
+    """
+    # --- Input Validation ---
+    if not input_rds_path.is_file():
+        raise ValueError(f"Input RDS file not found: {input_rds_path}")
+    
+    valid_methods = ["quant", "neg", "hk"]
+    if norm_method not in valid_methods:
+        raise ValueError(f"Invalid norm_method '{norm_method}'. Must be one of {valid_methods}.")
+    
+    if norm_method == "hk" and not housekeepers:
+        raise ValueError("Housekeeper genes must be provided for 'hk' normalization.")
+        
+    output_rds_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    housekeepers_r = f'c({", ".join(f"{hk}" for hk in housekeepers)})' if housekeepers else "NULL"
+
+    # --- R Script Generation ---
+    r_script_content = f"""
+    library(GeomxTools)
+    
+    tryCatch({{
+        geomx_data <- readRDS("{input_rds_path}")
+        
+        normalized_data <- normalize(
+            geomx_data, 
+            norm.method = "{norm_method}", 
+            fromElt = "{from_elt}", 
+            toElt = "{to_elt}", 
+            housekeepers = {housekeepers_r}
+        )
+        
+        saveRDS(normalized_data, file = "{output_rds_path}")
+        cat("Successfully normalized data and saved to", "{output_rds_path}", "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_rds_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+@mcp.tool()
+def mixed_model_de(
+    input_rds_path: Path,
+    output_csv_path: Path,
+    elt: str,
+    model_formula_fixed: str,
+    group_var: str,
+    model_formula_random: Optional[str] = None,
+    contrasts: Optional[List[str]] = None,
+    n_cores: int = 1,
+) -> dict:
+    """
+    Performs differential expression analysis using a linear mixed model.
+
+    Args:
+        input_rds_path: Path to the input RDS file containing a NanoStringGeomxSet object.
+        output_csv_path: Path for the output CSV file with DE results.
+        elt: The assay data element to use for the analysis (e.g., 'exprs_norm').
+        model_formula_fixed: The fixed effects part of the model formula (e.g., 'region + diseaseStatus').
+        group_var: The main variable of interest for testing (e.g., 'diseaseStatus').
+        model_formula_random: The random effects part of the model formula (e.g., '(1|slideName)').
+        contrasts: A list of contrasts to test (e.g., ['diseaseA - diseaseB', 'diseaseC - diseaseB']).
+        n_cores: Number of cores to use for parallel processing.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and the path to the output CSV file.
+    """
+    # --- Input Validation ---
+    if not input_rds_path.is_file():
+        raise ValueError(f"Input RDS file not found: {input_rds_path}")
+    if n_cores < 1:
+        raise ValueError("n_cores must be at least 1.")
+    output_csv_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    formula_str = f"~ {model_formula_fixed}"
+    if model_formula_random:
+        formula_str += f" + {model_formula_random}"
+
+    contrasts_r = "NULL"
+    if contrasts:
+        contrasts_r = f'c({", ".join(f"{c}" for c in contrasts)})'
+
+    r_script_content = f"""
+    library(GeomxTools)
+    library(limma)
+    library(Biobase)
+
+    tryCatch({{
+        object <- readRDS("{input_rds_path}")
+        
+        model_formula <- as.formula("{formula_str}")
+        
+        contrast_matrix <- NULL
+        if (!is.null({contrasts_r})) {{
+            contrast_matrix <- makeContrasts(contrasts = {contrasts_r}, levels = unique(pData(object)[["{group_var}"]]))
+        }}
+        
+        results <- mixedModelDE(
+            object,
+            elt = "{elt}",
+            modelFormula = model_formula,
+            groupVar = "{group_var}",
+            nCores = {n_cores},
+            multiCore = {str(n_cores > 1).upper()},
+            contrasts = contrast_matrix
+        )
+        
+        write.csv(results, file = "{output_csv_path}", row.names = FALSE)
+        cat("Successfully performed DE analysis and saved results to", "{output_csv_path}", "\\n")
+    }}, error = function(e) {{
+        message("R script failed with error: ", e$message)
+        quit(status = 1)
+    }})
+    """
+
+    # --- Subprocess Execution ---
+    command_executed = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = ["Rscript", r_script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_csv_path)]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-geomxtools/app/bioconductor-geomxtools_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-geomxtools/app/bioconductor-geomxtools_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_geomxtools'
+
+
+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-geomxtools/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-geomxtools/requirements.txt

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

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

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

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

Biomni/mcp_generated/mcp_bioconductor-infercnv/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-infercnv via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-infercnv -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY bioconductor-infercnv_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-infercnv_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-infercnv_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-infercnv/app/bioconductor-infercnv_server.py

@@ -0,0 +1,298 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List
+import tempfile
+import shlex
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_infercnv'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def infercnv_run(
+    raw_counts_matrix: str,
+    annotations_file: str,
+    gene_order_file: str,
+    out_dir: str,
+    ref_group_names: Optional[List[str]] = None,
+    cutoff: float = 1.0,
+    min_cells_per_gene: int = 3,
+    cluster_by_groups: bool = True,
+    denoise: bool = False,
+    hmm: bool = False,
+    hmm_type: str = "i6",
+    analysis_mode: str = "samples",
+    num_threads: int = 1,
+    plot_steps: bool = False,
+    no_plot: bool = False,
+    window_length: int = 101,
+    max_centered_threshold: float = 3.0,
+    leiden_resolution: float = 0.05,
+):
+    """
+    Run the full InferCNV pipeline to identify somatic copy number alterations in single-cell RNA-seq data.
+    
+    Args:
+        raw_counts_matrix: Path to the matrix of gene expression counts (genes as rows, cells as columns).
+        annotations_file: Path to the cell annotations file (cell name and group).
+        gene_order_file: Path to the gene positions file (gene, chromosome, start, stop).
+        out_dir: Directory to save the output files.
+        ref_group_names: List of group names to use as reference (normal) cells. If None, all cells are used.
+        cutoff: Threshold for gene expression. Use 1.0 for Smart-seq2 and 0.1 for 10x Genomics.
+        min_cells_per_gene: Minimum number of cells a gene must be expressed in to be kept.
+        cluster_by_groups: Whether to cluster cells by their annotation groups.
+        denoise: Whether to apply denoising filters.
+        hmm: Whether to run the Hidden Markov Model (HMM) to predict CNV states.
+        hmm_type: Type of HMM to use ('i6' for 6-state model, 'i3' for 3-state model).
+        analysis_mode: Analysis mode ('samples' or 'subclusters').
+        num_threads: Number of CPU threads to use for parallel processing.
+        plot_steps: Whether to generate plots for every intermediate step.
+        no_plot: If True, skips the final heatmap generation.
+        window_length: Length of the moving average window for smoothing.
+        max_centered_threshold: Maximum value for centering the expression data.
+        leiden_resolution: Resolution for Leiden clustering if analysis_mode is 'subclusters'.
+    """
+    # Input validation
+    raw_path = Path(raw_counts_matrix)
+    ann_path = Path(annotations_file)
+    gene_path = Path(gene_order_file)
+    out_path = Path(out_dir)
+
+    if not raw_path.exists():
+        return {"error": f"Raw counts matrix not found: {raw_counts_matrix}"}
+    if not ann_path.exists():
+        return {"error": f"Annotations file not found: {annotations_file}"}
+    if not gene_path.exists():
+        return {"error": f"Gene order file not found: {gene_order_file}"}
+    
+    if hmm_type not in ["i6", "i3"]:
+        return {"error": "hmm_type must be either 'i6' or 'i3'"}
+    
+    if analysis_mode not in ["samples", "subclusters"]:
+        return {"error": "analysis_mode must be either 'samples' or 'subclusters'"}
+
+    os.makedirs(out_path, exist_ok=True)
+
+    # Prepare R vector for reference groups
+    if ref_group_names:
+        ref_groups_r = "c(" + ", ".join([f"'{g}'" for g in ref_group_names]) + ")"
+    else:
+        ref_groups_r = "NULL"
+
+    # Construct R script
+    r_script_content = f"""
+library(infercnv)
+
+# Create InferCNV Object
+infercnv_obj = CreateInfercnvObject(
+    raw_counts_matrix = "{raw_path.absolute()}",
+    gene_order_file = "{gene_path.absolute()}",
+    annotations_file = "{ann_path.absolute()}",
+    ref_group_names = {ref_groups_r}
+)
+
+# Run InferCNV Pipeline
+infercnv_obj = infercnv::run(
+    infercnv_obj,
+    cutoff = {cutoff},
+    min_cells_per_gene = {min_cells_per_gene},
+    out_dir = "{out_path.absolute()}",
+    cluster_by_groups = {str(cluster_by_groups).upper()},
+    denoise = {str(denoise).upper()},
+    HMM = {str(hmm).upper()},
+    HMM_type = "{hmm_type}",
+    analysis_mode = "{analysis_mode}",
+    num_threads = {num_threads},
+    plot_steps = {str(plot_steps).upper()},
+    no_plot = {str(no_plot).upper()},
+    window_length = {window_length},
+    max_centered_threshold = {max_centered_threshold},
+    leiden_resolution = {leiden_resolution}
+)
+"""
+
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+            tmp.write(r_script_content)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        # Cleanup temp file
+        os.unlink(tmp_path)
+
+        # Identify output files
+        output_files = [str(f) for f in out_path.glob("*") if f.is_file()]
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+            "status": "success"
+        }
+
+    except subprocess.CalledProcessError as e:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        return {
+            "command_executed": " ".join(e.cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "InferCNV execution failed."
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def infercnv_plot(
+    infercnv_obj_path: str,
+    out_dir: str,
+    output_filename: str = "infercnv_plot",
+    color_safe_pal: bool = False,
+    title: str = "InferCNV Heatmap",
+    cluster_by_groups: bool = True,
+    x_center: float = 1.0,
+    x_range: Optional[float] = None,
+    custom_color_pal: Optional[List[str]] = None,
+):
+    """
+    Generate or regenerate plots from a saved InferCNV object.
+    
+    Args:
+        infercnv_obj_path: Path to the saved .rds or .obj InferCNV object.
+        out_dir: Directory to save the plot.
+        output_filename: Name of the output plot file (without extension).
+        color_safe_pal: Use a color-blind safe palette.
+        title: Title of the plot.
+        cluster_by_groups: Whether to cluster by groups in the plot.
+        x_center: Value to center the color scale on (usually 1.0).
+        x_range: Range of values to display (e.g., 0.1 means 0.9 to 1.1).
+        custom_color_pal: Optional list of colors for the heatmap palette.
+    """
+    obj_path = Path(infercnv_obj_path)
+    out_path = Path(out_dir)
+
+    if not obj_path.exists():
+        return {"error": f"InferCNV object not found: {infercnv_obj_path}"}
+
+    os.makedirs(out_path, exist_ok=True)
+
+    x_range_r = f"{x_range}" if x_range is not None else "NULL"
+    color_pal_r = "NULL"
+    if custom_color_pal:
+        color_pal_r = "c(" + ", ".join([f"'{c}'" for c in custom_color_pal]) + ")"
+
+    r_script_content = f"""
+library(infercnv)
+infercnv_obj = readRDS("{obj_path.absolute()}")
+
+plot_cnv(
+    infercnv_obj,
+    out_dir = "{out_path.absolute()}",
+    output_filename = "{output_filename}",
+    color_safe_pal = {str(color_safe_pal).upper()},
+    title = "{title}",
+    cluster_by_groups = {str(cluster_by_groups).upper()},
+    x_center = {x_center},
+    x_range = {x_range_r},
+    custom_color_pal = {color_pal_r}
+)
+"""
+
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+            tmp.write(r_script_content)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        os.unlink(tmp_path)
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(f) for f in out_path.glob(f"{output_filename}*")],
+            "status": "success"
+        }
+
+    except subprocess.CalledProcessError as e:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        return {
+            "command_executed": " ".join(e.cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "InferCNV plotting failed."
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def infercnv_filter_genes(
+    raw_counts_matrix: str,
+    gene_order_file: str,
+    output_matrix_path: str,
+    min_cells_per_gene: int = 3,
+):
+    """
+    Pre-filter a counts matrix to remove genes expressed in fewer than a threshold number of cells.
+    
+    Args:
+        raw_counts_matrix: Path to the input counts matrix.
+        gene_order_file: Path to the gene order file.
+        output_matrix_path: Path to save the filtered matrix.
+        min_cells_per_gene: Minimum number of cells a gene must be expressed in.
+    """
+    raw_path = Path(raw_counts_matrix)
+    gene_path = Path(gene_order_file)
+    out_path = Path(output_matrix_path)
+
+    if not raw_path.exists():
+        return {"error": f"Input matrix not found: {raw_counts_matrix}"}
+
+    r_script_content = f"""
+library(infercnv)
+# Load data
+counts = read.table("{raw_path.absolute()}", header=TRUE, row.names=1, check.names=FALSE)
+# Filter
+gene_counts = rowSums(counts > 0)
+filtered_counts = counts[gene_counts >= {min_cells_per_gene}, ]
+# Save
+write.table(filtered_counts, file="{out_path.absolute()}", quote=FALSE, sep='\\t')
+"""
+
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+            tmp.write(r_script_content)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        os.unlink(tmp_path)
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_path)],
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        if os.path.exists(tmp_path):
+            os.unlink(tmp_path)
+        return {
+            "command_executed": " ".join(e.cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Filtering failed."
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

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

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

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

Biomni/mcp_generated/mcp_bioconductor-infercnv/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-org.hs.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.hs.eg.db via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-org.hs.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.hs.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.hs.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.hs.eg.db_server.py"]
+        

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

@@ -0,0 +1,195 @@
+import subprocess
+import json
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+def run_r_command(script: str) -> Dict[str, Any]:
+    """
+    Helper function to execute R code and capture output.
+    Uses jsonlite in R to return structured data.
+    """
+    # Wrap the script to load the library and output JSON
+    full_script = f"""
+    suppressPackageStartupMessages(library(org.hs.eg.db))
+    suppressPackageStartupMessages(library(jsonlite))
+    
+    tryCatch({{
+        {script}
+    }}, error = function(e) {{
+        write(paste("ERROR:", e$message), stderr())
+        q(status = 1)
+    }})
+    """
+    
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(full_script)
+        tmp_path = tmp.name
+
+    try:
+        process = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "command_executed": f"Rscript {tmp_path}"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": e.stderr or e.stdout,
+            "command_executed": f"Rscript {tmp_path}",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+    finally:
+        if Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_org_hs_eg_db'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def org_hs_eg_db_select(
+    keys: List[str],
+    columns: List[str],
+    keytype: str = "ENTREZID",
+) -> Dict[str, Any]:
+    """
+    Retrieve annotations for the specified keys from the Human (org.hs.eg.db) database.
+    
+    Args:
+        keys: A list of identifiers to look up (e.g., ["7157", "4312"] or ["TP53", "BRCA1"]).
+        columns: The types of data to retrieve (e.g., ["SYMBOL", "GENENAME", "ENSEMBL"]).
+        keytype: The type of the input keys (e.g., "ENTREZID", "SYMBOL", "ENSEMBL").
+    """
+    # Validation
+    if not keys:
+        return {"error": "At least one key must be provided."}
+    if not columns:
+        return {"error": "At least one column must be provided."}
+
+    # Format R vectors
+    r_keys = 'c("' + '","'.join(keys) + '")'
+    r_cols = 'c("' + '","'.join(columns) + '")'
+    
+    script = f"""
+    res <- select(org.hs.eg.db, keys = {r_keys}, columns = {r_cols}, keytype = "{keytype}")
+    cat(toJSON(res, pretty = TRUE))
+    """
+    
+    result = run_r_command(script)
+    return result
+
+@mcp.tool()
+def org_hs_eg_db_keytypes() -> Dict[str, Any]:
+    """
+    List all available types of identifiers (keytypes) that can be used as input for queries.
+    Common types include ENTREZID, SYMBOL, ENSEMBL, and UNIPROT.
+    """
+    script = """
+    res <- keytypes(org.hs.eg.db)
+    cat(toJSON(res))
+    """
+    return run_r_command(script)
+
+@mcp.tool()
+def org_hs_eg_db_columns() -> Dict[str, Any]:
+    """
+    List all available annotation columns that can be retrieved from the database.
+    """
+    script = """
+    res <- columns(org.hs.eg.db)
+    cat(toJSON(res))
+    """
+    return run_r_command(script)
+
+@mcp.tool()
+def org_hs_eg_db_map_symbol_to_entrez(
+    symbols: List[str]
+) -> Dict[str, Any]:
+    """
+    A convenience tool to quickly map Human Gene Symbols to Entrez IDs.
+    
+    Args:
+        symbols: List of gene symbols (e.g., ["TP53", "APOE"]).
+    """
+    if not symbols:
+        return {"error": "No symbols provided."}
+        
+    r_keys = 'c("' + '","'.join(symbols) + '")'
+    script = f"""
+    res <- select(org.hs.eg.db, keys = {r_keys}, columns = c("ENTREZID"), keytype = "SYMBOL")
+    cat(toJSON(res, pretty = TRUE))
+    """
+    return run_r_command(script)
+
+@mcp.tool()
+def org_hs_eg_db_get_keys(
+    keytype: str = "SYMBOL",
+    pattern: str = "",
+    limit: int = 100
+) -> Dict[str, Any]:
+    """
+    Retrieve a list of all valid keys of a specific type, optionally filtered by a pattern.
+    
+    Args:
+        keytype: The type of keys to retrieve (e.g., "SYMBOL", "ENSEMBL").
+        pattern: A string pattern to filter keys (uses grep-style matching).
+        limit: Maximum number of keys to return to prevent overwhelming output.
+    """
+    if limit <= 0:
+        limit = 100
+
+    script = f"""
+    all_keys <- keys(org.hs.eg.db, keytype = "{keytype}")
+    if ("{pattern}" != "") {{
+        all_keys <- all_keys[grep("{pattern}", all_keys)]
+    }}
+    res <- head(all_keys, {limit})
+    cat(toJSON(res))
+    """
+    return run_r_command(script)
+
+@mcp.tool()
+def org_hs_eg_db_metadata() -> Dict[str, Any]:
+    """
+    Get metadata about the org.hs.eg.db package, including version, organism, and data sources.
+    """
+    script = """
+    res <- metadata(org.hs.eg.db)
+    cat(toJSON(res, pretty = TRUE))
+    """
+    return run_r_command(script)
+
+@mcp.tool()
+def org_hs_eg_db_map_ids(
+    ids: List[str],
+    from_type: str,
+    to_type: str
+) -> Dict[str, Any]:
+    """
+    Generic tool to map identifiers from one type to another.
+    
+    Args:
+        ids: List of input identifiers.
+        from_type: The source identifier type (e.g., "ENSEMBL").
+        to_type: The target identifier type (e.g., "SYMBOL").
+    """
+    if not ids:
+        return {"error": "No IDs provided."}
+
+    r_keys = 'c("' + '","'.join(ids) + '")'
+    script = f"""
+    res <- select(org.hs.eg.db, keys = {r_keys}, columns = c("{to_type}"), keytype = "{from_type}")
+    cat(toJSON(res, pretty = TRUE))
+    """
+    return run_r_command(script)
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-org.hs.eg.db/app/bioconductor-org.hs.eg.db_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-org.hs.eg.db/app/bioconductor-org.hs.eg.db_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_org_hs_eg_db'
+
+
+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.hs.eg.db/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

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

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

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

Biomni/mcp_generated/mcp_bioconductor-preprocesscore/app/bioconductor-preprocesscore_server.py

@@ -0,0 +1,340 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List
+import tempfile
+
+def run_r_command(script_content: str):
+    """Helper to execute R code and handle errors."""
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write("library(preprocessCore)\n")
+        tmp.write(script_content)
+        tmp_path = tmp.name
+
+    try:
+        result = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout, result.stderr
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"R execution failed: {e.stderr}\nStdout: {e.stdout}")
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_preprocesscore'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def preprocesscore_normalize_quantiles(
+    input_file: str,
+    output_file: str,
+    keep_names: bool = True,
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Perform Quantile Normalization on a numeric matrix.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file containing the matrix.
+        output_file: Path where the normalized matrix will be saved.
+        keep_names: Whether to preserve row and column names in the output.
+        sep: Delimiter used in the input file (e.g., ',' or '\t').
+        header: Whether the input file has a header row.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    normalized_data <- normalize.quantiles(data, keep.names={str(keep_names).upper()})
+    write.table(normalized_data, "{output_path}", sep="{sep}", col.names={str(header).upper()}, row.names=TRUE, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "normalize.quantiles",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def preprocesscore_normalize_quantiles_robust(
+    input_file: str,
+    output_file: str,
+    remove_extreme: str = "both",
+    n_remove: int = 1,
+    use_log2: bool = False,
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Perform Robust Quantile Normalization.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file.
+        output_file: Path for the output file.
+        remove_extreme: How to remove outliers: 'none', 'left', 'right', or 'both'.
+        n_remove: Number of extreme values to remove.
+        use_log2: Whether to apply log2 transformation before normalization.
+        sep: Delimiter used in the input file.
+        header: Whether the input file has a header row.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+    
+    if remove_extreme not in ["none", "left", "right", "both"]:
+        return {"error": "remove_extreme must be one of: none, left, right, both"}
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    normalized_data <- normalize.quantiles.robust(
+        data, 
+        remove.extreme="{remove_extreme}", 
+        n.remove={n_remove}, 
+        use.log2={str(use_log2).upper()}
+    )
+    write.table(normalized_data, "{output_path}", sep="{sep}", col.names={str(header).upper()}, row.names=TRUE, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "normalize.quantiles.robust",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def preprocesscore_background_correct(
+    input_file: str,
+    output_file: str,
+    method: str = "rma",
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Perform background correction on a matrix of intensities.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file.
+        output_file: Path for the output file.
+        method: Correction method (typically 'rma').
+        sep: Delimiter used in the input file.
+        header: Whether the input file has a header row.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    corrected_data <- background.correct(data, method="{method}")
+    write.table(corrected_data, "{output_path}", sep="{sep}", col.names={str(header).upper()}, row.names=TRUE, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": f"background.correct(method='{method}')",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def preprocesscore_sub_col_summarize_median_polish(
+    input_file: str,
+    output_file: str,
+    group_labels: List[int],
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Summarize columns of a matrix using Median Polish based on group labels.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file.
+        output_file: Path for the output file.
+        group_labels: A list of integers representing the group for each column (e.g., [1, 1, 2, 2]).
+        sep: Delimiter used in the input file.
+        header: Whether the input file has a header row.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+
+    # Convert Python list to R vector string
+    r_groups = f"c({','.join(map(str, group_labels))})"
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    groups <- as.integer({r_groups})
+    summarized <- subColSummarizeMedianPolish(data, groups)
+    write.table(summarized, "{output_path}", sep="{sep}", col.names=NA, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "subColSummarizeMedianPolish",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def preprocesscore_sub_col_summarize_log_avg(
+    input_file: str,
+    output_file: str,
+    group_labels: List[int],
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Summarize columns of a matrix using Log-Average based on group labels.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file.
+        output_file: Path for the output file.
+        group_labels: A list of integers representing the group for each column.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+
+    r_groups = f"c({','.join(map(str, group_labels))})"
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    groups <- as.integer({r_groups})
+    summarized <- subColSummarizeLogAvg(data, groups)
+    write.table(summarized, "{output_path}", sep="{sep}", col.names=NA, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "subColSummarizeLogAvg",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def preprocesscore_sub_col_summarize_log_median(
+    input_file: str,
+    output_file: str,
+    group_labels: List[int],
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Summarize columns of a matrix using Log-Median based on group labels.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file.
+        output_file: Path for the output file.
+        group_labels: A list of integers representing the group for each column.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+
+    r_groups = f"c({','.join(map(str, group_labels))})"
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    groups <- as.integer({r_groups})
+    summarized <- subColSummarizeLogMedian(data, groups)
+    write.table(summarized, "{output_path}", sep="{sep}", col.names=NA, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "subColSummarizeLogMedian",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def preprocesscore_sub_col_summarize_biweight_midavg(
+    input_file: str,
+    output_file: str,
+    group_labels: List[int],
+    sep: str = ",",
+    header: bool = True
+):
+    """
+    Summarize columns of a matrix using Biweight Mid-average based on group labels.
+    
+    Args:
+        input_file: Path to the input CSV/TSV file.
+        output_file: Path for the output file.
+        group_labels: A list of integers representing the group for each column.
+    """
+    input_path = Path(input_file)
+    output_path = Path(output_file)
+    
+    if not input_path.exists():
+        return {"error": f"Input file {input_file} not found."}
+
+    r_groups = f"c({','.join(map(str, group_labels))})"
+
+    r_script = f"""
+    data <- as.matrix(read.table("{input_path}", header={str(header).upper()}, sep="{sep}"))
+    groups <- as.integer({r_groups})
+    summarized <- subColSummarizeBiweightMidavg(data, groups)
+    write.table(summarized, "{output_path}", sep="{sep}", col.names=NA, quote=FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "subColSummarizeBiweightMidavg",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-preprocesscore/app/bioconductor-preprocesscore_shim_server.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-preprocesscore/app/bioconductor-preprocesscore_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_preprocesscore'
+
+
+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-preprocesscore/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-preprocesscore/requirements.txt

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