Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_bcbio-nextgen/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 bcbio-nextgen via conda (e.g., from bioconda)
+RUN conda install -c bioconda bcbio-nextgen -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/bcbio-nextgen_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/bcbio-nextgen_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/bcbio-nextgen_server.py"]
+        

Biomni/mcp_generated/mcp_bcbio-nextgen/app/bcbio-nextgen_server.py

@@ -0,0 +1,276 @@
+from typing import List, Optional, Dict, Any
+import subprocess
+from pathlib import Path
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bcbio_nextgen'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bcbio_nextgen_run(
+    config_file: str,
+    num_cores: int = 1,
+    parallel_type: str = "local",
+    scheduler: Optional[str] = None,
+    queue: Optional[str] = None,
+    resources: Optional[str] = None,
+    tag: Optional[str] = None,
+    workdir: Optional[str] = None,
+    timeout: int = 15,
+    retries: int = 0,
+) -> Dict[str, Any]:
+    """
+    Run a bcbio-nextgen analysis pipeline using a provided configuration file.
+
+    Args:
+        config_file: Path to the YAML configuration file defining the analysis.
+        num_cores: Number of local cores to use for parallel execution.
+        parallel_type: Type of parallel execution (local, ipython, cluster, etc.).
+        scheduler: Scheduler for cluster execution (e.g., sge, slurm, torque, pbspro, lsf).
+        queue: Queue to submit jobs to on a cluster.
+        resources: Specific resource requirements for the scheduler (e.g., 'mem=16,vmem=20').
+        tag: Optional tag to identify this specific run.
+        workdir: Directory to use for processing (defaults to current directory).
+        timeout: Time in minutes to wait for ipython cluster startup.
+        retries: Number of times to retry failed steps.
+    """
+    config_path = Path(config_file)
+    if not config_path.exists():
+        return {"error": f"Configuration file not found: {config_file}"}
+
+    cmd = ["bcbio_nextgen.py", str(config_path.absolute())]
+    
+    cmd.extend(["-n", str(num_cores)])
+    cmd.extend(["-t", parallel_type])
+    
+    if scheduler:
+        cmd.extend(["-s", scheduler])
+    if queue:
+        cmd.extend(["-q", queue])
+    if resources:
+        cmd.extend(["-r", resources])
+    if tag:
+        cmd.extend(["--tag", tag])
+    if timeout != 15:
+        cmd.extend(["--timeout", str(timeout)])
+    if retries > 0:
+        cmd.extend(["--retries", str(retries)])
+
+    # Handle working directory
+    original_dir = os.getcwd()
+    if workdir:
+        work_path = Path(workdir)
+        if not work_path.exists():
+            work_path.mkdir(parents=True, exist_ok=True)
+        os.chdir(work_path)
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+    finally:
+        os.chdir(original_dir)
+
+@mcp.tool()
+def bcbio_nextgen_template(
+    template_name: str,
+    metadata_csv: str,
+    input_files: List[str],
+    out_dir: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Create a bcbio-nextgen processing description from a template and input files.
+
+    Args:
+        template_name: Name of the template to use (e.g., 'freebayes-variant', 'gatk-variant').
+        metadata_csv: Path to a CSV file containing sample metadata.
+        input_files: List of paths to input BAM or FASTQ files.
+        out_dir: Directory to write the generated configuration (defaults to current directory).
+    """
+    metadata_path = Path(metadata_csv)
+    if not metadata_path.exists():
+        return {"error": f"Metadata file not found: {metadata_csv}"}
+
+    # Validate input files
+    valid_inputs = []
+    for f in input_files:
+        p = Path(f)
+        if p.exists():
+            valid_inputs.append(str(p.absolute()))
+        else:
+            return {"error": f"Input file not found: {f}"}
+
+    cmd = ["bcbio_nextgen.py", "-w", "template", template_name, str(metadata_path.absolute())]
+    cmd.extend(valid_inputs)
+
+    # Handle output directory
+    original_dir = os.getcwd()
+    if out_dir:
+        out_path = Path(out_dir)
+        if not out_path.exists():
+            out_path.mkdir(parents=True, exist_ok=True)
+        os.chdir(out_path)
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success",
+            "info": "Configuration files generated in the output directory."
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+    finally:
+        os.chdir(original_dir)
+
+@mcp.tool()
+def bcbio_nextgen_upgrade(
+    tooldir: Optional[str] = None,
+    tools: bool = False,
+    data: bool = False,
+    genomes: Optional[List[str]] = None,
+    aligners: Optional[List[str]] = None,
+    cores: int = 1,
+) -> Dict[str, Any]:
+    """
+    Upgrade bcbio-nextgen software, third-party tools, or genome data.
+
+    Args:
+        tooldir: Directory where tools are installed.
+        tools: If True, upgrade third-party software tools.
+        data: If True, upgrade/install genome data.
+        genomes: List of genome builds to install/upgrade (e.g., ['hg38', 'mm10']).
+        aligners: List of aligners to install data for (e.g., ['bwa', 'bowtie2']).
+        cores: Number of cores to use for data downloads and indexing.
+    """
+    cmd = ["bcbio_nextgen.py", "upgrade"]
+    
+    if tooldir:
+        cmd.extend(["--tooldir", tooldir])
+    if tools:
+        cmd.append("--tools")
+    if data:
+        cmd.append("--data")
+    
+    if genomes:
+        for g in genomes:
+            cmd.extend(["--genomes", g])
+    
+    if aligners:
+        for a in aligners:
+            cmd.extend(["--aligners", a])
+            
+    cmd.extend(["--cores", str(cores)])
+
+    try:
+        # Upgrades can take a long time, but we capture output
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+
+@mcp.tool()
+def bcbio_nextgen_install(
+    install_path: str,
+    tooldir: str,
+    genomes: List[str],
+    aligners: List[str],
+    nodata: bool = False,
+    isolate: bool = False,
+) -> Dict[str, Any]:
+    """
+    Run the bcbio-nextgen installer script to set up the environment.
+
+    Args:
+        install_path: Path to install bcbio-nextgen data and code.
+        tooldir: Path to install third-party software tools.
+        genomes: List of genome builds to install (e.g., ['hg38']).
+        aligners: List of aligners to prepare (e.g., ['bwa']).
+        nodata: If True, do not install genome data.
+        isolate: If True, install into an isolated environment.
+    """
+    # Note: This assumes bcbio_nextgen_install.py is in the PATH or current directory
+    # In a real environment, users might need to download it first.
+    cmd = ["python", "bcbio_nextgen_install.py", install_path, "--tooldir=" + tooldir]
+    
+    for g in genomes:
+        cmd.extend(["--genomes", g])
+    for a in aligners:
+        cmd.extend(["--aligners", a])
+    
+    if nodata:
+        cmd.append("--nodata")
+    if isolate:
+        cmd.append("--isolate")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+
+@mcp.tool()
+def bcbio_nextgen_version() -> Dict[str, Any]:
+    """
+    Check the installed version of bcbio-nextgen.
+    """
+    cmd = ["bcbio_nextgen.py", "--version"]
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout.strip(),
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": str(e),
+            "status": "failed"
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bcbio-nextgen/app/bcbio-nextgen_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_bcbio-nextgen/app/bcbio-nextgen_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bcbio_nextgen'
+
+
+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_bcbio-nextgen/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bcbio-nextgen/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-banksy/app/bioconductor-banksy_server.py

@@ -0,0 +1,667 @@
+import subprocess
+import tempfile
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# Note: The @mcp.tool() decorator is assumed to be available in the environment
+# where this code will be run, as per the instructions "NO NEED to import mcp".
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_banksy'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def banksy_init_object(
+    input_seurat_rdata_path: Path,
+    output_banksy_rdata_path: Path,
+    assay: str = "Spatial",
+    verbose: bool = True,
+) -> Dict[str, Any]:
+    """
+    Initializes a BanksyObject from an existing Seurat object.
+
+    This tool takes an RData file containing a Seurat object, converts it
+    into a BanksyObject, and saves the new BanksyObject to an RData file.
+    This is often the first step before running the BANKSY algorithm.
+
+    Requires R and the 'banksy' and 'Seurat' R packages to be installed
+    and accessible in the environment.
+
+    Args:
+        input_seurat_rdata_path: Path to the input .RData file containing a Seurat object.
+        output_banksy_rdata_path: Path where the new BanksyObject will be saved as an .RData file.
+        assay: Name of the assay in the Seurat object to use for spatial data.
+        verbose: If TRUE, print messages during execution.
+
+    Returns:
+        A dictionary containing execution details:
+        - command_executed: The Rscript command and generated R script path.
+        - stdout: Standard output from the Rscript execution.
+        - stderr: Standard error from the Rscript execution.
+        - output_files: A list of paths to generated output files.
+    """
+    # 1. Input validation
+    if not input_seurat_rdata_path.exists():
+        raise FileNotFoundError(f"Input Seurat RData file not found: {input_seurat_rdata_path}")
+    if not input_seurat_rdata_path.is_file():
+        raise ValueError(f"Input Seurat RData path is not a file: {input_seurat_rdata_path}")
+    if output_banksy_rdata_path.suffix.lower() != ".rdata":
+        raise ValueError(f"Output RData file must have a .RData extension: {output_banksy_rdata_path}")
+    if not assay:
+        raise ValueError("Assay name cannot be empty.")
+
+    # Ensure output directory exists
+    output_banksy_rdata_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. Generate R script content
+    r_script_content = f"""
+    # Load required packages
+    library(Seurat)
+    library(banksy)
+
+    # Define input and output paths
+    input_obj_path <- "{input_seurat_rdata_path.as_posix()}"
+    output_obj_path <- "{output_banksy_rdata_path.as_posix()}"
+
+    # Check if input file exists
+    if (!file.exists(input_obj_path)) {{
+        stop(paste("Input RData file not found:", input_obj_path))
+    }}
+
+    # Load the object from RData. This approach handles cases where the object
+    # name inside the RData file is not known beforehand.
+    loaded_env <- new.env()
+    load(input_obj_path, envir = loaded_env)
+    
+    seurat_obj <- NULL
+    for (var_name in ls(loaded_env)) {{
+        candidate <- get(var_name, envir = loaded_env)
+        if (inherits(candidate, "Seurat")) {{
+            seurat_obj <- candidate
+            break
+        }}
+    }}
+
+    if (is.null(seurat_obj)) {{
+        stop("No Seurat object found in the input RData file.")
+    }}
+
+    message("Initializing BanksyObject from Seurat object with parameters:")
+    message(paste("  assay:", "{assay}"))
+    message(paste("  verbose:", {str(verbose).upper()}))
+
+    # Create BanksyObject
+    banksy_obj <- BanksyObject(
+        seurat_obj,
+        assay = "{assay}",
+        verbose = {str(verbose).upper()}
+    )
+
+    # Save the new BanksyObject. Renaming to 'obj' for consistency with other banksy tools.
+    obj <- banksy_obj
+    save(obj, file = output_obj_path)
+
+    message(paste("BanksyObject saved to:", output_obj_path))
+    """
+
+    temp_r_script_path: Optional[Path] = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".R") as temp_r_script:
+            temp_r_script.write(r_script_content)
+            temp_r_script_path = Path(temp_r_script.name)
+
+        command = ["Rscript", str(temp_r_script_path)]
+        
+        # 3. Subprocess execution
+        process = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=os.environ # Pass current environment to Rscript
+        )
+
+        stdout = process.stdout
+        stderr = process.stderr
+
+        # 4. Error handling: Check for R-specific errors in stderr
+        if "Error" in stderr or "stop(" in stderr:
+            raise RuntimeError(f"R script execution failed. Stderr: {stderr}")
+
+        if not output_banksy_rdata_path.exists():
+            raise RuntimeError(f"Output file was not created by R script: {output_banksy_rdata_path}")
+
+        return {
+            "command_executed": " ".join(command),
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_banksy_rdata_path)],
+        }
+
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Is R installed and in your PATH?")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with exit code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+    finally:
+        # Clean up temporary R script
+        if temp_r_script_path and temp_r_script_path.exists():
+            os.remove(temp_r_script_path)
+
+
+@mcp.tool()
+def banksy_run_banksy(
+    input_rdata_path: Path,
+    output_rdata_path: Path,
+    k_neighbours: int = 10,
+    lambda_param: float = 0.1, # Renamed from 'lambda' to avoid Python keyword conflict
+    resolution: float = 0.8,
+    n_components: int = 2,
+    n_cores: int = 1,
+    verbose: bool = True,
+    seed: int = 123,
+) -> Dict[str, Any]:
+    """
+    Runs the core BANKSY algorithm on a Seurat or BanksyObject.
+
+    This tool takes an RData file containing a Seurat or BanksyObject,
+    applies the BANKSY algorithm for spatial transcriptomics analysis,
+    and saves the updated object to a new RData file.
+
+    Requires R and the 'banksy', 'Seurat', and 'future' R packages to be installed
+    and accessible in the environment.
+
+    Args:
+        input_rdata_path: Path to the input .RData file containing a Seurat or BanksyObject.
+        output_rdata_path: Path where the updated Seurat/BanksyObject will be saved as an .RData file.
+        k_neighbours: Number of neighbours for spatial graph construction.
+        lambda_param: Weight of spatial information (lambda parameter).
+        resolution: Resolution parameter for clustering.
+        n_components: Number of components for dimensionality reduction (e.g., UMAP/tSNE).
+        n_cores: Number of cores to use for parallel processing.
+        verbose: If TRUE, print messages during execution.
+        seed: Random seed for reproducibility.
+
+    Returns:
+        A dictionary containing execution details:
+        - command_executed: The Rscript command and generated R script path.
+        - stdout: Standard output from the Rscript execution.
+        - stderr: Standard error from the Rscript execution.
+        - output_files: A list of paths to generated output files.
+    """
+    # 1. Input validation
+    if not input_rdata_path.exists():
+        raise FileNotFoundError(f"Input RData file not found: {input_rdata_path}")
+    if not input_rdata_path.is_file():
+        raise ValueError(f"Input RData path is not a file: {input_rdata_path}")
+    if output_rdata_path.suffix.lower() != ".rdata":
+        raise ValueError(f"Output RData file must have a .RData extension: {output_rdata_path}")
+    if k_neighbours <= 0:
+        raise ValueError("k_neighbours must be a positive integer.")
+    if not (0 <= lambda_param <= 1):
+        raise ValueError("lambda_param must be between 0 and 1.")
+    if resolution <= 0:
+        raise ValueError("resolution must be a positive float.")
+    if n_components <= 0:
+        raise ValueError("n_components must be a positive integer.")
+    if n_cores <= 0:
+        raise ValueError("n_cores must be a positive integer.")
+
+    # Ensure output directory exists
+    output_rdata_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. Generate R script content
+    r_script_content = f"""
+    # Load required packages
+    library(Seurat)
+    library(banksy)
+    library(future) # For parallel processing
+
+    # Set up parallel processing if n_cores > 1
+    if ({n_cores} > 1) {{
+        plan("multisession", workers = {n_cores})
+    }} else {{
+        plan("sequential")
+    }}
+
+    # Set random seed for reproducibility
+    set.seed({seed})
+
+    # Define input and output paths
+    input_obj_path <- "{input_rdata_path.as_posix()}"
+    output_obj_path <- "{output_rdata_path.as_posix()}"
+
+    # Check if input file exists
+    if (!file.exists(input_obj_path)) {{
+        stop(paste("Input RData file not found:", input_obj_path))
+    }}
+
+    # Load the object
+    loaded_env <- new.env()
+    load(input_obj_path, envir = loaded_env)
+    
+    obj <- NULL
+    for (var_name in ls(loaded_env)) {{
+        candidate <- get(var_name, envir = loaded_env)
+        if (inherits(candidate, "Seurat") || inherits(candidate, "BanksyObject")) {{
+            obj <- candidate
+            break
+        }}
+    }}
+
+    if (is.null(obj)) {{
+        stop("No Seurat or BanksyObject found in the input RData file.")
+    }}
+
+    message("Running banksy with parameters:")
+    message(paste("  k_neighbours:", {k_neighbours}))
+    message(paste("  lambda:", {lambda_param}))
+    message(paste("  resolution:", {resolution}))
+    message(paste("  n_components:", {n_components}))
+    message(paste("  n_cores:", {n_cores}))
+    message(paste("  verbose:", {str(verbose).upper()}))
+    message(paste("  seed:", {seed}))
+
+    # Run BANKSY
+    obj <- runBanksy(
+        object = obj,
+        k_neighbours = {k_neighbours},
+        lambda = {lambda_param},
+        resolution = {resolution},
+        n_components = {n_components},
+        verbose = {str(verbose).upper()}
+    )
+
+    # Save the updated object
+    save(obj, file = output_obj_path)
+
+    message(paste("Updated object saved to:", output_obj_path))
+    """
+
+    temp_r_script_path: Optional[Path] = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".R") as temp_r_script:
+            temp_r_script.write(r_script_content)
+            temp_r_script_path = Path(temp_r_script.name)
+
+        command = ["Rscript", str(temp_r_script_path)]
+        
+        # 3. Subprocess execution
+        process = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=os.environ
+        )
+
+        stdout = process.stdout
+        stderr = process.stderr
+
+        # 4. Error handling: Check for R-specific errors in stderr
+        if "Error" in stderr or "stop(" in stderr:
+            raise RuntimeError(f"R script execution failed. Stderr: {stderr}")
+
+        if not output_rdata_path.exists():
+            raise RuntimeError(f"Output file was not created by R script: {output_rdata_path}")
+
+        return {
+            "command_executed": " ".join(command),
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_rdata_path)],
+        }
+
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Is R installed and in your PATH?")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with exit code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+    finally:
+        # Clean up temporary R script
+        if temp_r_script_path and temp_r_script_path.exists():
+            os.remove(temp_r_script_path)
+
+
+@mcp.tool()
+def banksy_cluster_banksy(
+    input_rdata_path: Path,
+    output_rdata_path: Path,
+    resolution: float = 0.8,
+    method: str = "leiden",
+    verbose: bool = True,
+    seed: int = 123,
+) -> Dict[str, Any]:
+    """
+    Performs clustering on a BanksyObject or Seurat object after BANKSY analysis.
+
+    This tool takes an RData file containing a Seurat or BanksyObject (typically
+    after `runBanksy`), performs clustering using the specified method and resolution,
+    and saves the updated object to a new RData file.
+
+    Requires R and the 'banksy' and 'Seurat' R packages to be installed
+    and accessible in the environment.
+
+    Args:
+        input_rdata_path: Path to the input .RData file containing a Seurat or BanksyObject.
+        output_rdata_path: Path where the updated Seurat/BanksyObject will be saved as an .RData file.
+        resolution: Resolution parameter for clustering.
+        method: Clustering method to use (e.g., "leiden", "louvain").
+        verbose: If TRUE, print messages during execution.
+        seed: Random seed for reproducibility.
+
+    Returns:
+        A dictionary containing execution details:
+        - command_executed: The Rscript command and generated R script path.
+        - stdout: Standard output from the Rscript execution.
+        - stderr: Standard error from the Rscript execution.
+        - output_files: A list of paths to generated output files.
+    """
+    # 1. Input validation
+    if not input_rdata_path.exists():
+        raise FileNotFoundError(f"Input RData file not found: {input_rdata_path}")
+    if not input_rdata_path.is_file():
+        raise ValueError(f"Input RData path is not a file: {input_rdata_path}")
+    if output_rdata_path.suffix.lower() != ".rdata":
+        raise ValueError(f"Output RData file must have a .RData extension: {output_rdata_path}")
+    if resolution <= 0:
+        raise ValueError("resolution must be a positive float.")
+    if method not in ["leiden", "louvain"]:
+        raise ValueError(f"Unsupported clustering method: {method}. Choose from 'leiden', 'louvain'.")
+
+    # Ensure output directory exists
+    output_rdata_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. Generate R script content
+    r_script_content = f"""
+    # Load required packages
+    library(Seurat)
+    library(banksy)
+
+    # Set random seed for reproducibility
+    set.seed({seed})
+
+    # Define input and output paths
+    input_obj_path <- "{input_rdata_path.as_posix()}"
+    output_obj_path <- "{output_rdata_path.as_posix()}"
+
+    # Check if input file exists
+    if (!file.exists(input_obj_path)) {{
+        stop(paste("Input RData file not found:", input_obj_path))
+    }}
+
+    # Load the object
+    loaded_env <- new.env()
+    load(input_obj_path, envir = loaded_env)
+    
+    obj <- NULL
+    for (var_name in ls(loaded_env)) {{
+        candidate <- get(var_name, envir = loaded_env)
+        if (inherits(candidate, "Seurat") || inherits(candidate, "BanksyObject")) {{
+            obj <- candidate
+            break
+        }}
+    }}
+
+    if (is.null(obj)) {{
+        stop("No Seurat or BanksyObject found in the input RData file.")
+    }}
+
+    message("Clustering banksy object with parameters:")
+    message(paste("  resolution:", {resolution}))
+    message(paste("  method:", "{method}"))
+    message(paste("  verbose:", {str(verbose).upper()}))
+    message(paste("  seed:", {seed}))
+
+    # Cluster BANKSY object
+    obj <- clusterBanksy(
+        object = obj,
+        resolution = {resolution},
+        method = "{method}",
+        verbose = {str(verbose).upper()}
+    )
+
+    # Save the updated object
+    save(obj, file = output_obj_path)
+
+    message(paste("Updated object saved to:", output_obj_path))
+    """
+
+    temp_r_script_path: Optional[Path] = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".R") as temp_r_script:
+            temp_r_script.write(r_script_content)
+            temp_r_script_path = Path(temp_r_script.name)
+
+        command = ["Rscript", str(temp_r_script_path)]
+        
+        # 3. Subprocess execution
+        process = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=os.environ
+        )
+
+        stdout = process.stdout
+        stderr = process.stderr
+
+        # 4. Error handling: Check for R-specific errors in stderr
+        if "Error" in stderr or "stop(" in stderr:
+            raise RuntimeError(f"R script execution failed. Stderr: {stderr}")
+
+        if not output_rdata_path.exists():
+            raise RuntimeError(f"Output file was not created by R script: {output_rdata_path}")
+
+        return {
+            "command_executed": " ".join(command),
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_rdata_path)],
+        }
+
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Is R installed and in your PATH?")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with exit code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+    finally:
+        # Clean up temporary R script
+        if temp_r_script_path and temp_r_script_path.exists():
+            os.remove(temp_r_script_path)
+
+
+@mcp.tool()
+def banksy_spatial_dim_plot(
+    input_rdata_path: Path,
+    output_plot_path: Path,
+    reduction: str = "banksy",
+    group_by: str = "banksy_clusters",
+    label: bool = True,
+    pt_size: float = 1.5,
+    verbose: bool = True,
+    width: float = 7.0,
+    height: float = 7.0,
+    units: str = "in",
+    dpi: int = 300,
+) -> Dict[str, Any]:
+    """
+    Generates a spatial dimensionality plot for a BanksyObject.
+
+    This tool takes an RData file containing a BanksyObject (typically after
+    `runBanksy` and `clusterBanksy`), generates a spatial plot, and saves it
+    to an image file (e.g., PNG, PDF).
+
+    Requires R and the 'banksy', 'Seurat', and 'ggplot2' R packages to be installed
+    and accessible in the environment.
+
+    Args:
+        input_rdata_path: Path to the input .RData file containing a BanksyObject.
+        output_plot_path: Path where the plot will be saved (e.g., .png, .pdf, .jpeg).
+        reduction: Dimensionality reduction to use for plotting (e.g., "banksy", "umap").
+        group_by: Feature to group cells by for coloring (e.g., "banksy_clusters").
+        label: If TRUE, label clusters on the plot.
+        pt_size: Size of the points in the plot.
+        verbose: If TRUE, print messages during execution.
+        width: Width of the output plot.
+        height: Height of the output plot.
+        units: Units for width and height ("in", "cm", "mm").
+        dpi: Resolution for raster plots (e.g., PNG, JPEG).
+
+    Returns:
+        A dictionary containing execution details:
+        - command_executed: The Rscript command and generated R script path.
+        - stdout: Standard output from the Rscript execution.
+        - stderr: Standard error from the Rscript execution.
+        - output_files: A list of paths to generated output files.
+    """
+    # 1. Input validation
+    if not input_rdata_path.exists():
+        raise FileNotFoundError(f"Input RData file not found: {input_rdata_path}")
+    if not input_rdata_path.is_file():
+        raise ValueError(f"Input RData path is not a file: {input_rdata_path}")
+    
+    valid_plot_suffixes = [".png", ".pdf", ".jpeg", ".jpg", ".tiff", ".bmp"]
+    if output_plot_path.suffix.lower() not in valid_plot_suffixes:
+        raise ValueError(f"Output plot file must have one of the following extensions: {', '.join(valid_plot_suffixes)}")
+    
+    if pt_size <= 0:
+        raise ValueError("pt_size must be a positive float.")
+    if width <= 0 or height <= 0:
+        raise ValueError("Width and height must be positive floats.")
+    if units not in ["in", "cm", "mm"]:
+        raise ValueError(f"Invalid units: {units}. Choose from 'in', 'cm', 'mm'.")
+    if dpi <= 0:
+        raise ValueError("DPI must be a positive integer.")
+
+    # Ensure output directory exists
+    output_plot_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. Generate R script content
+    r_script_content = f"""
+    # Load required packages
+    library(Seurat)
+    library(banksy)
+    library(ggplot2) # For saving plots
+
+    # Define input and output paths
+    input_obj_path <- "{input_rdata_path.as_posix()}"
+    output_plot_path <- "{output_plot_path.as_posix()}"
+
+    # Check if input file exists
+    if (!file.exists(input_obj_path)) {{
+        stop(paste("Input RData file not found:", input_obj_path))
+    }}
+
+    # Load the object
+    loaded_env <- new.env()
+    load(input_obj_path, envir = loaded_env)
+    
+    obj <- NULL
+    for (var_name in ls(loaded_env)) {{
+        candidate <- get(var_name, envir = loaded_env)
+        if (inherits(candidate, "Seurat") || inherits(candidate, "BanksyObject")) {{
+            obj <- candidate
+            break
+        }}
+    }}
+
+    if (is.null(obj)) {{
+        stop("No Seurat or BanksyObject found in the input RData file.")
+    }}
+
+    message("Generating spatial dimensionality plot with parameters:")
+    message(paste("  reduction:", "{reduction}"))
+    message(paste("  group_by:", "{group_by}"))
+    message(paste("  label:", {str(label).upper()}))
+    message(paste("  pt_size:", {pt_size}))
+    message(paste("  verbose:", {str(verbose).upper()}))
+
+    # Generate plot
+    p <- spatialDimPlot(
+        object = obj,
+        reduction = "{reduction}",
+        group.by = "{group_by}",
+        label = {str(label).upper()},
+        pt.size.factor = {pt_size}, # Note: R parameter is pt.size.factor
+        verbose = {str(verbose).upper()}
+    )
+
+    # Save the plot
+    ggsave(
+        filename = output_plot_path,
+        plot = p,
+        width = {width},
+        height = {height},
+        units = "{units}",
+        dpi = {dpi}
+    )
+
+    message(paste("Plot saved to:", output_plot_path))
+    """
+
+    temp_r_script_path: Optional[Path] = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".R") as temp_r_script:
+            temp_r_script.write(r_script_content)
+            temp_r_script_path = Path(temp_r_script.name)
+
+        command = ["Rscript", str(temp_r_script_path)]
+        
+        # 3. Subprocess execution
+        process = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=os.environ
+        )
+
+        stdout = process.stdout
+        stderr = process.stderr
+
+        # 4. Error handling: Check for R-specific errors in stderr
+        if "Error" in stderr or "stop(" in stderr:
+            raise RuntimeError(f"R script execution failed. Stderr: {stderr}")
+
+        if not output_plot_path.exists():
+            raise RuntimeError(f"Output plot file was not created by R script: {output_plot_path}")
+
+        return {
+            "command_executed": " ".join(command),
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_plot_path)],
+        }
+
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Is R installed and in your PATH?")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with exit code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+    finally:
+        # Clean up temporary R script
+        if temp_r_script_path and temp_r_script_path.exists():
+            os.remove(temp_r_script_path)
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-banksy/app/bioconductor-banksy_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-banksy/app/bioconductor-banksy_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_banksy'
+
+
+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-banksy/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-banksy/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-benchdamic/app/bioconductor-benchdamic_server.py

@@ -0,0 +1,464 @@
+import subprocess
+import tempfile
+from pathlib import Path
+import os
+import logging
+from typing import List, Optional
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# MCP decorator is assumed to be available in the execution environment.
+# This is a placeholder for the actual decorator.
+class mcp:
+    @staticmethod
+    def tool(func):
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        return wrapper
+
+@mcp.tool
+def run_benchdamic(
+    config_file: Path,
+    output_dir: Path,
+):
+    """
+    Runs the full benchdamic pipeline.
+
+    This function serves as the main entry point for the benchdamic workflow,
+    executing data generation, method application, evaluation, and plotting
+    based on a single YAML configuration file. The process is run within the
+    specified output directory.
+
+    Args:
+        config_file: Path to the benchdamic YAML configuration file.
+        output_dir: Path to the directory where all outputs will be stored.
+                    It will be created if it doesn't exist.
+    """
+    # 1. Input validation
+    if not config_file.is_file():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+
+    # 2. File path handling
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # The R function benchdamic() relies on the 'output_dir' key within the config YAML.
+    # By running Rscript from the specified output_dir, we ensure that
+    # relative paths in the config file are resolved correctly.
+    r_script_content = f"""
+    if (!requireNamespace("benchdamic", quietly = TRUE)) {{
+        stop("The 'benchdamic' R package is not installed. Please install it from Bioconductor.")
+    }}
+    library(benchdamic)
+
+    config_path <- "{config_file.resolve()}"
+
+    cat("Starting benchdamic pipeline...\\n")
+    benchdamic::benchdamic(config_file = config_path)
+    cat("benchdamic pipeline finished successfully.\\n")
+    """
+
+    # 3. Subprocess execution
+    command_to_execute = []
+    stdout_str = ""
+    stderr_str = ""
+    r_script_path = None
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, dir=output_dir) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = Path(r_script_file.name)
+
+        # Use relative path for the command since we set cwd
+        command_to_execute = ["Rscript", str(r_script_path.name)]
+        
+        files_before = set(os.listdir(output_dir))
+
+        process = subprocess.run(
+            command_to_execute,
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=output_dir,
+        )
+        
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+        files_after = set(os.listdir(output_dir))
+        # Find new files and directories
+        new_items = files_after - files_before
+        output_files = [str(output_dir / item) for item in new_items]
+
+    except FileNotFoundError:
+        err_msg = "Rscript not found. Please ensure R is installed and 'Rscript' is in your system's PATH."
+        logger.error(err_msg)
+        raise RuntimeError(err_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"R script execution failed with exit code {e.returncode}")
+        logger.error(f"Command: {' '.join(command_to_execute)}")
+        logger.error(f"Stdout: {e.stdout}")
+        logger.error(f"Stderr: {e.stderr}")
+        raise
+    finally:
+        if r_script_path and r_script_path.exists():
+            r_script_path.unlink()
+
+    # 4. Structured result return
+    return {
+        "command_executed": " ".join(command_to_execute),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": output_files
+    }
+
+@mcp.tool
+def generate_data(
+    config_file: Path,
+    output_dir: Path,
+):
+    """
+    Generates simulated data using the benchdamic configuration.
+
+    This function corresponds to the `generate_data` step in the benchdamic
+    workflow. It reads simulation parameters from the config file and writes
+    the generated datasets to the specified output directory.
+
+    Args:
+        config_file: Path to the benchdamic YAML configuration file.
+        output_dir: Path to the directory where generated data will be stored.
+                    It will be created if it doesn't exist.
+    """
+    # 1. Input validation
+    if not config_file.is_file():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+
+    # 2. File path handling
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    r_script_content = f"""
+    if (!requireNamespace("benchdamic", quietly = TRUE)) {{
+        stop("The 'benchdamic' R package is not installed.")
+    }}
+    library(benchdamic)
+
+    config_path <- "{config_file.resolve()}"
+    output_path <- "{output_dir.resolve()}"
+
+    cat("Starting data generation...\\n")
+    benchdamic::generate_data(config_file = config_path, output_dir = output_path)
+    cat("Data generation finished successfully.\\n")
+    """
+
+    # 3. Subprocess execution
+    command_to_execute = []
+    stdout_str = ""
+    stderr_str = ""
+    r_script_path = None
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = Path(r_script_file.name)
+
+        command_to_execute = ["Rscript", str(r_script_path)]
+        
+        files_before = set(p.resolve() for p in output_dir.glob('**/*'))
+
+        process = subprocess.run(
+            command_to_execute,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+        files_after = set(p.resolve() for p in output_dir.glob('**/*'))
+        new_files = [str(p) for p in files_after - files_before]
+
+    except FileNotFoundError:
+        err_msg = "Rscript not found. Please ensure R is installed and 'Rscript' is in your system's PATH."
+        logger.error(err_msg)
+        raise RuntimeError(err_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"R script execution failed with exit code {e.returncode}")
+        logger.error(f"Command: {' '.join(command_to_execute)}")
+        logger.error(f"Stdout: {e.stdout}")
+        logger.error(f"Stderr: {e.stderr}")
+        raise
+    finally:
+        if r_script_path and r_script_path.exists():
+            r_script_path.unlink()
+
+    # 4. Structured result return
+    return {
+        "command_executed": " ".join(command_to_execute),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": new_files
+    }
+
+@mcp.tool
+def run_methods(
+    config_file: Path,
+    output_dir: Path,
+):
+    """
+    Runs differential abundance methods on generated data.
+
+    This function corresponds to the `run_methods` step in the benchdamic
+    workflow. It applies the specified methods to the datasets found in the
+    output directory and saves their results.
+
+    Args:
+        config_file: Path to the benchdamic YAML configuration file.
+        output_dir: Path to the directory containing the generated data and
+                    where method results will be stored. It must exist.
+    """
+    # 1. Input validation
+    if not config_file.is_file():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+    if not output_dir.is_dir():
+        raise FileNotFoundError(f"Output directory not found: {output_dir}. Please run generate_data first.")
+
+    # 2. R script content
+    r_script_content = f"""
+    if (!requireNamespace("benchdamic", quietly = TRUE)) {{
+        stop("The 'benchdamic' R package is not installed.")
+    }}
+    library(benchdamic)
+
+    config_path <- "{config_file.resolve()}"
+    output_path <- "{output_dir.resolve()}"
+
+    cat("Running differential abundance methods...\\n")
+    benchdamic::run_methods(config_file = config_path, output_dir = output_path)
+    cat("Method execution finished successfully.\\n")
+    """
+
+    # 3. Subprocess execution
+    command_to_execute = []
+    stdout_str = ""
+    stderr_str = ""
+    r_script_path = None
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = Path(r_script_file.name)
+
+        command_to_execute = ["Rscript", str(r_script_path)]
+        
+        files_before = set(p.resolve() for p in output_dir.glob('**/*'))
+
+        process = subprocess.run(
+            command_to_execute,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+        files_after = set(p.resolve() for p in output_dir.glob('**/*'))
+        new_files = [str(p) for p in files_after - files_before]
+
+    except FileNotFoundError:
+        err_msg = "Rscript not found. Please ensure R is installed and 'Rscript' is in your system's PATH."
+        logger.error(err_msg)
+        raise RuntimeError(err_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"R script execution failed with exit code {e.returncode}")
+        logger.error(f"Command: {' '.join(command_to_execute)}")
+        logger.error(f"Stdout: {e.stdout}")
+        logger.error(f"Stderr: {e.stderr}")
+        raise
+    finally:
+        if r_script_path and r_script_path.exists():
+            r_script_path.unlink()
+
+    # 4. Structured result return
+    return {
+        "command_executed": " ".join(command_to_execute),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": new_files
+    }
+
+@mcp.tool
+def evaluate_methods(
+    config_file: Path,
+    output_dir: Path,
+):
+    """
+    Evaluates the performance of differential abundance methods.
+
+    This function corresponds to the `evaluate_methods` step in the benchdamic
+    workflow. It computes performance metrics based on the method results
+    and ground truth, saving the evaluation to the output directory.
+
+    Args:
+        config_file: Path to the benchdamic YAML configuration file.
+        output_dir: Path to the directory containing method results. It must exist.
+    """
+    # 1. Input validation
+    if not config_file.is_file():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+    if not output_dir.is_dir():
+        raise FileNotFoundError(f"Output directory not found: {output_dir}.")
+
+    # 2. R script content
+    r_script_content = f"""
+    if (!requireNamespace("benchdamic", quietly = TRUE)) {{
+        stop("The 'benchdamic' R package is not installed.")
+    }}
+    library(benchdamic)
+
+    config_path <- "{config_file.resolve()}"
+    output_path <- "{output_dir.resolve()}"
+
+    cat("Evaluating method performance...\\n")
+    benchdamic::evaluate_methods(config_file = config_path, output_dir = output_path)
+    cat("Evaluation finished successfully.\\n")
+    """
+
+    # 3. Subprocess execution
+    command_to_execute = []
+    stdout_str = ""
+    stderr_str = ""
+    r_script_path = None
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = Path(r_script_file.name)
+
+        command_to_execute = ["Rscript", str(r_script_path)]
+        
+        files_before = set(p.resolve() for p in output_dir.glob('**/*'))
+
+        process = subprocess.run(
+            command_to_execute,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+        files_after = set(p.resolve() for p in output_dir.glob('**/*'))
+        new_files = [str(p) for p in files_after - files_before]
+
+    except FileNotFoundError:
+        err_msg = "Rscript not found. Please ensure R is installed and 'Rscript' is in your system's PATH."
+        logger.error(err_msg)
+        raise RuntimeError(err_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"R script execution failed with exit code {e.returncode}")
+        logger.error(f"Command: {' '.join(command_to_execute)}")
+        logger.error(f"Stdout: {e.stdout}")
+        logger.error(f"Stderr: {e.stderr}")
+        raise
+    finally:
+        if r_script_path and r_script_path.exists():
+            r_script_path.unlink()
+
+    # 4. Structured result return
+    return {
+        "command_executed": " ".join(command_to_execute),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": new_files
+    }
+
+@mcp.tool
+def plot_results(
+    config_file: Path,
+    output_dir: Path,
+):
+    """
+    Generates plots from the evaluation results.
+
+    This function corresponds to the `plot_results` step in the benchdamic
+    workflow. It creates various visualizations of the performance metrics
+    and saves them as files in the output directory.
+
+    Args:
+        config_file: Path to the benchdamic YAML configuration file.
+        output_dir: Path to the directory containing evaluation results. It must exist.
+    """
+    # 1. Input validation
+    if not config_file.is_file():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+    if not output_dir.is_dir():
+        raise FileNotFoundError(f"Output directory not found: {output_dir}.")
+
+    # 2. R script content
+    r_script_content = f"""
+    if (!requireNamespace("benchdamic", quietly = TRUE)) {{
+        stop("The 'benchdamic' R package is not installed.")
+    }}
+    library(benchdamic)
+
+    config_path <- "{config_file.resolve()}"
+    output_path <- "{output_dir.resolve()}"
+
+    cat("Generating plots...\\n")
+    benchdamic::plot_results(config_file = config_path, output_dir = output_path)
+    cat("Plot generation finished successfully.\\n")
+    """
+
+    # 3. Subprocess execution
+    command_to_execute = []
+    stdout_str = ""
+    stderr_str = ""
+    r_script_path = None
+    
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = Path(r_script_file.name)
+
+        command_to_execute = ["Rscript", str(r_script_path)]
+        
+        files_before = set(p.resolve() for p in output_dir.glob('**/*'))
+
+        process = subprocess.run(
+            command_to_execute,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+        files_after = set(p.resolve() for p in output_dir.glob('**/*'))
+        new_files = [str(p) for p in files_after - files_before]
+
+    except FileNotFoundError:
+        err_msg = "Rscript not found. Please ensure R is installed and 'Rscript' is in your system's PATH."
+        logger.error(err_msg)
+        raise RuntimeError(err_msg) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"R script execution failed with exit code {e.returncode}")
+        logger.error(f"Command: {' '.join(command_to_execute)}")
+        logger.error(f"Stdout: {e.stdout}")
+        logger.error(f"Stderr: {e.stderr}")
+        raise
+    finally:
+        if r_script_path and r_script_path.exists():
+            r_script_path.unlink()
+
+    # 4. Structured result return
+    return {
+        "command_executed": " ".join(command_to_execute),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": new_files
+    }

Biomni/mcp_generated/mcp_bioconductor-benchdamic/app/bioconductor-benchdamic_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-benchdamic/app/bioconductor-benchdamic_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_benchdamic'
+
+
+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-benchdamic/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-benchdamic/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-catscradle/app/bioconductor-catscradle_server.py

@@ -0,0 +1,312 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Union
+import tempfile
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_catscradle'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def catscradle_build_neighborhoods(
+    input_rds: str,
+    output_rds: str,
+    radius: float = 50.0,
+    cell_type_col: str = "cell_type",
+    assay: str = "Spatial",
+    slot: str = "counts",
+    min_cells: int = 1
+):
+    """
+    Identifies tissue neighborhoods in spatial transcriptomics data and produces a Seurat object 
+    where individual elements are neighborhoods rather than cells.
+
+    Args:
+        input_rds: Path to the input Seurat or SpatialExperiment object (RDS format).
+        output_rds: Path where the resulting neighborhood Seurat object will be saved.
+        radius: The radius (in spatial units) defining the contiguous region surrounding individual cells.
+        cell_type_col: Metadata column name containing cell type annotations.
+        assay: Assay to use from the input object.
+        slot: Slot to use (e.g., counts, data).
+        min_cells: Minimum number of cells required to define a neighborhood.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file not found: {input_rds}"}
+    
+    if radius <= 0:
+        return {"error": "Radius must be a positive float."}
+
+    # R script to perform neighborhood construction
+    r_code = f"""
+    library(CatsCradle)
+    library(Seurat)
+    library(SpatialExperiment)
+
+    # Load data
+    input_data <- readRDS("{input_path}")
+    
+    # Check if it's SpatialExperiment and convert if necessary
+    if (inherits(input_data, "SpatialExperiment")) {{
+        # CatsCradle handles SE/SPE, but we ensure Seurat compatibility if needed
+        # Internal CatsCradle functions typically take these objects
+    }}
+
+    # Core CatsCradle logic for neighborhood construction
+    # Based on package description: "produces Seurat objects whose individual elements are neighborhoods"
+    # We use the primary constructor function (inferred from documentation)
+    neighborhood_obj <- CatsCradle::spatialToNeighborhoods(
+        object = input_data,
+        radius = {radius},
+        cell_type_col = "{cell_type_col}",
+        assay = "{assay}",
+        slot = "{slot}",
+        min_cells = {min_cells}
+    )
+
+    saveRDS(neighborhood_obj, "{output_path}")
+    """
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+            tmp.write(r_code)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_path)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": " ".join(e.cmd)
+        }
+    finally:
+        if 'tmp_path' in locals() and Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+@mcp.tool()
+def catscradle_gene_centric_analysis(
+    input_rds: str,
+    output_rds: str,
+    assay: str = "RNA",
+    slot: str = "data",
+    variable_features_only: bool = True,
+    n_features: int = 2000
+):
+    """
+    Enables the categorisation and annotation of genes by producing Seurat objects 
+    whose elements are genes rather than cells.
+
+    Args:
+        input_rds: Path to the input Seurat object (RDS format).
+        output_rds: Path where the gene-centric Seurat object will be saved.
+        assay: Assay to use for gene expression data.
+        slot: Slot to use (e.g., data, scale.data).
+        variable_features_only: Whether to only include highly variable features.
+        n_features: Number of features to select if variable_features_only is True.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file not found: {input_rds}"}
+
+    r_code = f"""
+    library(CatsCradle)
+    library(Seurat)
+
+    input_data <- readRDS("{input_path}")
+
+    # Core CatsCradle logic for gene-centric Seurat object creation
+    gene_obj <- CatsCradle::geneCentricSeurat(
+        object = input_data,
+        assay = "{assay}",
+        slot = "{slot}",
+        variable_features_only = {"TRUE" if variable_features_only else "FALSE"},
+        n_features = {n_features}
+    )
+
+    saveRDS(gene_obj, "{output_path}")
+    """
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+            tmp.write(r_code)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_path)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": " ".join(e.cmd)
+        }
+    finally:
+        if 'tmp_path' in locals() and Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+@mcp.tool()
+def catscradle_tag_neighborhoods(
+    neighborhood_rds: str,
+    output_rds: str,
+    tag_by: str = "cell_type",
+    threshold: float = 0.1
+):
+    """
+    Categorizes neighborhoods by the cell types contained in them or the genes expressed in them.
+
+    Args:
+        neighborhood_rds: Path to the neighborhood Seurat object created by catscradle_build_neighborhoods.
+        output_rds: Path to save the tagged neighborhood object.
+        tag_by: Attribute to tag by ('cell_type' or 'gene_expression').
+        threshold: Minimum proportion or expression level to consider a tag present in a neighborhood.
+    """
+    input_path = Path(neighborhood_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file not found: {neighborhood_rds}"}
+
+    r_code = f"""
+    library(CatsCradle)
+    library(Seurat)
+
+    nb_obj <- readRDS("{input_path}")
+
+    # Categorize neighborhoods
+    nb_obj <- CatsCradle::tagNeighborhoods(
+        object = nb_obj,
+        tag_by = "{tag_by}",
+        threshold = {threshold}
+    )
+
+    saveRDS(nb_obj, "{output_path}")
+    """
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+            tmp.write(r_code)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_path)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": " ".join(e.cmd)
+        }
+    finally:
+        if 'tmp_path' in locals() and Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+@mcp.tool()
+def catscradle_spatial_vignette_pipeline(
+    input_rds: str,
+    output_prefix: str,
+    radius: float = 50.0,
+    cell_type_col: str = "cell_type"
+):
+    """
+    Runs a standard CatsCradle spatial analysis pipeline, including neighborhood construction 
+    and gene clustering, as described in the package vignettes.
+
+    Args:
+        input_rds: Path to the input spatial transcriptomics RDS file.
+        output_prefix: Prefix for output files (e.g., 'results/sample1').
+        radius: Radius for neighborhood definition.
+        cell_type_col: Metadata column for cell types.
+    """
+    input_path = Path(input_rds)
+    out_dir = Path(output_prefix).parent
+    if not out_dir.exists():
+        out_dir.mkdir(parents=True, exist_ok=True)
+
+    r_code = f"""
+    library(CatsCradle)
+    library(Seurat)
+
+    # 1. Load Data
+    spatial_data <- readRDS("{input_path}")
+
+    # 2. Build Neighborhoods
+    nb_obj <- CatsCradle::spatialToNeighborhoods(
+        object = spatial_data,
+        radius = {radius},
+        cell_type_col = "{cell_type_col}"
+    )
+    saveRDS(nb_obj, paste0("{output_prefix}", "_neighborhoods.rds"))
+
+    # 3. Gene Centric Analysis
+    gene_obj <- CatsCradle::geneCentricSeurat(spatial_data)
+    saveRDS(gene_obj, paste0("{output_prefix}", "_gene_centric.rds"))
+
+    # 4. Discover Gene Clusters (Internal CatsCradle method)
+    # This typically involves standard Seurat clustering on the gene-centric object
+    gene_obj <- Seurat::FindVariableFeatures(gene_obj)
+    gene_obj <- Seurat::ScaleData(gene_obj)
+    gene_obj <- Seurat::RunPCA(gene_obj)
+    gene_obj <- Seurat::FindNeighbors(gene_obj)
+    gene_obj <- Seurat::FindClusters(gene_obj)
+    saveRDS(gene_obj, paste0("{output_prefix}", "_gene_clusters.rds"))
+    """
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+            tmp.write(r_code)
+            tmp_path = tmp.name
+
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [
+                f"{output_prefix}_neighborhoods.rds",
+                f"{output_prefix}_gene_centric.rds",
+                f"{output_prefix}_gene_clusters.rds"
+            ]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": " ".join(e.cmd)
+        }
+    finally:
+        if 'tmp_path' in locals() and Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-catscradle/app/bioconductor-catscradle_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-catscradle/app/bioconductor-catscradle_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_catscradle'
+
+
+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-catscradle/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-catscradle/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-clustifyr/app/bioconductor-clustifyr_server.py

@@ -0,0 +1,127 @@
+import subprocess
+import shlex
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# @mcp.tool() is a placeholder for the actual decorator in the MCP framework.
+# The code is written to be compatible with it.
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_clustifyr'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def clustifyr_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,
+    save: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    restore: bool = False,
+    vanilla: bool = False,
+) -> Dict[str, Any]:
+    """
+    Executes an R script using Rscript, for running Bioconductor packages like clustifyr.
+
+    This tool serves as a wrapper around the Rscript command-line interpreter,
+    allowing the execution of R scripts that utilize the clustifyr library or other
+    Bioconductor packages. You can either provide an R script file or a list of
+    R expressions to execute.
+
+    Args:
+        script_file: Path to the R script file to be executed. Mutually exclusive with 'expressions'.
+        expressions: A list of R expressions to execute. Mutually exclusive with 'script_file'.
+        script_args: A list of arguments to be passed to the R script itself.
+        verbose: If True, print information on progress.
+        default_packages: A comma-separated list of package names to be loaded by default (e.g., "clustifyr,Seurat").
+        save: If True, save the workspace at the end of the session. Ignored if 'vanilla' is True.
+        no_environ: If True, do not read the site and user environment files. Ignored if 'vanilla' is True.
+        no_site_file: If True, do not read the site-wide Rprofile. Ignored if 'vanilla' is True.
+        no_init_file: If True, do not read the user R profile. Ignored if 'vanilla' is True.
+        restore: If True, restore previously saved objects at startup. Ignored if 'vanilla' is True.
+        vanilla: If True, combines --no-save, --no-restore, --no-site-file, --no-init-file, and --no-environ.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+        Note: Output files are not automatically detected and must be known from the R script's logic.
+    """
+    # 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:
+        if not script_file.is_file():
+            raise FileNotFoundError(f"The specified script file does not exist: {script_file}")
+
+    # 2. Command Construction
+    cmd = ["Rscript"]
+
+    # The --vanilla option is a shortcut for several other flags.
+    if vanilla:
+        cmd.append("--vanilla")
+    else:
+        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")
+
+    if verbose:
+        cmd.append("--verbose")
+
+    if default_packages:
+        cmd.extend(["--default-packages", default_packages])
+
+    # Add the script file or expressions to execute
+    if script_file:
+        cmd.append(str(script_file))
+    elif expressions:
+        for expr in expressions:
+            cmd.extend(["-e", expr])
+
+    # Add any additional arguments for the R script itself
+    if script_args:
+        cmd.extend(script_args)
+
+    command_executed = shlex.join(cmd)
+
+    # 3. Subprocess Execution
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        # 4. Structured Result Return
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": []  # Rscript does not have a defined output file parameter.
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        # Handle cases where the R script fails
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Rscript execution failed with return code {e.returncode}",
+            "output_files": []
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-clustifyr/app/bioconductor-clustifyr_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-clustifyr/app/bioconductor-clustifyr_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_clustifyr'
+
+
+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-clustifyr/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-clustifyr/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-genomicfeatures/app/bioconductor-genomicfeatures_server.py

@@ -0,0 +1,178 @@
+import subprocess
+import tempfile
+import shlex
+from pathlib import Path
+from typing import Optional, Dict, List
+
+# @mcp.tool() is a placeholder for the actual decorator.
+# The code is written to be compatible with the MCP framework.
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_genomicfeatures'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def make_txdb_from_gff(
+    gff_file: Path,
+    output_db_path: Path,
+    format: Optional[str] = None,
+    data_source: Optional[str] = None,
+    organism: Optional[str] = None,
+    taxonomy_id: Optional[int] = None,
+    chrominfo_file: Optional[Path] = None,
+    metadata_file: Optional[Path] = None,
+    pruning_mode: str = "coarse",
+    on_foreign_chrom: str = "abort",
+    infer_cds: bool = False,
+    infer_utr: bool = True,
+) -> Dict:
+    """
+    Creates a TranscriptDb (TxDb) SQLite database from a GFF or GTF file.
+
+    This tool serves as a wrapper for the `makeTxDbFromGFF` function from the
+    R/Bioconductor GenomicFeatures package. It parses a gene annotation file
+    (GFF3 or GTF) and stores the transcript metadata in a structured SQLite
+    database, which is highly efficient for downstream analysis.
+
+    Args:
+        gff_file: Path to the input GFF3 or GTF file.
+        output_db_path: Path where the output SQLite TxDb file will be saved.
+        format: The format of the input file. Can be 'gff3' or 'gtf'.
+                If not provided, the tool attempts to infer it from the file extension.
+        data_source: A string describing the source of the data (e.g., "Ensembl v104").
+        organism: The scientific name of the organism (e.g., "Homo sapiens").
+        taxonomy_id: The NCBI Taxonomy ID for the organism.
+        chrominfo_file: Optional path to a two-column, tab-separated file containing
+                        chromosome names and their lengths.
+        metadata_file: Optional path to a two-column, tab-separated file containing
+                       metadata as name-value pairs to be stored in the database.
+        pruning_mode: Sets the strictness for handling problematic transcripts.
+                      Must be one of 'coarse', 'fine', or 'strict'.
+        on_foreign_chrom: Action to take for features on chromosomes not listed in
+                          `chrominfo_file`. Must be one of 'abort', 'drop', or 'as.is'.
+        infer_cds: If TRUE, infer CDS features from annotated stop codons.
+        infer_utr: If TRUE, infer UTR features (5' and 3') when not explicitly provided.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a
+        mapping to the generated output database file.
+    """
+    # 1. Input Validation
+    if not gff_file.is_file():
+        raise FileNotFoundError(f"Input GFF/GTF file not found: {gff_file}")
+
+    if chrominfo_file and not chrominfo_file.is_file():
+        raise FileNotFoundError(f"Chrominfo file not found: {chrominfo_file}")
+
+    if metadata_file and not metadata_file.is_file():
+        raise FileNotFoundError(f"Metadata file not found: {metadata_file}")
+
+    if format and format.lower() not in ["gff3", "gtf"]:
+        raise ValueError("Parameter 'format' must be either 'gff3' or 'gtf'.")
+
+    allowed_pruning = ["coarse", "fine", "strict"]
+    if pruning_mode not in allowed_pruning:
+        raise ValueError(f"Parameter 'pruning_mode' must be one of {allowed_pruning}.")
+
+    allowed_foreign_chrom = ["abort", "drop", "as.is"]
+    if on_foreign_chrom not in allowed_foreign_chrom:
+        raise ValueError(f"Parameter 'on_foreign_chrom' must be one of {allowed_foreign_chrom}.")
+
+    output_db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. R Script Generation
+    # Use R-friendly paths (forward slashes) for cross-platform compatibility
+    gff_file_r = str(gff_file).replace('\\', '/')
+    output_db_path_r = str(output_db_path).replace('\\', '/')
+
+    r_script_lines = [
+        "suppressPackageStartupMessages(library(GenomicFeatures))",
+        "",
+        "# Build the argument list for makeTxDbFromGFF",
+        f'txdb_args <- list(file = "{gff_file_r}")',
+    ]
+
+    # Add optional arguments to the list
+    if format:
+        r_script_lines.append(f'txdb_args$format <- "{format.lower()}"')
+    if data_source:
+        r_script_lines.append(f'txdb_args$dataSource <- "{data_source}"')
+    if organism:
+        r_script_lines.append(f'txdb_args$organism <- "{organism}"')
+    if taxonomy_id is not None:
+        r_script_lines.append(f'txdb_args$taxonomyId <- {taxonomy_id}')
+    
+    r_script_lines.append(f'txdb_args$pruning.mode <- "{pruning_mode}"')
+    r_script_lines.append(f'txdb_args$on.foreign.chrom <- "{on_foreign_chrom}"')
+    r_script_lines.append(f'txdb_args$infer_cds <- {"TRUE" if infer_cds else "FALSE"}')
+    r_script_lines.append(f'txdb_args$infer_utr <- {"TRUE" if infer_utr else "FALSE"}')
+
+    if chrominfo_file:
+        chrominfo_file_r = str(chrominfo_file).replace('\\', '/')
+        r_script_lines.extend([
+            f'chrominfo_df <- read.table("{chrominfo_file_r}", sep="\\t", header=FALSE, col.names=c("chrom", "length"), stringsAsFactors=FALSE)',
+            'txdb_args$chrominfo <- chrominfo_df'
+        ])
+    
+    if metadata_file:
+        metadata_file_r = str(metadata_file).replace('\\', '/')
+        r_script_lines.extend([
+            f'metadata_df <- read.table("{metadata_file_r}", sep="\\t", header=FALSE, col.names=c("name", "value"), stringsAsFactors=FALSE)',
+            'txdb_args$metadata <- metadata_df'
+        ])
+
+    r_script_lines.extend([
+        "",
+        "# Execute the function with the constructed arguments",
+        "txdb <- do.call(makeTxDbFromGFF, txdb_args)",
+        "",
+        "# Save the resulting database",
+        f'saveDb(txdb, file="{output_db_path_r}")',
+        'message("TxDb database created successfully.")'
+    ])
+
+    r_script_content = "\n".join(r_script_lines)
+    
+    script_path = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R", encoding='utf-8') as r_script_file:
+            r_script_file.write(r_script_content)
+            script_path = r_script_file.name
+        
+        # 3. Subprocess Execution
+        cmd = ["Rscript", script_path]
+        command_executed = shlex.join(cmd)
+
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+
+        # 4. Structured Result Return
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {"txdb_database": str(output_db_path)}
+        }
+
+    except subprocess.CalledProcessError as e:
+        # R often prints errors to stdout, so combine them for a comprehensive message
+        error_message = (
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"STDOUT:\n{e.stdout}\n"
+            f"STDERR:\n{e.stderr}\n"
+        )
+        raise RuntimeError(error_message) from e
+    
+    finally:
+        # Clean up the temporary script file
+        if script_path and Path(script_path).exists():
+            Path(script_path).unlink()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-genomicfeatures/app/bioconductor-genomicfeatures_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-genomicfeatures/app/bioconductor-genomicfeatures_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_genomicfeatures'
+
+
+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-genomicfeatures/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-genomicfeatures/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-hdf5array/app/bioconductor-hdf5array_server.py

@@ -0,0 +1,460 @@
+import subprocess
+import tempfile
+import textwrap
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+# MCP decorator is not defined in this context, so we'll use a placeholder.
+# In a real MCP environment, this would be: from mcp import tool
+class mcp:
+    def tool(func):
+        return func
+
+@mcp.tool
+def write_hdf5_array(
+    input_file: Path,
+    output_hdf5: Path,
+    dataset_name: str,
+    input_format: str = "csv",
+    chunk_dim: Optional[str] = None,
+    compression_level: int = 6,
+    as_integer: bool = False,
+    csv_header: bool = True,
+    csv_row_names_col: Optional[int] = 1,
+) -> Dict[str, Union[str, Dict[str, str]]]:
+    """
+    Converts a data file (CSV, TSV, or RDS) into an HDF5 file using HDF5Array.
+
+    This tool is a wrapper around the HDF5Array::writeHDF5Array R function.
+    It requires R and the Bioconductor 'HDF5Array' package to be installed.
+    """
+    # 1. Input validation
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if not output_hdf5.parent.exists():
+        raise FileNotFoundError(f"Output directory does not exist: {output_hdf5.parent}")
+    if input_format not in ["csv", "tsv", "rds"]:
+        raise ValueError("input_format must be one of 'csv', 'tsv', or 'rds'.")
+    if not (0 <= compression_level <= 9):
+        raise ValueError("compression_level must be between 0 and 9.")
+    if chunk_dim:
+        try:
+            [int(d) for d in chunk_dim.split(',')]
+        except ValueError:
+            raise ValueError("chunk_dim must be a comma-separated string of integers (e.g., '100,1000').")
+
+    # 2. R script for execution
+    r_script_content = textwrap.dedent("""
+    suppressPackageStartupMessages({
+        library(optparse)
+        library(HDF5Array)
+    })
+
+    option_list <- list(
+        make_option("--input", type="character", help="Input file path (CSV, TSV, or RDS)."),
+        make_option("--output", type="character", help="Output HDF5 file path."),
+        make_option("--name", type="character", help="Name for the dataset within the HDF5 file."),
+        make_option("--format", type="character", default="csv", help="Input file format [csv, tsv, rds]."),
+        make_option("--chunkdim", type="character", default=NULL, help="Comma-separated chunk dimensions."),
+        make_option("--level", type="integer", default=6, help="Compression level (0-9)."),
+        make_option("--as_integer", action="store_true", default=FALSE, help="Coerce data to integer."),
+        make_option("--header", action="store_true", default=TRUE, help="Does the CSV/TSV have a header?"),
+        make_option("--rownames", type="integer", default=NULL, help="Column number for row names in CSV/TSV.")
+    )
+
+    args <- parse_args(OptionParser(option_list=option_list))
+
+    # Read input data
+    message("Reading input file: ", args$input)
+    if (args$format == "rds") {
+        data_matrix <- readRDS(args$input)
+    } else if (args$format == "csv") {
+        data_matrix <- read.csv(args$input, header=args$header, row.names=args$rownames, check.names=FALSE)
+    } else if (args$format == "tsv") {
+        data_matrix <- read.delim(args$input, header=args$header, row.names=args$rownames, check.names=FALSE)
+    } else {
+        stop("Unsupported format: ", args$format)
+    }
+
+    if (!is.matrix(data_matrix)) {
+        message("Input data is not a matrix, coercing...")
+        data_matrix <- as.matrix(data_matrix)
+    }
+
+    if (args$as_integer) {
+        message("Coercing data to integer...")
+        storage.mode(data_matrix) <- "integer"
+    }
+
+    # Parse chunk dimensions
+    chunk_dims <- NULL
+    if (!is.null(args$chunkdim)) {
+        chunk_dims <- as.integer(strsplit(args$chunkdim, ",")[[1]])
+        message("Using chunk dimensions: ", paste(chunk_dims, collapse=", "))
+    }
+
+    # Write HDF5 array
+    message("Writing HDF5 array to: ", args$output)
+    writeHDF5Array(
+        x = data_matrix,
+        filepath = args$output,
+        name = args$name,
+        chunkdim = chunk_dims,
+        level = args$level,
+        with.dimnames = TRUE,
+        verbose = TRUE
+    )
+    message("Successfully created HDF5 file.")
+    """)
+
+    # 3. Subprocess execution
+    cmd = [
+        "Rscript", "-",
+        "--input", str(input_file),
+        "--output", str(output_hdf5),
+        "--name", dataset_name,
+        "--format", input_format,
+        "--level", str(compression_level),
+    ]
+    if chunk_dim:
+        cmd.extend(["--chunkdim", chunk_dim])
+    if as_integer:
+        cmd.append("--as_integer")
+    if csv_header:
+        cmd.append("--header")
+    if csv_row_names_col is not None:
+        cmd.extend(["--rownames", str(csv_row_names_col)])
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=True, suffix=".R") as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_file.flush()
+            
+            # Rebuild command to use the script file
+            cmd[1] = r_script_file.name
+            
+            process = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": {"output_hdf5": str(output_hdf5)},
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = (
+            f"HDF5Array R script failed with exit code {e.returncode}.\n"
+            f"This may be due to missing R packages ('optparse', 'HDF5Array').\n"
+            f"Please install them in R using:\n"
+            f"install.packages('optparse')\n"
+            f"if (!requireNamespace('BiocManager', quietly = TRUE)) install.packages('BiocManager')\n"
+            f"BiocManager::install('HDF5Array')\n\n"
+            f"STDOUT:\n{e.stdout}\n"
+            f"STDERR:\n{e.stderr}"
+        )
+        raise RuntimeError(error_message) from e
+
+
+@mcp.tool
+def save_hdf5_summarized_experiment(
+    input_rds: Path,
+    output_dir: Path,
+    prefix: Optional[str] = None,
+    replace: bool = False,
+) -> Dict[str, Union[str, Dict[str, str]]]:
+    """
+    Saves a SummarizedExperiment object from an RDS file to an HDF5-backed format.
+
+    This tool wraps the HDF5Array::saveHDF5SummarizedExperiment R function.
+    It requires R and the Bioconductor packages 'HDF5Array' and 'SummarizedExperiment'.
+    """
+    # 1. Input validation
+    if not input_rds.exists():
+        raise FileNotFoundError(f"Input RDS file not found: {input_rds}")
+    if output_dir.exists() and not output_dir.is_dir():
+        raise ValueError(f"Output path exists but is not a directory: {output_dir}")
+    if output_dir.exists() and any(output_dir.iterdir()) and not replace:
+        raise FileExistsError(f"Output directory {output_dir} is not empty. Use replace=True to overwrite.")
+    
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # 2. R script for execution
+    r_script_content = textwrap.dedent("""
+    suppressPackageStartupMessages({
+        library(optparse)
+        library(HDF5Array)
+        library(SummarizedExperiment)
+    })
+
+    option_list <- list(
+        make_option("--input", type="character", help="Input RDS file containing a SummarizedExperiment object."),
+        make_option("--outdir", type="character", help="Output directory to save the HDF5SummarizedExperiment."),
+        make_option("--prefix", type="character", default=NULL, help="Optional prefix for file names."),
+        make_option("--replace", action="store_true", default=FALSE, help="Replace existing directory content.")
+    )
+
+    args <- parse_args(OptionParser(option_list=option_list))
+
+    message("Reading SummarizedExperiment object from: ", args$input)
+    se <- readRDS(args$input)
+
+    if (!is(se, "SummarizedExperiment")) {
+        stop("The object in the RDS file is not a SummarizedExperiment.")
+    }
+
+    message("Saving HDF5SummarizedExperiment to: ", args$outdir)
+    saveHDF5SummarizedExperiment(
+        x = se,
+        dir = args$outdir,
+        prefix = args$prefix,
+        replace = args$replace,
+        verbose = TRUE
+    )
+    message("Successfully saved HDF5SummarizedExperiment.")
+    """)
+
+    # 3. Subprocess execution
+    cmd = [
+        "Rscript", "-",
+        "--input", str(input_rds),
+        "--outdir", str(output_dir),
+    ]
+    if prefix:
+        cmd.extend(["--prefix", prefix])
+    if replace:
+        cmd.append("--replace")
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=True, suffix=".R") as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_file.flush()
+            
+            cmd[1] = r_script_file.name
+            
+            process = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": {"output_directory": str(output_dir)},
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = (
+            f"HDF5Array R script failed with exit code {e.returncode}.\n"
+            f"This may be due to missing R packages ('optparse', 'HDF5Array', 'SummarizedExperiment').\n"
+            f"Please install them in R using BiocManager.\n\n"
+            f"STDOUT:\n{e.stdout}\n"
+            f"STDERR:\n{e.stderr}"
+        )
+        raise RuntimeError(error_message) from e
+
+
+@mcp.tool
+def export_hdf5_summarized_experiment(
+    input_dir: Path,
+    output_dir: Path,
+    assay_names: Optional[str] = None,
+    export_coldata: bool = True,
+    export_rowdata: bool = True,
+) -> Dict[str, Union[str, Dict[str, str]]]:
+    """
+    Loads an HDF5SummarizedExperiment and exports its components to CSV files.
+
+    This tool wraps HDF5Array::loadHDF5SummarizedExperiment and exports data.
+    Requires R and the Bioconductor packages 'HDF5Array' and 'SummarizedExperiment'.
+    """
+    # 1. Input validation
+    if not input_dir.is_dir():
+        raise FileNotFoundError(f"Input directory not found: {input_dir}")
+    if output_dir.exists() and not output_dir.is_dir():
+        raise ValueError(f"Output path exists but is not a directory: {output_dir}")
+    
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # 2. R script for execution
+    r_script_content = textwrap.dedent("""
+    suppressPackageStartupMessages({
+        library(optparse)
+        library(HDF5Array)
+        library(SummarizedExperiment)
+    })
+
+    option_list <- list(
+        make_option("--indir", type="character", help="Input directory of the HDF5SummarizedExperiment."),
+        make_option("--outdir", type="character", help="Output directory for exported CSV files."),
+        make_option("--assays", type="character", default=NULL, help="Comma-separated list of assays to export (default: all)."),
+        make_option("--coldata", action="store_true", default=FALSE, help="Export colData to CSV."),
+        make_option("--rowdata", action="store_true", default=FALSE, help="Export rowData to CSV.")
+    )
+
+    args <- parse_args(OptionParser(option_list=option_list))
+
+    message("Loading HDF5SummarizedExperiment from: ", args$indir)
+    se <- loadHDF5SummarizedExperiment(dir = args$indir)
+
+    assays_to_export <- assayNames(se)
+    if (!is.null(args$assays)) {
+        assays_to_export <- intersect(assays_to_export, strsplit(args$assays, ",")[[1]])
+    }
+
+    if (length(assays_to_export) > 0) {
+        for (aname in assays_to_export) {
+            message("Exporting assay: ", aname)
+            out_path <- file.path(args$outdir, paste0("assay_", aname, ".csv"))
+            mat <- as.matrix(assay(se, aname))
+            write.csv(mat, file=out_path, quote=FALSE, row.names=TRUE)
+        }
+    }
+
+    if (args$coldata) {
+        message("Exporting colData")
+        out_path <- file.path(args$outdir, "coldata.csv")
+        write.csv(as.data.frame(colData(se)), file=out_path, quote=FALSE, row.names=TRUE)
+    }
+
+    if (args$rowdata) {
+        message("Exporting rowData")
+        out_path <- file.path(args$outdir, "rowdata.csv")
+        write.csv(as.data.frame(rowData(se)), file=out_path, quote=FALSE, row.names=TRUE)
+    }
+
+    message("Export complete.")
+    """)
+
+    # 3. Subprocess execution
+    cmd = [
+        "Rscript", "-",
+        "--indir", str(input_dir),
+        "--outdir", str(output_dir),
+    ]
+    if assay_names:
+        cmd.extend(["--assays", assay_names])
+    if export_coldata:
+        cmd.append("--coldata")
+    if export_rowdata:
+        cmd.append("--rowdata")
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=True, suffix=".R") as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_file.flush()
+            
+            cmd[1] = r_script_file.name
+            
+            process = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        
+        output_files = [str(p) for p in output_dir.glob("*.csv")]
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": {"output_directory": str(output_dir), "exported_files": output_files},
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = (
+            f"HDF5Array R script failed with exit code {e.returncode}.\n"
+            f"This may be due to missing R packages or an invalid HDF5SummarizedExperiment directory.\n\n"
+            f"STDOUT:\n{e.stdout}\n"
+            f"STDERR:\n{e.stderr}"
+        )
+        raise RuntimeError(error_message) from e
+
+
+@mcp.tool
+def inspect_hdf5_array(
+    input_hdf5: Path,
+    dataset_name: str,
+) -> Dict[str, str]:
+    """
+    Inspects an HDF5 file and prints properties of a specific HDF5Array dataset.
+
+    This tool provides information like dimensions and chunking without loading data.
+    Requires R and the Bioconductor 'HDF5Array' package.
+    """
+    # 1. Input validation
+    if not input_hdf5.exists():
+        raise FileNotFoundError(f"Input HDF5 file not found: {input_hdf5}")
+
+    # 2. R script for execution
+    r_script_content = textwrap.dedent("""
+    suppressPackageStartupMessages({
+        library(optparse)
+        library(HDF5Array)
+    })
+
+    option_list <- list(
+        make_option("--file", type="character", help="Input HDF5 file path."),
+        make_option("--name", type="character", help="Name of the dataset to inspect.")
+    )
+
+    args <- parse_args(OptionParser(option_list=option_list))
+
+    # Load the HDF5 array seed
+    HDF5_dataset <- HDF5Array(args$file, args$name)
+
+    # Print properties
+    cat("Dataset:", name(HDF5_dataset), "\\n")
+    cat("Filepath:", path(HDF5_dataset), "\\n")
+    cat("Dimensions:", paste(dim(HDF5_dataset), collapse=" x "), "\\n")
+    cat("Datatype:", class(HDF5_dataset@seed@first_val), "\\n")
+    cat("Chunking:", paste(chunkdim(HDF5_dataset), collapse=" x "), "\\n")
+    """)
+
+    # 3. Subprocess execution
+    cmd = [
+        "Rscript", "-",
+        "--file", str(input_hdf5),
+        "--name", dataset_name,
+    ]
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=True, suffix=".R") as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_file.flush()
+            
+            cmd[1] = r_script_file.name
+            
+            process = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = (
+            f"HDF5Array R script failed with exit code {e.returncode}.\n"
+            f"This may be due to a missing R package, an incorrect file path, or a non-existent dataset name ('{dataset_name}').\n\n"
+            f"STDOUT:\n{e.stdout}\n"
+            f"STDERR:\n{e.stderr}"
+        )
+        raise RuntimeError(error_message) from e

Biomni/mcp_generated/mcp_bioconductor-hdf5array/app/bioconductor-hdf5array_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-hdf5array/app/bioconductor-hdf5array_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_hdf5array'
+
+
+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-hdf5array/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-hdf5array/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-irisfgm/app/bioconductor-irisfgm_server.py

@@ -0,0 +1,183 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_irisfgm'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_irisfgm_script(
+    r_script_content: str,
+    output_dir: Path = Path("./"),
+    r_environment_setup_script: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Executes an R script that utilizes the bioconductor-irisfgm package.
+
+    The bioconductor-irisfgm tool is an R package designed for comprehensive
+    analysis of gene interactivity networks based on single-cell RNA-Seq data.
+    As the provided documentation does not expose a direct command-line
+    interface with specific subcommands and parameters, this MCP tool provides
+    a generic entry point to execute arbitrary R code that leverages the IRISFGM
+    package.
+
+    Users are expected to provide an R script that loads the IRISFGM package
+    and calls its internal functions as needed. The R script should be written
+    to save any desired output files to the directory specified by the
+    'OUTPUT_DIR' environment variable, which corresponds to the `output_dir`
+    parameter.
+
+    Example R script content:
+    ```R
+    # Load the IRISFGM package
+    library(IRISFGM)
+
+    # --- Placeholder for actual IRISFGM function calls ---
+    # In a real scenario, you would load your actual scRNA-seq data
+    # (e.g., from a CSV, TSV, or a Seurat object) and then apply IRISFGM functions.
+    #
+    # Example: Create a dummy SingleCellExperiment object for demonstration
+    # library(SingleCellExperiment)
+    # counts <- matrix(rnbinom(1000, mu=10, size=1), ncol=10)
+    # rownames(counts) <- paste0("gene", 1:100)
+    # colnames(counts) <- paste0("cell", 1:10)
+    # sce <- SingleCellExperiment(assays=list(counts=counts))
+    #
+    # Example of a hypothetical IRISFGM function call (replace with actual functions):
+    # fgms_result <- IRISFGM::identifyFGMs(sce_object, ...)
+    #
+    # Print some output to stdout
+    message("IRISFGM R script executed successfully.")
+    #
+    # Save results to a file in the output directory
+    # output_dir <- Sys.getenv("OUTPUT_DIR")
+    # if (!is.null(output_dir) && dir.exists(output_dir)) {
+    #   write.csv(data.frame(gene="gene1", value=10), file = file.path(output_dir, "example_output.csv"))
+    #   message(paste("Saved example_output.csv to", output_dir))
+    # } else {
+    #   warning("OUTPUT_DIR environment variable not set or directory does not exist.")
+    # }
+    ```
+
+    Args:
+        r_script_content: A string containing the R script to be executed.
+                          This script should include calls to IRISFGM functions.
+        output_dir: The directory where any output files generated by the R script
+                    should be stored. The R script should be written to save
+                    files to this directory (e.g., using `file.path(Sys.getenv("OUTPUT_DIR"), "filename")`).
+                    Defaults to the current working directory.
+        r_environment_setup_script: Optional R script content to run before the main
+                                    `r_script_content`. This can be used for
+                                    environment setup, installing packages, etc.,
+                                    if not handled by the container.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list
+        of any output files generated.
+    """
+    if not r_script_content:
+        raise ValueError("R script content cannot be empty.")
+
+    # Ensure the output directory exists
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    command_executed: List[str] = []
+    stdout: str = ""
+    stderr: str = ""
+    output_files: List[Path] = []
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        temp_dir_path = Path(tmpdir)
+        r_script_path = temp_dir_path / "main_script.R"
+        setup_script_path: Optional[Path] = None
+
+        # Write the main R script content to a temporary file
+        with open(r_script_path, "w") as f:
+            f.write(r_script_content)
+
+        # Prepare environment variables for the R process
+        env_vars = {"OUTPUT_DIR": str(output_dir)}
+
+        # If an R environment setup script is provided, execute it first
+        if r_environment_setup_script:
+            setup_script_path = temp_dir_path / "setup_script.R"
+            with open(setup_script_path, "w") as f:
+                f.write(r_environment_setup_script)
+            setup_command = ["Rscript", str(setup_script_path)]
+            command_executed.append(" ".join(setup_command))
+            try:
+                setup_result = subprocess.run(
+                    setup_command,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                    env={**subprocess.os.environ, **env_vars} # Merge with current environment
+                )
+                stdout += f"Setup script stdout:\n{setup_result.stdout}\n"
+                stderr += f"Setup script stderr:\n{setup_result.stderr}\n"
+            except subprocess.CalledProcessError as e:
+                return {
+                    "command_executed": " ".join(setup_command),
+                    "stdout": e.stdout,
+                    "stderr": e.stderr,
+                    "error": f"R setup script failed with exit code {e.returncode}",
+                    "output_files": [],
+                }
+            except FileNotFoundError:
+                return {
+                    "command_executed": " ".join(setup_command),
+                    "stdout": "",
+                    "stderr": "Error: Rscript command not found. Is R installed and in PATH?",
+                    "error": "Rscript not found for setup script",
+                    "output_files": [],
+                }
+
+        # Execute the main R script
+        r_command = ["Rscript", str(r_script_path)]
+        command_executed.append(" ".join(r_command))
+
+        try:
+            result = subprocess.run(
+                r_command,
+                capture_output=True,
+                text=True,
+                check=True,
+                env={**subprocess.os.environ, **env_vars} # Merge with current environment
+            )
+            stdout += result.stdout
+            stderr += result.stderr
+
+            # Collect output files from the specified output_dir
+            for f in output_dir.iterdir():
+                if f.is_file():
+                    output_files.append(f)
+
+        except subprocess.CalledProcessError as e:
+            return {
+                "command_executed": "\n".join(command_executed),
+                "stdout": e.stdout,
+                "stderr": e.stderr,
+                "error": f"R script failed with exit code {e.returncode}",
+                "output_files": [],
+            }
+        except FileNotFoundError:
+            return {
+                "command_executed": "\n".join(command_executed),
+                "stdout": "",
+                "stderr": "Error: Rscript command not found. Is R installed and in PATH?",
+                "error": "Rscript not found for main script",
+                "output_files": [],
+            }
+
+    return {
+        "command_executed": "\n".join(command_executed),
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files,
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-irisfgm/app/bioconductor-irisfgm_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-irisfgm/app/bioconductor-irisfgm_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_irisfgm'
+
+
+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-irisfgm/docker-compose.yml

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