Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_anarci/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 anarci via conda (e.g., from bioconda)
+RUN conda install -c bioconda anarci -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/anarci_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/anarci_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/anarci_server.py"]
+        

Biomni/mcp_generated/mcp_anarci/app/anarci_server.py

@@ -0,0 +1,191 @@
+from pathlib import Path
+import subprocess
+from typing import Optional, List, Union
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_anarci'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_anarci(
+    sequence: Optional[str] = None,
+    input_file: Optional[str] = None,
+    output_file: Optional[str] = None,
+    scheme: str = "imgt",
+    restrict: Optional[str] = None,
+    species: Optional[str] = None,
+    csv: bool = False,
+    ncpu: int = 1,
+    bit_score_threshold: float = 80.0,
+    assign_germline: bool = False,
+    name: Optional[str] = None,
+    verbose: bool = False
+):
+    """
+    ANARCI: Antibody Numbering and Antigen Receptor ClassIfication.
+    Numbers amino-acid sequences of antibody and T-cell receptor variable domains.
+
+    Args:
+        sequence: A single amino acid sequence to number.
+        input_file: Path to a FASTA file containing sequences to number.
+        output_file: Path to the output file. If not provided, results are printed to stdout.
+        scheme: Numbering scheme to use. Options: 'imgt', 'kabat', 'chothia', 'martin', 'aho'. (Default: 'imgt')
+        restrict: Restrict numbering to specific domain types. Options: 'ig' (immunoglobulins), 'tr' (T-cell receptors).
+        species: Restrict germline search to specific species (e.g., 'human', 'mouse', 'rat', 'rabbit', 'rhesus', 'pig', 'alpaca').
+        csv: If True, output results in CSV format (horizontal). If False, uses plain text (vertical).
+        ncpu: Number of CPUs to use for parallel processing. (Default: 1)
+        bit_score_threshold: HMMER bit score threshold for domain identification. (Default: 80.0)
+        assign_germline: If True, assign germline species and gene information.
+        name: Name to assign to the single sequence (used with 'sequence' parameter).
+        verbose: If True, produce verbose output.
+    """
+    
+    # Input validation
+    if not sequence and not input_file:
+        raise ValueError("Either 'sequence' or 'input_file' must be provided.")
+    
+    if sequence and input_file:
+        raise ValueError("Provide either 'sequence' or 'input_file', not both.")
+
+    valid_schemes = ["imgt", "kabat", "chothia", "martin", "aho"]
+    if scheme.lower() not in valid_schemes:
+        raise ValueError(f"Invalid scheme '{scheme}'. Must be one of {valid_schemes}")
+
+    if restrict and restrict.lower() not in ["ig", "tr"]:
+        raise ValueError("Restrict must be either 'ig' or 'tr'.")
+
+    # Build command
+    # The CLI tool is typically named 'ANARCI' (uppercase)
+    cmd = ["ANARCI"]
+
+    if sequence:
+        cmd.extend(["--sequence", sequence])
+        if name:
+            cmd.extend(["--name", name])
+    
+    if input_file:
+        input_path = Path(input_file)
+        if not input_path.exists():
+            raise FileNotFoundError(f"Input file not found: {input_file}")
+        cmd.extend(["--input", str(input_path)])
+
+    if output_file:
+        cmd.extend(["--outfile", output_file])
+
+    cmd.extend(["--scheme", scheme.lower()])
+    
+    if restrict:
+        cmd.extend(["--restrict", restrict.lower()])
+    
+    if species:
+        cmd.extend(["--species", species.lower()])
+    
+    if csv:
+        cmd.append("--csv")
+    
+    if assign_germline:
+        cmd.append("--assign_germline")
+    
+    if verbose:
+        cmd.append("--verbose")
+
+    cmd.extend(["--ncpu", str(ncpu)])
+    cmd.extend(["--bit_score_threshold", str(bit_score_threshold)])
+
+    try:
+        # Execute the tool
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        output_files = []
+        if output_file:
+            # ANARCI often appends suffixes depending on the format
+            # e.g., .csv or .txt
+            actual_output = Path(output_file)
+            if actual_output.exists():
+                output_files.append(str(actual_output))
+            else:
+                # Check for common suffixes if the exact file isn't found
+                for suffix in [".csv", ".txt"]:
+                    p = Path(f"{output_file}{suffix}")
+                    if p.exists():
+                        output_files.append(str(p))
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files
+        }
+
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"ANARCI failed with return code {e.returncode}"
+        }
+    except Exception as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e)
+        }
+
+@mcp.tool()
+def list_anarci_species():
+    """
+    Returns a list of species supported by ANARCI for germline alignment.
+    Note: This is an informational tool based on ANARCI's standard database.
+    """
+    # Standard species supported by ANARCI
+    species_list = [
+        "human", "mouse", "rat", "rabbit", "rhesus", "pig", "alpaca", 
+        "dog", "chicken", "cow", "horse", "monkey", "macaque"
+    ]
+    
+    return {
+        "supported_species": species_list,
+        "note": "Availability may depend on the specific ANARCI version and installed HMM databases."
+    }
+
+@mcp.tool()
+def get_anarci_version():
+    """
+    Retrieves the version information for the installed ANARCI tool.
+    """
+    try:
+        # ANARCI doesn't always have a simple --version flag in older versions,
+        # but we can try to run it to see the help header or use pip/conda info.
+        # Most modern versions support --version.
+        result = subprocess.run(
+            ["ANARCI", "--version"],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        
+        # If --version fails, try to get it from the help output
+        if result.returncode != 0:
+            result = subprocess.run(
+                ["ANARCI", "--help"],
+                capture_output=True,
+                text=True,
+                check=False
+            )
+            
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr
+        }
+    except Exception as e:
+        return {
+            "error": f"Could not determine ANARCI version: {str(e)}"
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_anarci/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_anarci/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-cellmigration/app/bioconductor-cellmigration_server.py

@@ -0,0 +1,214 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(func):
+            return func
+        return decorator
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_cellmigration'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_cellmigration_analysis(
+    input_file: Path,
+    output_dir: Path,
+    delta_t: float = 1.0,
+    x_microns: float = 1.0,
+    y_microns: float = 1.0,
+    plot_format: str = "png",
+    plot_width: int = 7,
+    plot_height: int = 7,
+    plot_dpi: int = 300,
+    generate_displacement_plot: bool = True,
+    generate_speed_plot: bool = True,
+    generate_rose_plot: bool = True,
+    generate_angle_plot: bool = True,
+    generate_straighness_plot: bool = True,
+    generate_persistence_ratio_plot: bool = True,
+    generate_displacement_ratio_plot: bool = True,
+    generate_persistence_plot: bool = True,
+    generate_cumulative_plot: bool = True,
+    generate_cumulative_hist_plot: bool = True,
+    generate_single_cell_plot: bool = True,
+    generate_all_cells_plot: bool = True,
+) -> Dict[str, Any]:
+    """
+    Performs a complete cell migration analysis using the Bioconductor cellmigration package.
+
+    This tool reads ImageJ trajectory data, performs a comprehensive analysis,
+    and generates a variety of plots and a summary statistics CSV file.
+    It requires R and the 'cellmigration' Bioconductor package to be installed.
+
+    Args:
+        input_file: Path to the input data file from ImageJ's manual tracking plugin.
+        output_dir: Path to the directory where output files will be saved.
+        delta_t: Time interval between frames (dt).
+        x_microns: Pixel to micron conversion factor for the x-axis (x.scale).
+        y_microns: Pixel to micron conversion factor for the y-axis (y.scale).
+        plot_format: The format for the output plots ('png' or 'pdf').
+        plot_width: Width of the plots in inches.
+        plot_height: Height of the plots in inches.
+        plot_dpi: Resolution for PNG plots in dots per inch.
+        generate_displacement_plot: Generate a displacement plot.
+        generate_speed_plot: Generate a speed plot.
+        generate_rose_plot: Generate a rose plot of cell turning angles.
+        generate_angle_plot: Generate a plot of cell turning angles.
+        generate_straighness_plot: Generate a plot of cell trajectory straightness.
+        generate_persistence_ratio_plot: Generate a persistence ratio plot.
+        generate_displacement_ratio_plot: Generate a displacement ratio plot.
+        generate_persistence_plot: Generate a persistence time plot.
+        generate_cumulative_plot: Generate a cumulative plot.
+        generate_cumulative_hist_plot: Generate a cumulative plot with a histogram.
+        generate_single_cell_plot: Generate a plot for each single cell trajectory.
+        generate_all_cells_plot: Generate a plot showing all cell trajectories.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    if delta_t <= 0:
+        raise ValueError("delta_t must be a positive number.")
+    if x_microns <= 0 or y_microns <= 0:
+        raise ValueError("x_microns and y_microns must be positive numbers.")
+    if plot_format not in ["png", "pdf"]:
+        raise ValueError("plot_format must be either 'png' or 'pdf'.")
+    if plot_width <= 0 or plot_height <= 0 or plot_dpi <= 0:
+        raise ValueError("Plot dimensions and DPI must be positive integers.")
+
+    # --- File Path Handling ---
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        raise OSError(f"Could not create output directory: {output_dir}. Error: {e}")
+
+    # --- R Script Generation ---
+    # Using absolute paths to avoid issues with working directories
+    abs_input_file = input_file.resolve()
+    abs_output_dir = output_dir.resolve()
+
+    # Helper function to generate R plotting code
+    def get_plot_code(plot_name: str, plot_function: str) -> str:
+        return f"""
+    cat("Generating {plot_name} plot...\\n")
+    if (plot_format == "png") {{
+        png(file.path("{abs_output_dir}", "{plot_name}.png"), width=plot_width, height=plot_height, units="in", res=plot_dpi)
+    }} else {{
+        pdf(file.path("{abs_output_dir}", "{plot_name}.pdf"), width=plot_width, height=plot_height)
+    }}
+    {plot_function}(analysis_results)
+    dev.off()
+    """
+
+    r_script_content = f"""
+    # Load the library, with error handling
+    if (!requireNamespace("cellmigration", quietly = TRUE)) {{
+        stop("The 'cellmigration' package is not installed. Please install it from Bioconductor.", call. = FALSE)
+    }}
+    library(cellmigration)
+
+    # --- Parameters ---
+    inputFile <- "{abs_input_file}"
+    outputDir <- "{abs_output_dir}"
+    dt <- {delta_t}
+    x_scale <- {x_microns}
+    y_scale <- {y_microns}
+    plot_format <- "{plot_format}"
+    plot_width <- {plot_width}
+    plot_height <- {plot_height}
+    plot_dpi <- {plot_dpi}
+
+    # --- Main Analysis ---
+    cat("Reading ImageJ data from:", inputFile, "\\n")
+    ij_data <- read.ijdata(inputFile, dt=dt, x.scale=x_scale, y.scale=y_scale)
+
+    cat("Analyzing trajectories...\\n")
+    analysis_results <- analyze.trajectories(ij_data)
+
+    cat("Saving analysis summary...\\n")
+    write.csv(analysis_results$results, file=file.path(outputDir, "analysis_summary.csv"), row.names = FALSE)
+
+    # --- Plotting ---
+    if ({str(generate_displacement_plot).upper()}) {{{get_plot_code('displacement', 'plot.displacement')}}}
+    if ({str(generate_speed_plot).upper()}) {{{get_plot_code('speed', 'plot.speed')}}}
+    if ({str(generate_rose_plot).upper()}) {{{get_plot_code('rose', 'plot.rose')}}}
+    if ({str(generate_angle_plot).upper()}) {{{get_plot_code('angle', 'plot.angle')}}}
+    if ({str(generate_straighness_plot).upper()}) {{{get_plot_code('straighness', 'plot.straighness')}}}
+    if ({str(generate_persistence_ratio_plot).upper()}) {{{get_plot_code('persistence_ratio', 'plot.persistence.ratio')}}}
+    if ({str(generate_displacement_ratio_plot).upper()}) {{{get_plot_code('displacement_ratio', 'plot.displacement.ratio')}}}
+    if ({str(generate_persistence_plot).upper()}) {{{get_plot_code('persistence', 'plot.persistence')}}}
+    if ({str(generate_cumulative_plot).upper()}) {{{get_plot_code('cumulative', 'plot.cummulative.plot')}}}
+    if ({str(generate_cumulative_hist_plot).upper()}) {{{get_plot_code('cumulative_hist', 'plot.cummulative.plot.and.hist')}}}
+    if ({str(generate_single_cell_plot).upper()}) {{{get_plot_code('single_cell', 'plot.single.cell')}}}
+    if ({str(generate_all_cells_plot).upper()}) {{{get_plot_code('all_cells', 'plot.all.cells')}}}
+
+    cat("Analysis complete.\\n")
+    """
+
+    # --- Subprocess Execution ---
+    command = []
+    stdout_str, stderr_str = "", ""
+    output_files = []
+
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        command = ["Rscript", r_script_path]
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+        # Collect output files
+        output_files = [str(p) for p in abs_output_dir.glob('*')]
+
+    except FileNotFoundError:
+        stderr_str = "Error: 'Rscript' command not found. Please ensure R is installed and in your system's PATH."
+        return {
+            "command_executed": " ".join(command),
+            "stdout": stdout_str,
+            "stderr": stderr_str,
+            "output_files": []
+        }
+    except subprocess.CalledProcessError as e:
+        stderr_str = f"Error executing R script. Return code: {e.returncode}\n"
+        stderr_str += f"STDOUT:\n{e.stdout}\n"
+        stderr_str += f"STDERR:\n{e.stderr}\n"
+        return {
+            "command_executed": " ".join(command),
+            "stdout": e.stdout,
+            "stderr": stderr_str,
+            "output_files": []
+        }
+    finally:
+        # Clean up the temporary R script
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+    # --- Structured Result Return ---
+    return {
+        "command_executed": " ".join(command),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": output_files
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-cellmigration/app/bioconductor-cellmigration_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-cellmigration/app/bioconductor-cellmigration_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_cellmigration'
+
+
+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-cellmigration/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-cellmigration/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-geneplotter/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-glmgampoi/app/bioconductor-glmgampoi_server.py

@@ -0,0 +1,270 @@
+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_glmgampoi'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def fit_glm_gp(
+    data_path: str,
+    output_rds: str,
+    design_formula: str = "~1",
+    col_data_path: Optional[str] = None,
+    size_factors: str = "normed_sum",
+    overdispersion_shrinkage: bool = True,
+    on_disk: bool = False,
+) -> Dict[str, Any]:
+    """
+    Fit a Gamma-Poisson Generalized Linear Model (GLM) to count data.
+    Designed for large datasets like single-cell RNA-seq.
+
+    Args:
+        data_path: Path to the input count matrix (CSV or TSV). Rows are genes, columns are samples.
+        output_rds: Path where the fitted model object (RDS format) will be saved.
+        design_formula: R-style formula string (e.g., '~ condition').
+        col_data_path: Optional path to sample metadata (CSV or TSV). Rows must match columns in data_path.
+        size_factors: Method for normalization. Options: 'normed_sum', 'poscounts', 'median', or 'none'.
+        overdispersion_shrinkage: Whether to shrink overdispersion estimates towards a global trend.
+        on_disk: If True, uses HDF5-backed matrices to minimize memory usage for very large datasets.
+    """
+    # Input validation
+    input_p = Path(data_path)
+    if not input_p.exists():
+        raise FileNotFoundError(f"Input data file not found: {data_path}")
+    
+    output_p = Path(output_rds)
+    output_p.parent.mkdir(parents=True, exist_ok=True)
+
+    col_data_arg = "NULL"
+    if col_data_path:
+        col_p = Path(col_data_path)
+        if not col_p.exists():
+            raise FileNotFoundError(f"Metadata file not found: {col_data_path}")
+        col_data_arg = f"read_data('{col_data_path}')"
+
+    # Map size_factors string to R logic
+    sf_val = f"'{size_factors}'"
+    if size_factors.lower() == "none":
+        sf_val = "FALSE"
+
+    # Construct R script
+    r_script = f"""
+    library(glmGamPoi)
+    
+    read_data <- function(path) {{
+        if (grepl('\\\\.tsv$', path, ignore.case = TRUE)) {{
+            return(read.delim(path, row.names = 1, check.names = FALSE))
+        }} else {{
+            return(read.csv(path, row.names = 1, check.names = FALSE))
+        }}
+    }}
+
+    counts <- as.matrix(read_data('{data_path}'))
+    col_data <- {col_data_arg}
+    
+    fit <- glm_gp(
+        data = counts,
+        design = as.formula('{design_formula}'),
+        col_data = col_data,
+        size_factors = {sf_val},
+        overdispersion_shrinkage = {str(overdispersion_shrinkage).upper()},
+        on_disk = {str(on_disk).upper()}
+    )
+    
+    saveRDS(fit, '{output_rds}')
+    """
+
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"glm_gp on {data_path}",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [output_rds]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+@mcp.tool()
+def test_differential_expression(
+    fit_rds_path: str,
+    output_csv: str,
+    contrast: Optional[str] = None,
+    reduced_design: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Perform differential expression (DE) testing using a fitted glmGamPoi model.
+
+    Args:
+        fit_rds_path: Path to the RDS file generated by fit_glm_gp.
+        output_csv: Path where the DE results (CSV) will be saved.
+        contrast: String specifying the contrast to test (e.g., 'condition_B - condition_A').
+        reduced_design: Optional R-style formula for a reduced model to perform a Likelihood Ratio Test.
+    """
+    fit_p = Path(fit_rds_path)
+    if not fit_p.exists():
+        raise FileNotFoundError(f"Fitted model file not found: {fit_rds_path}")
+
+    output_p = Path(output_csv)
+    output_p.parent.mkdir(parents=True, exist_ok=True)
+
+    contrast_arg = "NULL"
+    if contrast:
+        # If it looks like a simple string, wrap in quotes; if it's complex, R handles it
+        contrast_arg = f"'{contrast}'"
+
+    reduced_arg = "NULL"
+    if reduced_design:
+        reduced_arg = f"as.formula('{reduced_design}')"
+
+    r_script = f"""
+    library(glmGamPoi)
+    fit <- readRDS('{fit_rds_path}')
+    res <- test_de(
+        fit, 
+        contrast = {contrast_arg}, 
+        reduced_design = {reduced_arg}
+    )
+    write.csv(res, '{output_csv}', row.names = TRUE)
+    """
+
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"test_de on {fit_rds_path}",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [output_csv]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+@mcp.tool()
+def get_overdispersion_estimates(
+    fit_rds_path: str,
+    output_csv: str
+) -> Dict[str, Any]:
+    """
+    Extract overdispersion estimates for each gene from a fitted glmGamPoi model.
+
+    Args:
+        fit_rds_path: Path to the RDS file generated by fit_glm_gp.
+        output_csv: Path where the overdispersion estimates (CSV) will be saved.
+    """
+    fit_p = Path(fit_rds_path)
+    if not fit_p.exists():
+        raise FileNotFoundError(f"Fitted model file not found: {fit_rds_path}")
+
+    r_script = f"""
+    library(glmGamPoi)
+    fit <- readRDS('{fit_rds_path}')
+    # Extract overdispersion and gene names
+    df <- data.frame(
+        gene = rownames(fit$Beta),
+        overdispersion = fit$overdispersions
+    )
+    write.csv(df, '{output_csv}', row.names = FALSE)
+    """
+
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"Extract overdispersion from {fit_rds_path}",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [output_csv]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+@mcp.tool()
+def predict_glm_gp(
+    fit_rds_path: str,
+    output_csv: str,
+    newdata_path: Optional[str] = None,
+    type: str = "link"
+) -> Dict[str, Any]:
+    """
+    Predict values (e.g., log-counts or counts) from a fitted glmGamPoi model.
+
+    Args:
+        fit_rds_path: Path to the RDS file generated by fit_glm_gp.
+        output_csv: Path where the predictions (CSV) will be saved.
+        newdata_path: Optional path to new sample metadata (CSV/TSV). If NULL, uses original data.
+        type: Type of prediction. 'link' (log-scale) or 'response' (original count scale).
+    """
+    fit_p = Path(fit_rds_path)
+    if not fit_p.exists():
+        raise FileNotFoundError(f"Fitted model file not found: {fit_rds_path}")
+
+    newdata_arg = "NULL"
+    if newdata_path:
+        if not Path(newdata_path).exists():
+            raise FileNotFoundError(f"New data file not found: {newdata_path}")
+        newdata_arg = f"read.csv('{newdata_path}', row.names = 1)"
+
+    r_script = f"""
+    library(glmGamPoi)
+    fit <- readRDS('{fit_rds_path}')
+    newdata <- {newdata_arg}
+    preds <- predict(fit, newdata = newdata, type = '{type}')
+    write.csv(preds, '{output_csv}')
+    """
+
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"predict on {fit_rds_path}",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [output_csv]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-glmgampoi/app/bioconductor-glmgampoi_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-glmgampoi/app/bioconductor-glmgampoi_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_glmgampoi'
+
+
+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-glmgampoi/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-glmgampoi/environment.yaml

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

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

Biomni/mcp_generated/mcp_bioconductor-keggrest/app/bioconductor-keggrest_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-keggrest/app/bioconductor-keggrest_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_keggrest'
+
+
+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-keggrest/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-keggrest/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-scran/app/bioconductor-scran_server.py

@@ -0,0 +1,115 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List
+
+# MCP decorator is omitted as per instructions.
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_scran'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+
+def scran_normalize(
+    input_sce_rds: Path,
+    output_sce_rds: Path,
+    clusters_csv: Optional[Path] = None,
+    min_mean: float = 0.1,
+    bpparam_workers: int = 1,
+) -> dict:
+    """
+    Performs normalization of single-cell RNA-seq data using scran's deconvolution method.
+
+    This tool serves as a wrapper for a hypothetical R script that utilizes the
+    'scran' Bioconductor package. 'scran' itself is an R library without a native
+    command-line interface. This function assumes an R script ('run_scran.R')
+    exists that can take command-line arguments to perform normalization.
+
+    Args:
+        input_sce_rds (Path): Path to the input SingleCellExperiment object saved as an RDS file.
+                              This object should contain the raw count matrix.
+        output_sce_rds (Path): Path to save the output SingleCellExperiment object (in RDS format)
+                               with the calculated size factors added.
+        clusters_csv (Optional[Path]): Path to a CSV file containing cell cluster assignments.
+                                       If provided, normalization is performed per cluster.
+                                       The CSV should have two columns: cell_barcode, cluster_id.
+        min_mean (float): The minimum mean expression for a gene to be used for normalization.
+                          Corresponds to the 'min.mean' parameter in scran's computeSumFactors.
+                          Defaults to 0.1.
+        bpparam_workers (int): Number of worker processes to use for parallel computation.
+                               Defaults to 1 (no parallelization).
+
+    Returns:
+        dict: A dictionary containing the executed command, stdout, stderr, and a list
+              of output files.
+    """
+    # --- Input Validation ---
+    if not input_sce_rds.is_file():
+        raise FileNotFoundError(f"Input RDS file not found: {input_sce_rds}")
+    if clusters_csv and not clusters_csv.is_file():
+        raise FileNotFoundError(f"Clusters CSV file not found: {clusters_csv}")
+    if min_mean < 0:
+        raise ValueError("min_mean must be a non-negative number.")
+    if bpparam_workers < 1:
+        raise ValueError("bpparam_workers must be at least 1.")
+
+    # --- Command Construction ---
+    # This assumes a hypothetical R script 'run_scran.R' that we have created
+    # to expose scran functionality to the command line.
+    cmd = [
+        "Rscript",
+        "run_scran.R",
+        "normalize",
+        "--input",
+        str(input_sce_rds),
+        "--output",
+        str(output_sce_rds),
+        "--min-mean",
+        str(min_mean),
+        "--workers",
+        str(bpparam_workers),
+    ]
+
+    if clusters_csv:
+        cmd.extend(["--clusters", str(clusters_csv)])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    try:
+        # In a real scenario, the R script would need to be in the PATH or specified with its full path.
+        # For this example, we assume it's available.
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = result.stdout
+        stderr = result.stderr
+    except FileNotFoundError:
+        # This error would be raised if 'Rscript' or 'run_scran.R' is not found.
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: 'Rscript' or the wrapper 'run_scran.R' not found. Please ensure R and the necessary wrapper script are in the system's PATH.",
+            "output_files": [],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": [],
+        }
+
+    # --- Return Structured Output ---
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [str(output_sce_rds)],
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-scran/app/bioconductor-scran_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-scran/app/bioconductor-scran_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_scran'
+
+
+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-scran/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-scran/requirements.txt

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

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

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

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

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

Biomni/mcp_generated/mcp_bioconductor-spari/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-spatialcpie/app/bioconductor-spatialcpie_server.py

@@ -0,0 +1,158 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# Assume @mcp.tool is defined elsewhere or imported.
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_spatialcpie'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_rscript(
+    script_file: Optional[Path] = None,
+    expressions: Optional[List[str]] = None,
+    script_args: Optional[List[str]] = None,
+    help_flag: bool = False,
+    version_flag: bool = False,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+    save_workspace: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    restore_workspace: bool = False,
+    vanilla: bool = False,
+) -> Dict[str, Any]:
+    """
+    Executes an R script or R expressions using the Rscript command-line tool.
+
+    This tool provides an interface to the Rscript command, allowing users to run
+    R code from the command line. It supports running either a specified R script
+    file or direct R expressions. Various options are available to control the
+    R session environment, such as package loading, workspace saving/restoring,
+    and environment file handling.
+
+    Args:
+        script_file: Path to an R script file to be executed. Mutually exclusive with 'expressions'.
+        expressions: A list of R expressions (strings) to be executed. Mutually exclusive with 'script_file'.
+        script_args: A list of arguments (strings) to be passed to the R script itself.
+        help_flag: If True, print usage information and exit.
+        version_flag: If True, print Rscript version information and exit.
+        verbose: If True, print information on progress during execution.
+        default_packages: A comma-separated list of package names to load by default, or 'NULL'.
+        save_workspace: If True, save the workspace at the end of the session.
+        no_environ: If True, do not read the site and user environment files.
+        no_site_file: If True, do not read the site-wide Rprofile.
+        no_init_file: If True, do not read the user R profile.
+        restore_workspace: If True, restore previously saved objects at startup.
+        vanilla: If True, combine --no-save, --no-restore, --no-site-file,
+                 --no-init-file, and --no-environ.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any
+        output files (though Rscript itself doesn't typically produce named
+        output files directly from the command line).
+    """
+    # Input validation
+    if script_file and expressions:
+        raise ValueError("Cannot specify both 'script_file' and 'expressions'. Please choose one.")
+    if not script_file and not expressions and not help_flag and not version_flag:
+        raise ValueError(
+            "Either 'script_file' or 'expressions' must be provided, "
+            "unless '--help' or '--version' is requested."
+        )
+
+    if script_file:
+        if not script_file.exists():
+            raise FileNotFoundError(f"R script file not found: {script_file}")
+        if not script_file.is_file():
+            raise ValueError(f"Provided path is not a file: {script_file}")
+
+    command = ["Rscript"]
+
+    # Add Rscript options
+    if help_flag:
+        command.append("--help")
+    if version_flag:
+        command.append("--version")
+    if verbose:
+        command.append("--verbose")
+    if default_packages is not None:
+        command.append(f"--default-packages={default_packages}")
+    if save_workspace:
+        command.append("--save")
+    if no_environ:
+        command.append("--no-environ")
+    if no_site_file:
+        command.append("--no-site-file")
+    if no_init_file:
+        command.append("--no-init-file")
+    if restore_workspace:
+        command.append("--restore")
+    if vanilla:
+        command.append("--vanilla")
+
+    # Add expressions or script file
+    if expressions:
+        for expr in expressions:
+            command.extend(["-e", expr])
+    elif script_file:
+        command.append(str(script_file))
+
+    # Add arguments to the R script itself
+    if script_args:
+        command.extend(script_args)
+
+    command_executed = " ".join(command)
+    stdout = ""
+    stderr = ""
+    output_files: List[Path] = []
+
+    try:
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Rscript execution failed with exit code {e.returncode}: {e}",
+            "returncode": e.returncode,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Rscript command not found. Please ensure R is installed and in your system's PATH.",
+            "error": "Rscript executable not found.",
+            "returncode": 127,
+            "output_files": output_files,
+        }
+    except Exception as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": stdout,
+            "stderr": stderr,
+            "error": f"An unexpected error occurred: {e}",
+            "returncode": 1, # Generic error code
+            "output_files": output_files,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files,
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-spatialcpie/app/bioconductor-spatialcpie_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-spatialcpie/app/bioconductor-spatialcpie_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_spatialcpie'
+
+
+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-spatialcpie/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-spatialcpie/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-spoon/app/bioconductor-spoon_server.py

@@ -0,0 +1,160 @@
+import subprocess
+import tempfile
+import shutil
+from pathlib import Path
+from typing import List
+
+# MCP decorator would be here in a real implementation
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_spoon'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_spoon(
+    input_spe: Path,
+    output_spe: Path,
+    assay_name: str = "counts",
+    n_threads: int = 1,
+) -> dict:
+    """
+    Runs the spoon workflow to address the mean-variance relationship in spatial transcriptomics data.
+
+    This tool takes a SpatialExperiment object (in .rds format), computes precision weights
+    and deviance residuals using Empirical Bayes techniques, and adds them to the object.
+    The output is the modified SpatialExperiment object, saved to a new .rds file.
+
+    Args:
+        input_spe: Path to the input SpatialExperiment object saved as an RDS file.
+        output_spe: Path to save the output SpatialExperiment object as an RDS file.
+        assay_name: The name of the assay to use from the input object.
+        n_threads: The number of threads to use for parallel processing.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list of output files.
+    """
+    # 1. Input Validation
+    if not input_spe.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_spe}")
+    if n_threads < 1:
+        raise ValueError("n_threads must be a positive integer.")
+    
+    # Ensure output directory exists
+    output_spe.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. R Script Generation
+    # This R script acts as a command-line wrapper for the spoon::run_spoon function.
+    r_script_content = f"""
+    # Ensure required R packages are installed and load them
+    if (!requireNamespace("optparse", quietly = TRUE)) stop("R package 'optparse' is required.")
+    if (!requireNamespace("spoon", quietly = TRUE)) stop("R package 'spoon' is required.")
+    if (!requireNamespace("SpatialExperiment", quietly = TRUE)) stop("R package 'SpatialExperiment' is required.")
+    if (!requireNamespace("BiocParallel", quietly = TRUE)) stop("R package 'BiocParallel' is required.")
+
+    library(optparse)
+    library(spoon)
+    library(SpatialExperiment)
+    library(BiocParallel)
+
+    # Define and parse command-line options
+    option_list <- list(
+      make_option(c("-i", "--input"), type="character", default=NULL,
+                  help="Input SpatialExperiment RDS file", metavar="character"),
+      make_option(c("-o", "--output"), type="character", default=NULL,
+                  help="Output SpatialExperiment RDS file", metavar="character"),
+      make_option(c("-a", "--assay_name"), type="character", default="counts",
+                  help="Name of the assay to use [default= %default]", metavar="character"),
+      make_option(c("-n", "--n_threads"), type="integer", default=1,
+                  help="Number of threads for parallel processing [default= %default]", metavar="integer")
+    )
+    opt_parser <- OptionParser(option_list=option_list)
+    opt <- parse_args(opt_parser)
+
+    # Validate required arguments
+    if (is.null(opt$input) || is.null(opt$output)){{
+      print_help(opt_parser)
+      stop("Input and output files must be supplied.", call.=FALSE)
+    }}
+
+    # Set up parallel processing backend
+    if (opt$n_threads > 1) {{
+        bpparam <- MulticoreParam(workers = opt$n_threads)
+    }} else {{
+        bpparam <- SerialParam()
+    }}
+
+    # Main workflow
+    message("Reading input SpatialExperiment object from: ", opt$input)
+    spe <- readRDS(opt$input)
+
+    message("Running spoon workflow with assay '", opt$assay_name, "' and ", opt$n_threads, " thread(s)...")
+    spe_processed <- tryCatch({{
+        run_spoon(
+            spe,
+            assay_name = opt$assay_name,
+            BPPARAM = bpparam
+        )
+    }}, error = function(e) {{
+        stop("Error during spoon::run_spoon execution: ", e$message)
+    }})
+    message("Spoon workflow completed successfully.")
+
+    message("Saving processed SpatialExperiment object to: ", opt$output)
+    saveRDS(spe_processed, file = opt$output)
+
+    message("Done.")
+    """
+
+    # 3. Subprocess Execution
+    # Use a temporary file for the R script
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as tmp_r_script:
+        tmp_r_script.write(r_script_content)
+        r_script_path = Path(tmp_r_script.name)
+
+    # Check for Rscript executable
+    if not shutil.which("Rscript"):
+        r_script_path.unlink()
+        raise RuntimeError("Rscript executable not found in PATH. R is required to run this tool.")
+
+    cmd = [
+        "Rscript",
+        str(r_script_path),
+        "--input", str(input_spe),
+        "--output", str(output_spe),
+        "--assay_name", assay_name,
+        "--n_threads", str(n_threads),
+    ]
+
+    command_executed = " ".join(cmd)
+    
+    try:
+        process = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+    finally:
+        # Ensure the temporary script is always cleaned up
+        if r_script_path.exists():
+            r_script_path.unlink()
+
+    # 4. Structured Result Return
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [str(output_spe)]
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-spoon/environment.yaml

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

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

Biomni/mcp_generated/mcp_bioconductor-statial/app/bioconductor-statial_server.py

@@ -0,0 +1,321 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Union
+import textwrap
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_statial'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def statial_calc_interactions(
+    input_rds: str,
+    output_rds: str,
+    image_col: str,
+    cell_type_col: str,
+    x_col: str = "x",
+    y_col: str = "y",
+    method: str = "radius",
+    radius: float = 100.0,
+    n_neighbors: int = 10,
+):
+    """
+    Calculates the localization of cell types (interactions) for each image in a SingleCellExperiment object.
+    
+    Args:
+        input_rds: Path to the input SingleCellExperiment object saved as an RDS file.
+        output_rds: Path where the resulting interactions data frame will be saved as an RDS file.
+        image_col: Column name in colData representing unique image identifiers.
+        cell_type_col: Column name in colData representing cell types.
+        x_col: Column name for the X coordinate.
+        y_col: Column name for the Y coordinate.
+        method: Method to define proximity ('radius' or 'knn').
+        radius: The radius to use if method is 'radius'.
+        n_neighbors: The number of neighbors to use if method is 'knn'.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} does not exist."}
+    
+    if method not in ["radius", "knn"]:
+        return {"error": "Method must be either 'radius' or 'knn'."}
+
+    r_script = textwrap.dedent(f"""
+        library(statial)
+        sce <- readRDS('{input_path}')
+        interactions <- calcInteractions(
+            sce, 
+            group = '{image_col}', 
+            cellType = '{cell_type_col}', 
+            spatialCoords = c('{x_col}', '{y_col}'),
+            method = '{method}',
+            radius = {radius},
+            n_neighbors = {n_neighbors}
+        )
+        saveRDS(interactions, '{output_path}')
+    """)
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"statial::calcInteractions on {input_rds}",
+            "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
+        }
+
+@mcp.tool()
+def statial_get_spatial_context(
+    input_rds: str,
+    output_rds: str,
+    cell_type_col: str,
+    x_col: str = "x",
+    y_col: str = "y",
+    r: float = 100.0,
+    k: int = 3,
+    image_col: Optional[str] = None
+):
+    """
+    Defines spatial contexts by clustering cell type densities across the tissue.
+
+    Args:
+        input_rds: Path to the input SingleCellExperiment object (RDS).
+        output_rds: Path to save the SCE object with spatial context assignments (RDS).
+        cell_type_col: Column name in colData representing cell types.
+        x_col: Column name for the X coordinate.
+        y_col: Column name for the Y coordinate.
+        r: Radius for calculating cell density.
+        k: Number of spatial contexts (clusters) to identify.
+        image_col: Optional column name for image IDs if processing multiple images.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} does not exist."}
+
+    image_arg = f"'{image_col}'" if image_col else "NULL"
+
+    r_script = textwrap.dedent(f"""
+        library(statial)
+        sce <- readRDS('{input_path}')
+        sce <- getSpatialContext(
+            sce, 
+            cellType = '{cell_type_col}', 
+            spatialCoords = c('{x_col}', '{y_col}'),
+            r = {r},
+            k = {k},
+            group = {image_arg}
+        )
+        saveRDS(sce, '{output_path}')
+    """)
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"statial::getSpatialContext on {input_rds}",
+            "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
+        }
+
+@mcp.tool()
+def statial_bivariate_test(
+    input_rds: str,
+    output_csv: str,
+    image_col: str,
+    cell_type_col: str,
+    spatial_context_col: str,
+    x_col: str = "x",
+    y_col: str = "y"
+):
+    """
+    Performs statistical testing to identify interactions that change significantly across spatial contexts.
+
+    Args:
+        input_rds: Path to the input SingleCellExperiment object (RDS).
+        output_csv: Path to save the statistical test results (CSV).
+        image_col: Column name for image IDs.
+        cell_type_col: Column name for cell types.
+        spatial_context_col: Column name for the spatial context (calculated via getSpatialContext).
+        x_col: Column name for the X coordinate.
+        y_col: Column name for the Y coordinate.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_csv)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} does not exist."}
+
+    r_script = textwrap.dedent(f"""
+        library(statial)
+        sce <- readRDS('{input_path}')
+        results <- bivariateTest(
+            sce,
+            group = '{image_col}',
+            cellType = '{cell_type_col}',
+            spatialContext = '{spatial_context_col}',
+            spatialCoords = c('{x_col}', '{y_col}')
+        )
+        write.csv(results, '{output_path}', row.names = FALSE)
+    """)
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"statial::bivariateTest on {input_rds}",
+            "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
+        }
+
+@mcp.tool()
+def statial_impute_interactions(
+    input_rds: str,
+    output_rds: str,
+    image_col: str,
+    cell_type_col: str,
+    min_cells: int = 5
+):
+    """
+    Imputes interaction values for images where certain cell types might be missing or rare.
+
+    Args:
+        input_rds: Path to the interactions data frame (RDS) generated by calcInteractions.
+        output_rds: Path to save the imputed interactions data frame (RDS).
+        image_col: Column name for image IDs.
+        cell_type_col: Column name for cell types.
+        min_cells: Minimum number of cells required to avoid imputation.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} does not exist."}
+
+    r_script = textwrap.dedent(f"""
+        library(statial)
+        interactions <- readRDS('{input_path}')
+        imputed <- imputeInteractions(
+            interactions,
+            group = '{image_col}',
+            cellType = '{cell_type_col}',
+            minCells = {min_cells}
+        )
+        saveRDS(imputed, '{output_path}')
+    """)
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"statial::imputeInteractions on {input_rds}",
+            "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
+        }
+
+@mcp.tool()
+def statial_get_interactions(
+    input_rds: str,
+    output_csv: str,
+    image_id: Optional[str] = None
+):
+    """
+    Extracts interaction information from a SingleCellExperiment object or interaction data frame.
+
+    Args:
+        input_rds: Path to the input RDS file.
+        output_csv: Path to save the extracted interactions (CSV).
+        image_id: Optional specific image ID to extract interactions for.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_csv)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} does not exist."}
+
+    image_filter = f"subset(interact, group == '{image_id}')" if image_id else "interact"
+
+    r_script = textwrap.dedent(f"""
+        library(statial)
+        interact <- readRDS('{input_path}')
+        # If input is SCE, extract interactions if they exist
+        if(is(interact, 'SingleCellExperiment')) {{
+            # Assuming interactions were stored in metadata or colData by user
+            # This is a helper to convert the object to a readable table
+            interact <- as.data.frame(colData(interact))
+        }}
+        
+        result_df <- {image_filter}
+        write.csv(result_df, '{output_path}', row.names = FALSE)
+    """)
+
+    try:
+        result = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"Extracting interactions from {input_rds}",
+            "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
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-statial/app/bioconductor-statial_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-statial/app/bioconductor-statial_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_statial'
+
+
+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-statial/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-statial/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-svp/app/bioconductor-svp_server.py

@@ -0,0 +1,250 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict
+
+# Note: The @mcp.tool decorator is expected to be provided by the MCP framework.
+# This is a placeholder class to allow the code to be syntactically valid.
+class mcp:
+    @staticmethod
+    def tool(func):
+        return func
+
+@mcp.tool
+def svp_train(
+    training_data: Path,
+    feature_data: Path,
+    output_model: Path,
+    method: str = "rf",
+) -> Dict:
+    """
+    Trains a Sequence-based Variant Prediction (SVP) model.
+
+    This tool wraps the `svp_train` function from the R Bioconductor package 'SVP'.
+    It takes training data and feature definitions to build a model, which is then
+    saved to a specified file. The R package 'SVP' and its dependencies must be
+    installed in the R environment.
+
+    Args:
+        training_data: Path to the training data file (tab-separated format).
+                       This file should contain variant information and their known classifications.
+        feature_data: Path to the feature data file (tab-separated format).
+                      This file defines the features to be used for model training.
+        output_model: Path where the trained model object (.rds file) will be saved.
+        method: The training method to be used by the underlying 'caret' package.
+                Defaults to 'rf' (Random Forest).
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the path
+        to the output model file.
+    """
+    # 1. Input Validation
+    if not training_data.is_file():
+        raise FileNotFoundError(f"Training data file not found: {training_data}")
+    if not feature_data.is_file():
+        raise FileNotFoundError(f"Feature data file not found: {feature_data}")
+
+    output_model.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. R Script Generation
+    r_script_content = f"""
+    # Suppress startup messages for cleaner output
+    suppressPackageStartupMessages(library(SVP))
+
+    # Get arguments from command line
+    args <- commandArgs(trailingOnly=TRUE)
+    training_file <- args[1]
+    feature_file <- args[2]
+    output_model_file <- args[3]
+    train_method <- args[4]
+
+    # Read data - assuming tab-separated values with a header
+    tryCatch({{
+        training <- read.delim(training_file, header=TRUE, stringsAsFactors=FALSE)
+        feature <- read.delim(feature_file, header=TRUE, stringsAsFactors=FALSE)
+    }}, error = function(e) {{
+        stop(paste("Error reading input files:", e$message))
+    }})
+
+    # Train model
+    print("Starting model training...")
+    tryCatch({{
+        svp_model <- svp_train(training, feature, method=train_method)
+    }}, error = function(e) {{
+        stop(paste("Error during model training:", e$message))
+    }})
+
+    # Save model
+    tryCatch({{
+        saveRDS(svp_model, file=output_model_file)
+    }}, error = function(e) {{
+        stop(paste("Error saving the model file:", e$message))
+    }})
+
+    print(paste("Model training complete. Model saved to:", output_model_file))
+    """
+
+    # 3. Subprocess Execution
+    r_script_path = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as tmp_r_script:
+            tmp_r_script.write(r_script_content)
+            r_script_path = tmp_r_script.name
+
+        cmd = [
+            "Rscript",
+            r_script_path,
+            str(training_data.resolve()),
+            str(feature_data.resolve()),
+            str(output_model.resolve()),
+            method,
+        ]
+        command_executed = " ".join(cmd)
+
+        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": {"model_file": str(output_model)},
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Is R installed and in your system's PATH?")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"SVP training failed with exit code {e.returncode}.\n"
+            f"Command: {e.cmd}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+    finally:
+        # Clean up the temporary R script
+        if r_script_path and Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+
+@mcp.tool
+def svp_predict(
+    model_file: Path,
+    testing_data: Path,
+    feature_data: Path,
+    output_predictions: Path,
+) -> Dict:
+    """
+    Predicts variant effects using a pre-trained SVP model.
+
+    This tool wraps the `svp_predict` function from the R Bioconductor package 'SVP'.
+    It uses a trained model to predict the classification of new variants. The R package
+    'SVP' and its dependencies must be installed in the R environment.
+
+    Args:
+        model_file: Path to the trained SVP model file (.rds format), generated by `svp_train`.
+        testing_data: Path to the data file containing new variants to be classified (tab-separated format).
+        feature_data: Path to the feature data file (tab-separated format). This must be the same
+                      or have the same structure as the one used for training.
+        output_predictions: Path where the output predictions (tab-separated file) will be saved.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the path
+        to the output predictions file.
+    """
+    # 1. Input Validation
+    if not model_file.is_file():
+        raise FileNotFoundError(f"Model file not found: {model_file}")
+    if not testing_data.is_file():
+        raise FileNotFoundError(f"Testing data file not found: {testing_data}")
+    if not feature_data.is_file():
+        raise FileNotFoundError(f"Feature data file not found: {feature_data}")
+
+    output_predictions.parent.mkdir(parents=True, exist_ok=True)
+
+    # 2. R Script Generation
+    r_script_content = f"""
+    # Suppress startup messages for cleaner output
+    suppressPackageStartupMessages(library(SVP))
+
+    # Get arguments from command line
+    args <- commandArgs(trailingOnly=TRUE)
+    model_file <- args[1]
+    testing_file <- args[2]
+    feature_file <- args[3]
+    output_file <- args[4]
+
+    # Load model and data
+    tryCatch({{
+        svp_model <- readRDS(model_file)
+        testing <- read.delim(testing_file, header=TRUE, stringsAsFactors=FALSE)
+        feature <- read.delim(feature_file, header=TRUE, stringsAsFactors=FALSE)
+    }}, error = function(e) {{
+        stop(paste("Error reading input files:", e$message))
+    }})
+
+    # Make predictions
+    print("Starting prediction...")
+    tryCatch({{
+        svp_prediction <- svp_predict(svp_model, testing, feature)
+    }}, error = function(e) {{
+        stop(paste("Error during prediction:", e$message))
+    }})
+
+    # Write predictions to file
+    tryCatch({{
+        write.table(svp_prediction, file=output_file, sep="\\t", row.names=FALSE, quote=FALSE)
+    }}, error = function(e) {{
+        stop(paste("Error writing prediction output file:", e$message))
+    }})
+
+    print(paste("Prediction complete. Results saved to:", output_file))
+    """
+
+    # 3. Subprocess Execution
+    r_script_path = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as tmp_r_script:
+            tmp_r_script.write(r_script_content)
+            r_script_path = tmp_r_script.name
+
+        cmd = [
+            "Rscript",
+            r_script_path,
+            str(model_file.resolve()),
+            str(testing_data.resolve()),
+            str(feature_data.resolve()),
+            str(output_predictions.resolve()),
+        ]
+        command_executed = " ".join(cmd)
+
+        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": {"predictions_file": str(output_predictions)},
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Is R installed and in your system's PATH?")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"SVP prediction failed with exit code {e.returncode}.\n"
+            f"Command: {e.cmd}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+    finally:
+        # Clean up the temporary R script
+        if r_script_path and Path(r_script_path).exists():
+            Path(r_script_path).unlink()