Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_bamtools/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 bamtools via conda (e.g., from bioconda)
+RUN conda install -c bioconda bamtools -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 bamtools_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/bamtools_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/bamtools_server.py"]
+        

Biomni/mcp_generated/mcp_bamtools/app/bamtools_server.py

@@ -0,0 +1,712 @@
+import subprocess
+import shlex
+import os
+from pathlib import Path
+from typing import List, Optional
+
+# In a real MCP environment, the 'mcp' object with its decorators
+# would be provided by the framework. This is a placeholder for standalone validation.
+class _MCP:
+    def tool(self, *args, **kwargs):
+        def decorator(f):
+            return f
+        return decorator
+mcp = _MCP()
+
+### Bamtools Tool Definitions ###
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bamtools'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def convert(
+    in_bam: Path,
+    format: str,
+    out: Optional[Path] = None,
+    region: Optional[str] = None,
+) -> dict:
+    """
+    Converts a BAM file to various other formats.
+
+    Args:
+        in_bam: The input BAM file.
+        format: The output format. Must be one of: bed, fasta, fastq, json, pileup, sam, yaml.
+        out: The output filename. If not provided, output is sent to stdout.
+        region: Only convert alignments that overlap this region (e.g., "ref:start-end").
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output files.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+
+    valid_formats = {"bed", "fasta", "fastq", "json", "pileup", "sam", "yaml"}
+    if format not in valid_formats:
+        raise ValueError(f"Invalid format '{format}'. Must be one of {valid_formats}")
+
+    cmd = ["bamtools", "convert", "-in", str(in_bam), "-format", format]
+    output_files = []
+
+    if out:
+        cmd.extend(["-out", str(out)])
+        output_files.append(str(out))
+    if region:
+        cmd.extend(["-region", region])
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools convert failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def count(in_bams: List[Path]) -> dict:
+    """
+    Prints the number of alignments in one or more BAM files.
+
+    Args:
+        in_bams: A list of input BAM files.
+    
+    Returns:
+        A dictionary containing the command executed, stdout (the count), and stderr.
+    """
+    if not in_bams:
+        raise ValueError("At least one input BAM file must be provided.")
+
+    cmd = ["bamtools", "count"]
+    for bam_file in in_bams:
+        if not bam_file.is_file():
+            raise FileNotFoundError(f"Input BAM file not found: {bam_file}")
+        cmd.extend(["-in", str(bam_file)])
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools count failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def coverage(in_bams: List[Path]) -> dict:
+    """
+    Prints coverage statistics from one or more BAM files.
+
+    Args:
+        in_bams: A list of input BAM files.
+    
+    Returns:
+        A dictionary containing the command executed, stdout (coverage stats), and stderr.
+    """
+    if not in_bams:
+        raise ValueError("At least one input BAM file must be provided.")
+
+    cmd = ["bamtools", "coverage"]
+    for bam_file in in_bams:
+        if not bam_file.is_file():
+            raise FileNotFoundError(f"Input BAM file not found: {bam_file}")
+        cmd.extend(["-in", str(bam_file)])
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools coverage failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def filter_bam(
+    in_bams: List[Path],
+    out_bam: Optional[Path] = None,
+    region: Optional[str] = None,
+    property_filters: Optional[List[str]] = None,
+    tag_filters: Optional[List[str]] = None,
+    script: Optional[Path] = None,
+    list_file: Optional[Path] = None,
+    force_compression: bool = False,
+) -> dict:
+    """
+    Filters BAM file(s) by user-specified criteria.
+
+    Args:
+        in_bams: The input BAM file(s).
+        out_bam: The output BAM file. If not provided, output is sent to stdout.
+        region: Only keeps alignments that overlap this region.
+        property_filters: List of "TAG:VALUE" strings to filter by BamAlignment property.
+        tag_filters: List of "TAG:VALUE" strings to filter by BamAlignment tag.
+        script: A file containing a list of filter rules.
+        list_file: A file containing a list of read names to be kept.
+        force_compression: If True, the output BAM file will be compressed.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output files.
+    """
+    if not in_bams:
+        raise ValueError("At least one input BAM file must be provided.")
+
+    cmd = ["bamtools", "filter"]
+    output_files = []
+
+    for bam_file in in_bams:
+        if not bam_file.is_file():
+            raise FileNotFoundError(f"Input BAM file not found: {bam_file}")
+        cmd.extend(["-in", str(bam_file)])
+
+    if out_bam:
+        cmd.extend(["-out", str(out_bam)])
+        output_files.append(str(out_bam))
+    if region:
+        cmd.extend(["-region", region])
+    if property_filters:
+        for p_filter in property_filters:
+            cmd.extend(["-property", p_filter])
+    if tag_filters:
+        for t_filter in tag_filters:
+            cmd.extend(["-tag", t_filter])
+    if script:
+        if not script.is_file():
+            raise FileNotFoundError(f"Script file not found: {script}")
+        cmd.extend(["-script", str(script)])
+    if list_file:
+        if not list_file.is_file():
+            raise FileNotFoundError(f"List file not found: {list_file}")
+        cmd.extend(["-list", str(list_file)])
+    if force_compression:
+        cmd.append("-forceCompression")
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools filter failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def header(in_bam: Path) -> dict:
+    """
+    Prints the header from a BAM file.
+
+    Args:
+        in_bam: The input BAM file.
+    
+    Returns:
+        A dictionary containing the command executed, stdout (the header), and stderr.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+
+    cmd = ["bamtools", "header", "-in", str(in_bam)]
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools header failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def index(in_bam: Path) -> dict:
+    """
+    Generates an index for a BAM file. The index file (.bai) is created in the same directory.
+
+    Args:
+        in_bam: The input BAM file to index.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the path to the generated index file.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+
+    cmd = ["bamtools", "index", "-in", str(in_bam)]
+    output_index_file = in_bam.with_suffix(in_bam.suffix + '.bai')
+    
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        if not output_index_file.is_file():
+             raise FileNotFoundError(f"Expected index file was not created: {output_index_file}")
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_index_file)],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools index failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def merge(
+    in_bams: List[Path],
+    out_bam: Optional[Path] = None,
+    region: Optional[str] = None,
+    force: bool = False,
+) -> dict:
+    """
+    Merges multiple BAM files into a single file.
+
+    Args:
+        in_bams: A list of input BAM files to merge. Must contain at least two files.
+        out_bam: The output BAM file. If not provided, output is sent to stdout.
+        region: Merges only alignments that overlap this region.
+        force: Forces merge, even if headers are not identical. Uses the first BAM file's header.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output files.
+    """
+    if len(in_bams) < 2:
+        raise ValueError("At least two input BAM files must be provided for merging.")
+
+    cmd = ["bamtools", "merge"]
+    output_files = []
+
+    for bam_file in in_bams:
+        if not bam_file.is_file():
+            raise FileNotFoundError(f"Input BAM file not found: {bam_file}")
+        cmd.extend(["-in", str(bam_file)])
+
+    if out_bam:
+        cmd.extend(["-out", str(out_bam)])
+        output_files.append(str(out_bam))
+    if region:
+        cmd.extend(["-region", region])
+    if force:
+        cmd.append("-force")
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools merge failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def random(
+    in_bams: List[Path],
+    out_bam: Optional[Path] = None,
+    n: int = 100,
+    seed: int = 0,
+) -> dict:
+    """
+    Selects a random number of alignments from existing BAM file(s).
+
+    Args:
+        in_bams: The input BAM file(s).
+        out_bam: The output BAM file. If not provided, output is sent to stdout.
+        n: Number of alignments to select.
+        seed: Random seed.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output files.
+    """
+    if not in_bams:
+        raise ValueError("At least one input BAM file must be provided.")
+
+    cmd = ["bamtools", "random", "-n", str(n), "-seed", str(seed)]
+    output_files = []
+
+    for bam_file in in_bams:
+        if not bam_file.is_file():
+            raise FileNotFoundError(f"Input BAM file not found: {bam_file}")
+        cmd.extend(["-in", str(bam_file)])
+
+    if out_bam:
+        cmd.extend(["-out", str(out_bam)])
+        output_files.append(str(out_bam))
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools random failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def resolve(in_bam: Path, out_bam: Path) -> dict:
+    """
+    Resolves paired-end reads, marking the IsProperPair flag as needed.
+
+    Args:
+        in_bam: The input BAM file.
+        out_bam: The output BAM file.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the output file path.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+
+    cmd = ["bamtools", "resolve", "-in", str(in_bam), "-out", str(out_bam)]
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_bam)],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools resolve failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def revert(in_bam: Path, out_bam: Path) -> dict:
+    """
+    Removes duplicate marks and restores original base qualities from a BAM file.
+
+    Args:
+        in_bam: The input BAM file.
+        out_bam: The output BAM file.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and the output file path.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+
+    cmd = ["bamtools", "revert", "-in", str(in_bam), "-out", str(out_bam)]
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_bam)],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools revert failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def sort(
+    in_bam: Path,
+    out_bam: Optional[Path] = None,
+    by: str = "position",
+    order: str = "ascending",
+    n: int = 1000,
+    mem: int = 512,
+) -> dict:
+    """
+    Sorts a BAM file by position or name.
+
+    Args:
+        in_bam: The input BAM file.
+        out_bam: The output BAM file. If not provided, output is sent to stdout.
+        by: Sort by 'position' or 'name'.
+        order: Sort in 'ascending' or 'descending' order.
+        n: Max number of alignments to buffer in memory.
+        mem: Max memory to use (in megabytes).
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output files.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+    if by not in ["position", "name"]:
+        raise ValueError("Sort 'by' must be 'position' or 'name'.")
+    if order not in ["ascending", "descending"]:
+        raise ValueError("Sort 'order' must be 'ascending' or 'descending'.")
+
+    cmd = ["bamtools", "sort", "-in", str(in_bam), "-by", by, "-order", order, "-n", str(n), "-mem", str(mem)]
+    output_files = []
+
+    if out_bam:
+        cmd.extend(["-out", str(out_bam)])
+        output_files.append(str(out_bam))
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools sort failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def split(
+    in_bam: Path,
+    output_dir: Path,
+    stub: Optional[str] = None,
+    by: Optional[str] = None,
+    reference: bool = False,
+    mapped: bool = False,
+    paired: bool = False,
+    tag: Optional[str] = None,
+) -> dict:
+    """
+    Splits a BAM file based on a specified property, creating multiple output BAM files.
+
+    Args:
+        in_bam: The input BAM file.
+        output_dir: The directory where output files will be created.
+        stub: The prefix for output file names. Defaults to the input file name.
+        by: Split file by a specific property.
+        reference: Split by reference sequence.
+        mapped: Split into mapped and unmapped files.
+        paired: Split into paired and single-end files.
+        tag: Split by the value of a specific tag.
+    
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list of created files.
+    """
+    if not in_bam.is_file():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+
+    split_options = [by is not None, reference, mapped, paired, tag is not None]
+    if sum(split_options) != 1:
+        raise ValueError("Exactly one split criterion (by, reference, mapped, paired, or tag) must be specified.")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["bamtools", "split", "-in", str(in_bam)]
+    
+    # Use the stub to direct output to the specified directory
+    output_stub = stub if stub else in_bam.stem
+    cmd.extend(["-stub", str(output_dir / output_stub)])
+
+    if by:
+        cmd.extend(["-by", by])
+    if reference:
+        cmd.append("-reference")
+    if mapped:
+        cmd.append("-mapped")
+    if paired:
+        cmd.append("-paired")
+    if tag:
+        cmd.extend(["-tag", tag])
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        # Find all files created in the output directory
+        created_files = [str(p) for p in output_dir.glob(f"{output_stub}*")]
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": created_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools split failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+@mcp.tool()
+def stats(in_bams: List[Path], insert: bool = False) -> dict:
+    """
+    Prints basic statistics from one or more BAM files.
+
+    Args:
+        in_bams: A list of input BAM files.
+        insert: If True, print insert size summary.
+    
+    Returns:
+        A dictionary containing the command executed, stdout (the stats), and stderr.
+    """
+    if not in_bams:
+        raise ValueError("At least one input BAM file must be provided.")
+
+    cmd = ["bamtools", "stats"]
+    for bam_file in in_bams:
+        if not bam_file.is_file():
+            raise FileNotFoundError(f"Input BAM file not found: {bam_file}")
+        cmd.extend(["-in", str(bam_file)])
+
+    if insert:
+        cmd.append("-insert")
+
+    command_executed = shlex.join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bamtools stats failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bamtools/app/bamtools_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_bamtools/app/bamtools_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bamtools'
+
+
+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_bamtools/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bamtools/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-alabaster.spatial/Dockerfile

@@ -0,0 +1,40 @@
+
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update &&     apt-get install -y         default-jre         wget         curl     && apt-get clean     && rm -rf /var/lib/apt/lists/*
+
+# Install Miniconda
+RUN wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O /tmp/miniconda.sh &&     bash /tmp/miniconda.sh -b -p /opt/conda &&     rm /tmp/miniconda.sh
+
+# Add conda to PATH
+ENV PATH="/opt/conda/bin:$PATH"
+
+# Install bioconductor-alabaster.spatial via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-alabaster.spatial -y &&     conda clean -a
+
+# Install Python dependencies
+RUN pip install uv
+RUN uv pip install --system fastmcp
+
+# Create app directory
+WORKDIR /app
+
+# Copy your MCP server
+COPY app/bioconductor-alabaster.spatial_server.py /app/
+
+# Create workspace and output directories
+RUN mkdir -p /app/workspace /app/output
+
+# Make sure the server script is executable
+RUN chmod +x /app/bioconductor-alabaster.spatial_server.py
+
+# Expose port for MCP over HTTP (optional)
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3     CMD python -c "import sys; sys.exit(0)"
+
+# Default command runs the MCP server via stdio
+CMD ["python", "/app/bioconductor-alabaster.spatial_server.py"]
+        

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

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  mcp-bioconductor-alabaster.spatial:
+    build: .
+    image: mcp-bioconductor-alabaster.spatial:latest
+    container_name: mcp-bioconductor-alabaster.spatial
+    ports:
+      - "8000:8000"
+    environment:
+      - MCP_SERVER_NAME=bioconductor-alabaster.spatial
+    volumes:
+      - ./workspace:/app/workspace
+      - ./output:/app/output
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 5s
+    

Biomni/mcp_generated/mcp_bioconductor-alabaster.spatial/environment.yaml

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

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

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

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

Biomni/mcp_generated/mcp_bioconductor-cardspa/app/bioconductor-cardspa_server.py

@@ -0,0 +1,189 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, List, Literal, Union
+
+# This is a placeholder for the MCP framework's decorator.
+# The user's environment will provide the actual mcp.tool implementation.
+class Mcp:
+    def tool(self):
+        def decorator(f):
+            return f
+        return decorator
+mcp = Mcp()
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_cardspa'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def cardspa(
+    sce_object: Path,
+    output_path: Path,
+    phenotype_col: str,
+    location_col_1: str = "row",
+    location_col_2: str = "col",
+    method: Literal["Giotto", "SpaGCN", "BayesSpace"] = "Giotto",
+    num_results: int = 10,
+    num_core: int = 1,
+    min_cells: int = 10,
+    min_pairs: int = 10,
+) -> Dict[str, Union[str, List[str], int]]:
+    """
+    Performs spatial analysis on single-cell data using the cardspa R package.
+
+    This tool wraps the main `cardspa` function, which can utilize different
+    backend methods like Giotto, SpaGCN, or BayesSpace to identify significant
+    co-enrichment of cell types in spatial transcriptomics data.
+
+    Args:
+        sce_object: Path to the input SingleCellExperiment object in RDS format.
+        output_path: Path to save the output results object in RDS format.
+        phenotype_col: The column name in the SCE object's colData that contains cell type annotations.
+        location_col_1: The column name for the first spatial coordinate (e.g., 'row', 'x').
+        location_col_2: The column name for the second spatial coordinate (e.g., 'col', 'y').
+        method: The computational method to use for the analysis.
+        num_results: The number of top co-enriched cell type pairs to return.
+        num_core: The number of CPU cores to use for parallel processing.
+        min_cells: The minimum number of cells required for a cell type to be included in the analysis.
+        min_pairs: The minimum number of interacting pairs for a result to be considered significant.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+        In case of an error, it includes an error message and return code.
+    """
+    # --- Input Validation ---
+    if not sce_object.is_file():
+        raise FileNotFoundError(f"Input file not found: {sce_object}")
+
+    if not output_path.parent.is_dir():
+        try:
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            raise NotADirectoryError(
+                f"Output directory does not exist and could not be created: {output_path.parent}"
+            ) from e
+
+    if num_results <= 0:
+        raise ValueError("num_results must be a positive integer.")
+    if num_core <= 0:
+        raise ValueError("num_core must be a positive integer.")
+    if min_cells <= 0:
+        raise ValueError("min_cells must be a positive integer.")
+    if min_pairs <= 0:
+        raise ValueError("min_pairs must be a positive integer.")
+
+    # R script to be executed. It includes package installation for portability.
+    r_script_content = """
+    # run_cardspa.R
+    options(warn=-1)
+    suppressPackageStartupMessages({
+        if (!requireNamespace("argparser", quietly = TRUE)) {
+            install.packages("argparser", repos = "http://cran.us.r-project.org", quiet = TRUE)
+        }
+        if (!requireNamespace("BiocManager", quietly = TRUE)) {
+            install.packages("BiocManager", repos = "http://cran.us.r-project.org", quiet = TRUE)
+        }
+        if (!requireNamespace("cardspa", quietly = TRUE)) {
+            BiocManager::install("cardspa", update=FALSE, ask=FALSE, quiet = TRUE)
+        }
+        if (!requireNamespace("SingleCellExperiment", quietly = TRUE)) {
+            BiocManager::install("SingleCellExperiment", update=FALSE, ask=FALSE, quiet = TRUE)
+        }
+        library(argparser)
+        library(cardspa)
+        library(SingleCellExperiment)
+    })
+
+    p <- arg_parser("Run cardspa analysis")
+    p <- add_argument(p, "--sce_object", help="Path to the input SingleCellExperiment RDS file", type="character")
+    p <- add_argument(p, "--output_path", help="Path to save the output RDS file", type="character")
+    p <- add_argument(p, "--phenotype_col", help="Column name for cell types", type="character")
+    p <- add_argument(p, "--location_col_1", help="First column name for spatial coordinates", default="row", type="character")
+    p <- add_argument(p, "--location_col_2", help="Second column name for spatial coordinates", default="col", type="character")
+    p <- add_argument(p, "--method", help="Method for spatial analysis (Giotto, SpaGCN, BayesSpace)", default="Giotto", type="character")
+    p <- add_argument(p, "--num_results", help="Number of top results to return", default=10, type="integer")
+    p <- add_argument(p, "--num_core", help="Number of cores for parallel processing", default=1, type="integer")
+    p <- add_argument(p, "--min_cells", help="Minimum number of cells for a cell type", default=10, type="integer")
+    p <- add_argument(p, "--min_pairs", help="Minimum number of interacting pairs", default=10, type="integer")
+
+    argv <- parse_args(p)
+
+    if (is.na(argv$sce_object) || is.na(argv$output_path) || is.na(argv$phenotype_col)) {
+      stop("Missing required arguments: --sce_object, --output_path, or --phenotype_col", call. = FALSE)
+    }
+
+    cat("Reading input SCE object from:", argv$sce_object, "\\n")
+    sce <- readRDS(argv$sce_object)
+
+    cat("Running cardspa analysis with method:", argv$method, "\\n")
+    results <- cardspa(
+        sce_object = sce,
+        location_col = c(argv$location_col_1, argv$location_col_2),
+        phenotype_col = argv$phenotype_col,
+        method = argv$method,
+        num_results = argv$num_results,
+        num_core = argv$num_core,
+        min_cells = argv$min_cells,
+        min_pairs = argv$min_pairs
+    )
+
+    cat("Saving results to:", argv$output_path, "\\n")
+    saveRDS(results, file = argv$output_path)
+    cat("cardspa analysis complete. Results saved to:", argv$output_path, "\\n")
+    """
+
+    # --- Subprocess Execution ---
+    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)
+
+    cmd = [
+        "Rscript", str(r_script_path),
+        "--sce_object", str(sce_object.resolve()),
+        "--output_path", str(output_path.resolve()),
+        "--phenotype_col", phenotype_col,
+        "--location_col_1", location_col_1,
+        "--location_col_2", location_col_2,
+        "--method", method,
+        "--num_results", str(num_results),
+        "--num_core", str(num_core),
+        "--min_cells", str(min_cells),
+        "--min_pairs", str(min_pairs),
+    ]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_path.resolve())]
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript command not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "cardspa execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        # Ensure temporary script is always removed
+        if r_script_path.exists():
+            r_script_path.unlink()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-cardspa/app/bioconductor-cardspa_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-cardspa/app/bioconductor-cardspa_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_cardspa'
+
+
+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-cardspa/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-cardspa/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-cellid/app/bioconductor-cellid_server.py

@@ -0,0 +1,288 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List, Union
+import tempfile
+
+def run_r_command(script_content: str):
+    """Helper function to execute R code via Rscript"""
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(script_content)
+        tmp_path = tmp.name
+
+    try:
+        result = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return result.stdout, result.stderr
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"R execution failed: {e.stderr}\nStdout: {e.stdout}")
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_cellid'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def cellid_run_mca(
+    input_rds: str,
+    output_rds: str,
+    nmcs: int = 50,
+    assay: str = "RNA",
+    slot: str = "counts",
+    features: Optional[List[str]] = None
+):
+    """
+    Performs Multiple Correspondence Analysis (MCA) on a SingleCellExperiment or Seurat object.
+    MCA allows for the simultaneous representation of cells and genes in a common low-dimensional space.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} not found."}
+    
+    if nmcs <= 0:
+        return {"error": "nmcs must be a positive integer."}
+
+    features_r = "NULL"
+    if features:
+        features_formatted = ", ".join([f"'{f}'" for f in features])
+        features_r = f"c({features_formatted})"
+
+    r_script = f"""
+    library(CelliD)
+    library(Seurat)
+    library(SingleCellExperiment)
+
+    obj <- readRDS("{input_path}")
+    
+    # Run MCA
+    obj <- RunMCA(obj, nmcs = {nmcs}, assay = "{assay}", slot = "{slot}", features = {features_r})
+    
+    saveRDS(obj, "{output_path}")
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "RunMCA",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def cellid_get_cell_gene_set(
+    input_rds: str,
+    output_csv: str,
+    dims: int = 50,
+    n_features: int = 200
+):
+    """
+    Extracts the top gene signatures for each individual cell based on MCA coordinates.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_csv)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} not found."}
+    
+    if dims <= 0 or n_features <= 0:
+        return {"error": "dims and n_features must be positive integers."}
+
+    r_script = f"""
+    library(CelliD)
+    library(Seurat)
+    library(SingleCellExperiment)
+    library(data.table)
+
+    obj <- readRDS("{input_path}")
+    
+    # Extract gene sets per cell
+    # dims is treated as 1:dims
+    gene_sets <- GetCellGeneSet(obj, dims = 1:{dims}, n.features = {n_features})
+    
+    # Convert list to a data table for export
+    # Each column is a cell, rows are top genes
+    max_len <- max(sapply(gene_sets, length))
+    dt <- as.data.frame(lapply(gene_sets, function(x) c(x, rep(NA, max_len - length(x)))))
+    
+    write.csv(dt, "{output_path}", row.names = FALSE)
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "GetCellGeneSet",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def cellid_run_cell_hgt(
+    input_rds: str,
+    pathways_gmt: str,
+    output_rds: str,
+    dims: int = 50,
+    n_features: int = 200,
+    min_size: int = 5
+):
+    """
+    Performs cell-type assignment or functional enrichment using a Hypergeometric Test (HGT).
+    Matches per-cell gene signatures against a reference database (GMT format).
+    """
+    input_path = Path(input_rds)
+    gmt_path = Path(pathways_gmt)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input RDS {input_rds} not found."}
+    if not gmt_path.exists():
+        return {"error": f"GMT file {pathways_gmt} not found."}
+
+    r_script = f"""
+    library(CelliD)
+    library(Seurat)
+    library(SingleCellExperiment)
+    library(fgsea)
+
+    obj <- readRDS("{input_path}")
+    pathways <- gmtPathways("{gmt_path}")
+    
+    # Run Hypergeometric Test
+    # Returns a matrix of -log10(p-value)
+    hgt_matrix <- RunCellHGT(obj, pathways = pathways, dims = 1:{dims}, n.features = {n_features}, minSize = {min_size})
+    
+    # If Seurat, we can add it as an assay or metadata
+    if(inherits(obj, "Seurat")) {{
+        obj[["HGT"]] <- CreateAssayObject(counts = hgt_matrix)
+    }} else {{
+        # For SCE, add to altExp
+        altExp(obj, "HGT") <- SummarizedExperiment(assays = list(counts = hgt_matrix))
+    }}
+    
+    saveRDS(obj, "{output_path}")
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "RunCellHGT",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def cellid_run_gsea(
+    input_rds: str,
+    pathways_gmt: str,
+    output_rds: str,
+    dims: int = 50
+):
+    """
+    Performs Gene Set Enrichment Analysis (GSEA) on cells using the MCA gene rankings.
+    """
+    input_path = Path(input_rds)
+    gmt_path = Path(pathways_gmt)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input RDS {input_rds} not found."}
+    if not gmt_path.exists():
+        return {"error": f"GMT file {pathways_gmt} not found."}
+
+    r_script = f"""
+    library(CelliD)
+    library(Seurat)
+    library(SingleCellExperiment)
+    library(fgsea)
+
+    obj <- readRDS("{input_path}")
+    pathways <- gmtPathways("{gmt_path}")
+    
+    # Run GSEA
+    # This calculates enrichment scores for each cell and each pathway
+    gsea_res <- RunGSEA(obj, pathways = pathways, dims = 1:{dims})
+    
+    # Save results (usually returns a matrix of NES)
+    if(inherits(obj, "Seurat")) {{
+        obj[["GSEA"]] <- CreateAssayObject(counts = gsea_res)
+    }} else {{
+        altExp(obj, "GSEA") <- SummarizedExperiment(assays = list(counts = gsea_res))
+    }}
+    
+    saveRDS(obj, "{output_path}")
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "RunGSEA",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def cellid_run_group_mca(
+    input_rds: str,
+    group_by: str,
+    output_rds: str,
+    nmcs: int = 50,
+    assay: str = "RNA",
+    slot: str = "counts"
+):
+    """
+    Performs MCA on grouped cells (e.g., by cluster or cell type) rather than individual cells.
+    Useful for extracting group-specific gene signatures.
+    """
+    input_path = Path(input_rds)
+    output_path = Path(output_rds)
+
+    if not input_path.exists():
+        return {"error": f"Input file {input_rds} not found."}
+
+    r_script = f"""
+    library(CelliD)
+    library(Seurat)
+    library(SingleCellExperiment)
+
+    obj <- readRDS("{input_path}")
+    
+    # Run Group MCA
+    # This aggregates cells by the specified metadata column before MCA
+    group_mca <- RunGroupMCA(obj, group.by = "{group_by}", nmcs = {nmcs}, assay = "{assay}", slot = "{slot}")
+    
+    saveRDS(group_mca, "{output_path}")
+    """
+
+    try:
+        stdout, stderr = run_r_command(r_script)
+        return {
+            "command_executed": "RunGroupMCA",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(output_path)]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-cellid/app/bioconductor-cellid_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-cellid/app/bioconductor-cellid_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_cellid'
+
+
+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-cellid/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-cellid/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-ggspavis/app/bioconductor-ggspavis_server.py

@@ -0,0 +1,403 @@
+import subprocess
+import tempfile
+import json
+import shlex
+from pathlib import Path
+from typing import Optional, List, Literal
+
+# This R script acts as a generic command-line wrapper for ggspavis functions.
+# It is written to a temporary file and executed by the Python functions below.
+# It dynamically installs required R packages, making the tool self-contained.
+R_SCRIPT = """
+# ggspavis_runner.R
+# A generic runner for ggspavis functions
+
+# Suppress startup messages for cleaner output
+suppressPackageStartupMessages({
+  # Check if packages are installed, install if not
+  if (!requireNamespace("argparse", quietly = TRUE)) install.packages("argparse", repos = "http://cran.us.r-project.org")
+  if (!requireNamespace("jsonlite", quietly = TRUE)) install.packages("jsonlite", repos = "http://cran.us.r-project.org")
+  if (!requireNamespace("ggplot2", quietly = TRUE)) install.packages("ggplot2", repos = "http://cran.us.r-project.org")
+  if (!requireNamespace("BiocManager", quietly = TRUE)) install.packages("BiocManager", repos = "http://cran.us.r-project.org")
+  
+  # Use BiocManager to install Bioconductor packages
+  if (!requireNamespace("SpatialExperiment", quietly = TRUE)) BiocManager::install("SpatialExperiment", update = FALSE, ask = FALSE)
+  if (!requireNamespace("ggspavis", quietly = TRUE)) BiocManager::install("ggspavis", update = FALSE, ask = FALSE)
+})
+
+library(argparse)
+library(jsonlite)
+library(ggplot2)
+library(SpatialExperiment)
+library(ggspavis)
+
+# Main function to parse arguments and call the appropriate ggspavis function
+main <- function() {
+  parser <- ArgumentParser(description = "A command-line wrapper for ggspavis functions.")
+  
+  parser$add_argument("func", help = "The ggspavis function to call (e.g., plotSpots, plotFeature).")
+  parser$add_argument("--spe_path", required = TRUE, help = "Path to the SpatialExperiment object (.rds file).")
+  parser$add_argument("--output_path", required = TRUE, help = "Path to save the output plot.")
+  parser$add_argument("--width", type = "double", default = 7, help = "Width of the output plot in inches.")
+  parser$add_argument("--height", type = "double", default = 7, help = "Height of the output plot in inches.")
+  parser$add_argument("--json_args", type = "character", default = "{}", help = "A JSON string of arguments for the ggspavis function.")
+  
+  args <- parser$parse_args()
+  
+  # Load SpatialExperiment object
+  if (!file.exists(args$spe_path)) {
+    stop("Input SPE file not found: ", args$spe_path)
+  }
+  spe <- readRDS(args$spe_path)
+  
+  # Parse JSON arguments for the target function
+  func_args <- fromJSON(args$json_args)
+  
+  # Add the main 'spe' object to the arguments list
+  func_args <- c(list(spe = spe), func_args)
+  
+  # Check if the requested function exists in the ggspavis package
+  if (!exists(args$func, where = "package:ggspavis", mode = "function")) {
+    stop("Function '", args$func, "' not found in ggspavis package.")
+  }
+  
+  # Dynamically call the ggspavis function with the parsed arguments
+  plot_obj <- do.call(args$func, func_args)
+  
+  # Save the generated plot to the specified output file
+  ggsave(
+    filename = args$output_path,
+    plot = plot_obj,
+    width = args$width,
+    height = args$height,
+    dpi = 300
+  )
+  
+  cat("Plot successfully saved to", args$output_path, "\\n")
+}
+
+# Execute the main function and handle potential errors
+tryCatch({
+    main()
+}, error = function(e) {
+    message("Error: ", e$message)
+    quit(status = 1)
+})
+"""
+
+def _run_ggspavis(
+    function_name: str,
+    spe_path: Path,
+    output_path: Path,
+    plot_width: float,
+    plot_height: float,
+    json_args: dict,
+) -> dict:
+    """
+    Helper function to execute the ggspavis R script wrapper.
+
+    Args:
+        function_name: The ggspavis function to execute (e.g., 'plotSpots').
+        spe_path: Path to the input SpatialExperiment RDS file.
+        output_path: Path to save the output plot image.
+        plot_width: Width of the output plot in inches.
+        plot_height: Height of the output plot in inches.
+        json_args: A dictionary of arguments for the ggspavis function.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output file path.
+    """
+    # Ensure output directory exists
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Use a temporary file to store and execute the R script
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as r_script_file:
+        r_script_path = Path(r_script_file.name)
+        r_script_file.write(R_SCRIPT)
+
+    command = [
+        "Rscript",
+        str(r_script_path),
+        function_name,
+        "--spe_path", str(spe_path),
+        "--output_path", str(output_path),
+        "--width", str(plot_width),
+        "--height", str(plot_height),
+        "--json_args", json.dumps(json_args),
+    ]
+
+    command_executed = " ".join(shlex.quote(c) for c in command)
+    
+    try:
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+        output_files = {"plot": str(output_path)} if output_path.exists() else {}
+
+    except FileNotFoundError:
+        # This error occurs if 'Rscript' is not in the system's PATH
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: 'Rscript' command not found. Please ensure R is installed and in your system's PATH.",
+            "output_files": {},
+        }
+    except subprocess.CalledProcessError as e:
+        # This error occurs if the R script returns a non-zero exit code
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": {},
+        }
+    finally:
+        # Clean up the temporary R script file
+        r_script_path.unlink()
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files,
+    }
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_ggspavis'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def ggspavis_plot_spots(
+    spe_path: Path,
+    output_filename: str,
+    fill: Optional[str] = None,
+    highlight: Optional[str] = None,
+    facet_by: Optional[str] = None,
+    assay: str = "logcounts",
+    palette: str = "viridis",
+    point_size: float = 1.5,
+    point_alpha: float = 1.0,
+    plot_width: float = 7.0,
+    plot_height: float = 7.0,
+):
+    """
+    Generates a spatial plot of spots/capture locations using ggspavis::plotSpots.
+
+    Args:
+        spe_path: Path to the input SpatialExperiment object (.rds file).
+        output_filename: Name of the output plot file (e.g., 'plot.png').
+        fill: Column name in colData or a feature name to use for spot fill color.
+        highlight: Column name in colData to use for highlighting spots.
+        facet_by: Column name in colData to use for faceting the plot.
+        assay: Name of the assay to use if 'fill' is a feature name.
+        palette: Color palette for continuous values (e.g., 'viridis', 'magma').
+        point_size: Size of the points representing spots.
+        point_alpha: Alpha transparency of the points.
+        plot_width: Width of the output plot in inches.
+        plot_height: Height of the output plot in inches.
+    """
+    # Input validation
+    if not spe_path.is_file():
+        raise FileNotFoundError(f"Input file not found: {spe_path}")
+    if point_size <= 0:
+        raise ValueError("point_size must be positive.")
+    if not (0.0 <= point_alpha <= 1.0):
+        raise ValueError("point_alpha must be between 0.0 and 1.0.")
+
+    # Prepare arguments for the R function
+    json_args = {
+        "fill": fill,
+        "highlight": highlight,
+        "facet_by": facet_by,
+        "assay": assay,
+        "palette": palette,
+        "point_size": point_size,
+        "point_alpha": point_alpha,
+    }
+    # Filter out None values so they are not passed in the JSON
+    json_args = {k: v for k, v in json_args.items() if v is not None}
+
+    output_path = Path(output_filename)
+
+    return _run_ggspavis(
+        function_name="plotSpots",
+        spe_path=spe_path,
+        output_path=output_path,
+        plot_width=plot_width,
+        plot_height=plot_height,
+        json_args=json_args,
+    )
+
+
+@mcp.tool()
+def ggspavis_plot_feature(
+    spe_path: Path,
+    output_filename: str,
+    feature: str,
+    assay: str = "logcounts",
+    platform: Literal["Visium", "ST", "VisiumHD", "mIF", "seqFISH", "MERFISH", "Xenium"] = "Visium",
+    palette: str = "viridis",
+    point_size: float = 1.5,
+    plot_width: float = 7.0,
+    plot_height: float = 7.0,
+):
+    """
+    Visualizes the expression of a single feature (e.g., gene) in spatial context using ggspavis::plotFeature.
+
+    Args:
+        spe_path: Path to the input SpatialExperiment object (.rds file).
+        output_filename: Name of the output plot file (e.g., 'feature_plot.png').
+        feature: Name of the feature (gene) to plot from the specified assay.
+        assay: Name of the assay containing the feature.
+        platform: The spatial transcriptomics platform.
+        palette: Color palette for continuous expression values.
+        point_size: Size of the points.
+        plot_width: Width of the output plot in inches.
+        plot_height: Height of the output plot in inches.
+    """
+    # Input validation
+    if not spe_path.is_file():
+        raise FileNotFoundError(f"Input file not found: {spe_path}")
+    if not feature:
+        raise ValueError("A feature name must be provided.")
+
+    # Prepare arguments for the R function
+    json_args = {
+        "feature": feature,
+        "assay": assay,
+        "platform": platform,
+        "palette": palette,
+        "point_size": point_size,
+    }
+    json_args = {k: v for k, v in json_args.items() if v is not None}
+
+    output_path = Path(output_filename)
+
+    return _run_ggspavis(
+        function_name="plotFeature",
+        spe_path=spe_path,
+        output_path=output_path,
+        plot_width=plot_width,
+        plot_height=plot_height,
+        json_args=json_args,
+    )
+
+
+@mcp.tool()
+def ggspavis_plot_dim_red(
+    spe_path: Path,
+    output_filename: str,
+    reduction_type: str,
+    x_axis: Optional[str] = None,
+    y_axis: Optional[str] = None,
+    color_by: Optional[str] = None,
+    shape_by: Optional[str] = None,
+    assay: str = "logcounts",
+    point_size: float = 1.5,
+    plot_width: float = 7.0,
+    plot_height: float = 7.0,
+):
+    """
+    Plots dimensionality reduction results (e.g., UMAP, PCA) using ggspavis::plotDimRed.
+
+    Args:
+        spe_path: Path to the input SpatialExperiment object (.rds file).
+        output_filename: Name of the output plot file (e.g., 'umap.png').
+        reduction_type: Name of the dimensionality reduction result in reducedDims(spe).
+        x_axis: Column name for the x-axis (e.g., 'UMAP_1'). Defaults to type_1.
+        y_axis: Column name for the y-axis (e.g., 'UMAP_2'). Defaults to type_2.
+        color_by: Column name in colData or feature name to use for point color.
+        shape_by: Column name in colData to use for point shape.
+        assay: Name of assay to use if 'color_by' is a feature name.
+        point_size: Size of the points.
+        plot_width: Width of the output plot in inches.
+        plot_height: Height of the output plot in inches.
+    """
+    # Input validation
+    if not spe_path.is_file():
+        raise FileNotFoundError(f"Input file not found: {spe_path}")
+    if not reduction_type:
+        raise ValueError("A reduction_type must be provided.")
+
+    # Prepare arguments for the R function
+    json_args = {
+        "type": reduction_type,
+        "x_axis": x_axis,
+        "y_axis": y_axis,
+        "color_by": color_by,
+        "shape_by": shape_by,
+        "assay": assay,
+        "point_size": point_size,
+    }
+    json_args = {k: v for k, v in json_args.items() if v is not None}
+
+    output_path = Path(output_filename)
+
+    return _run_ggspavis(
+        function_name="plotDimRed",
+        spe_path=spe_path,
+        output_path=output_path,
+        plot_width=plot_width,
+        plot_height=plot_height,
+        json_args=json_args,
+    )
+
+
+@mcp.tool()
+def ggspavis_plot_label(
+    spe_path: Path,
+    output_filename: str,
+    label: str,
+    platform: Literal["Visium", "ST", "VisiumHD", "mIF", "seqFISH", "MERFISH", "Xenium"] = "Visium",
+    palette: Optional[str] = None,
+    point_size: float = 1.5,
+    plot_width: float = 7.0,
+    plot_height: float = 7.0,
+):
+    """
+    Visualizes spatial clusters or other categorical labels using ggspavis::plotLabel.
+
+    Args:
+        spe_path: Path to the input SpatialExperiment object (.rds file).
+        output_filename: Name of the output plot file (e.g., 'clusters.png').
+        label: Column name in colData containing the labels to plot.
+        platform: The spatial transcriptomics platform.
+        palette: Optional color palette for labels. If None, ggplot2 default is used.
+        point_size: Size of the points.
+        plot_width: Width of the output plot in inches.
+        plot_height: Height of the output plot in inches.
+    """
+    # Input validation
+    if not spe_path.is_file():
+        raise FileNotFoundError(f"Input file not found: {spe_path}")
+    if not label:
+        raise ValueError("A label column name must be provided.")
+
+    # Prepare arguments for the R function
+    json_args = {
+        "label": label,
+        "platform": platform,
+        "palette": palette,
+        "point_size": point_size,
+    }
+    json_args = {k: v for k, v in json_args.items() if v is not None}
+
+    output_path = Path(output_filename)
+
+    return _run_ggspavis(
+        function_name="plotLabel",
+        spe_path=spe_path,
+        output_path=output_path,
+        plot_width=plot_width,
+        plot_height=plot_height,
+        json_args=json_args,
+    )
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-ggspavis/app/bioconductor-ggspavis_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-ggspavis/app/bioconductor-ggspavis_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_ggspavis'
+
+
+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-ggspavis/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-ggspavis/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-mastr/app/bioconductor-mastr_server.py

@@ -0,0 +1,208 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List, Union
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_mastr'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def mastr_align(
+    fasta_input: str,
+    output_alignment: str,
+    iterations: int = 100,
+    temperature: float = 1.0,
+    cooling_rate: float = 0.9,
+    gap_open: float = -10.0,
+    gap_extend: float = -1.0,
+    use_structure: bool = True,
+    r_path: str = "Rscript"
+):
+    """
+    Perform Multiple Alignment of Structural RNAs (MASTR) using the Bioconductor mastr package.
+    
+    Args:
+        fasta_input: Path to the input FASTA file containing RNA sequences.
+        output_alignment: Path where the resulting alignment (FASTA format) will be saved.
+        iterations: Number of iterations for the simulated annealing (default: 100).
+        temperature: Initial temperature for simulated annealing (default: 1.0).
+        cooling_rate: Cooling rate for simulated annealing (default: 0.9).
+        gap_open: Penalty for opening a gap (default: -10.0).
+        gap_extend: Penalty for extending a gap (default: -1.0).
+        use_structure: Whether to incorporate secondary structure prediction (default: True).
+        r_path: Path to the Rscript executable (default: 'Rscript').
+    """
+    # Input validation
+    input_path = Path(fasta_input)
+    if not input_path.exists():
+        return {"error": f"Input file not found: {fasta_input}"}
+    
+    output_path = Path(output_alignment)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if iterations <= 0:
+        return {"error": "Iterations must be a positive integer."}
+    
+    if not (0 < cooling_rate < 1):
+        return {"error": "Cooling rate must be between 0 and 1."}
+
+    # Create an R script to execute the mastr package
+    # Note: mastr is a Bioconductor package, so we use Rscript to interface with it.
+    r_script_content = f"""
+    library(mastr)
+    library(Biostrings)
+
+    # Load sequences
+    seqs <- readRNAStringSet("{input_path.absolute()}")
+    
+    # Define parameters
+    params <- list(
+        iterations = {iterations},
+        temp = {temperature},
+        cooling = {cooling_rate},
+        gapOpen = {gap_open},
+        gapExtend = {gap_extend},
+        useStructure = {"TRUE" if use_structure else "FALSE"}
+    )
+
+    # Run MASTR alignment
+    # Note: mastr() is the primary function in the Bioconductor package
+    alignment_result <- mastr(seqs, 
+                              iterations = params$iterations, 
+                              temp = params$temp, 
+                              cooling = params$cooling,
+                              gapOpen = params$gapOpen,
+                              gapExtend = params$gapExtend)
+
+    # Write output
+    writeXStringSet(alignment_result, "{output_path.absolute()}")
+    """
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(r_script_content)
+        tmp_path = tmp.name
+
+    try:
+        # Execute the R script
+        process = subprocess.run(
+            [r_path, tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        return {
+            "command_executed": f"{r_path} {tmp_path}",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(output_path.absolute())],
+            "status": "Success"
+        }
+
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": f"{r_path} {tmp_path}",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R execution failed. Ensure 'mastr' and 'Biostrings' packages are installed in R.",
+            "status": "Error"
+        }
+    finally:
+        # Cleanup temporary R script
+        if Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+@mcp.tool()
+def mastr_score_alignment(
+    alignment_file: str,
+    r_path: str = "Rscript"
+):
+    """
+    Calculate the structural conservation score for an existing RNA alignment using mastr metrics.
+    
+    Args:
+        alignment_file: Path to the aligned FASTA/Stockholm file.
+        r_path: Path to the Rscript executable.
+    """
+    input_path = Path(alignment_file)
+    if not input_path.exists():
+        return {"error": f"Alignment file not found: {alignment_file}"}
+
+    r_script_content = f"""
+    library(mastr)
+    library(Biostrings)
+
+    aln <- readRNAStringSet("{input_path.absolute()}")
+    # Calculate conservation score based on mastr's internal scoring
+    # This typically involves base-pairing probabilities and covariance
+    score <- mastr:::calculateScore(aln) # Accessing internal scoring if exported or via wrapper
+    cat("Alignment_Score:", score, "\\n")
+    """
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(r_script_content)
+        tmp_path = tmp.name
+
+    try:
+        process = subprocess.run(
+            [r_path, tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        return {
+            "command_executed": f"{r_path} {tmp_path}",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "status": "Success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": str(e),
+            "stderr": e.stderr,
+            "status": "Error"
+        }
+    finally:
+        if Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+@mcp.tool()
+def mastr_check_dependencies(r_path: str = "Rscript"):
+    """
+    Verify if R and the required Bioconductor mastr package are installed and accessible.
+    
+    Args:
+        r_path: Path to the Rscript executable.
+    """
+    r_script_content = """
+    if (!requireNamespace("mastr", quietly = TRUE)) {
+        stop("Package 'mastr' not found. Please install it via BiocManager::install('mastr')")
+    }
+    if (!requireNamespace("Biostrings", quietly = TRUE)) {
+        stop("Package 'Biostrings' not found.")
+    }
+    cat("All dependencies are satisfied.\\n")
+    """
+    
+    try:
+        process = subprocess.run(
+            [r_path, "-e", r_script_content],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "status": "Ready",
+            "stdout": process.stdout
+        }
+    except Exception as e:
+        return {
+            "status": "Missing Dependencies",
+            "error": str(e)
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-mastr/app/bioconductor-mastr_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-mastr/app/bioconductor-mastr_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_mastr'
+
+
+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-mastr/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-mastr/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-rhdf5filters/app/bioconductor-rhdf5filters_server.py

@@ -0,0 +1,78 @@
+import subprocess
+import tempfile
+import shutil
+from pathlib import Path
+from typing import Dict, Any, List
+
+# MCP decorator is commented out as per instructions
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_rhdf5filters'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def check_installation() -> Dict[str, Any]:
+    """
+    Verifies the installation of the bioconductor-rhdf5filters R library.
+
+    bioconductor-rhdf5filters is an R library that provides HDF5 compression
+    filters and does not have a direct command-line interface. This function
+    executes a simple R script to confirm that the library is installed and
+    can be loaded in the R environment, and it reports the installed version.
+    """
+    # Pre-flight check for Rscript executable
+    if not shutil.which("Rscript"):
+        raise FileNotFoundError("Rscript executable not found in PATH. R is required to run this tool.")
+
+    r_script_content = """
+    if (!requireNamespace("rhdf5filters", quietly = TRUE)) {
+      cat("Error: The 'rhdf5filters' package is not installed.\\n", file = stderr())
+      quit(status = 1)
+    }
+    ver <- as.character(packageVersion("rhdf5filters"))
+    cat(paste0("Successfully loaded 'rhdf5filters' version: ", ver, "\\n"))
+    quit(status = 0)
+    """
+
+    command_executed = ""
+    script_path = ""
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R", encoding='utf-8') as tmp_r_script:
+            script_path = tmp_r_script.name
+            tmp_r_script.write(r_script_content)
+
+        cmd: List[str] = ["Rscript", script_path]
+        command_executed = " ".join(cmd)
+
+        process = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+        
+        return {
+            "command_executed": command_executed,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": []
+        }
+
+    except subprocess.CalledProcessError as e:
+        # This will catch the case where the R script exits with a non-zero status
+        # (e.g., package not installed) and return a structured error.
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "error": "R script execution failed. The 'rhdf5filters' package may not be installed or accessible."
+        }
+    finally:
+        # Ensure the temporary file is cleaned up
+        if script_path and Path(script_path).exists():
+            Path(script_path).unlink()
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

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

@@ -0,0 +1 @@
+

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

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

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

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

Biomni/mcp_generated/mcp_bioconductor-rsubread/app/bioconductor-rsubread_server.py

@@ -0,0 +1,322 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List, Union
+import tempfile
+
+def run_r_command(command: str):
+    """Helper to execute R commands via Rscript"""
+    try:
+        # We use -e to execute the expression directly
+        full_cmd = ["Rscript", "-e", f"library(Rsubread); {command}"]
+        result = subprocess.run(full_cmd, capture_output=True, text=True, check=True)
+        return result.stdout, result.stderr
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Rsubread execution failed: {e.stderr}")
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_rsubread'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def rsubread_buildindex(
+    basename: str,
+    reference: str,
+    gapped_index: bool = False,
+    index_memory: int = 8000,
+    colorspace: bool = False,
+    split_index: bool = False
+):
+    """
+    Builds an index for a reference genome.
+    
+    Args:
+        basename: Base name of the index files to be generated.
+        reference: Path to the reference genome file (FASTA format).
+        gapped_index: If True, a gapped index will be built (saves memory).
+        index_memory: Memory usage in MB.
+        colorspace: If True, index is built for color-space reads (SOLiD).
+        split_index: If True, the index will be split into multiple blocks.
+    """
+    ref_path = Path(reference)
+    if not ref_path.exists():
+        return {"error": f"Reference file {reference} not found."}
+
+    # Construct R command
+    r_cmd = (
+        f"buildindex(basename='{basename}', reference='{reference}', "
+        f"gappedIndex={'TRUE' if gapped_index else 'FALSE'}, "
+        f"indexMemory={index_memory}, colorspace={'TRUE' if colorspace else 'FALSE'}, "
+        f"splitIndex={'TRUE' if split_index else 'FALSE'})"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": f"Rsubread::buildindex({basename})",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [str(Path(f"{basename}.{ext}")) for ext in ["files"]] # Rsubread creates multiple files
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def rsubread_align(
+    index: str,
+    readfile1: str,
+    readfile2: Optional[str] = None,
+    output_file: str = "output.bam",
+    input_format: str = "gzFASTQ",
+    output_format: str = "BAM",
+    nthreads: int = 1,
+    type: str = "dna",
+    phred_offset: int = 33,
+    unique: bool = False,
+    n_best_locations: int = 1,
+    max_mismatches: int = 3
+):
+    """
+    Aligns reads to a reference genome using the Subread aligner.
+    
+    Args:
+        index: Base name of the index.
+        readfile1: Path to the first read file.
+        readfile2: Path to the second read file (for paired-end).
+        output_file: Name of the output file.
+        input_format: Format of input reads ('FASTQ', 'gzFASTQ', 'SAM', 'BAM').
+        output_format: Format of output ('BAM', 'SAM').
+        nthreads: Number of threads to use.
+        type: Type of sequencing ('dna' or 'rna').
+        phred_offset: Phred score offset (33 or 64).
+        unique: If True, only uniquely mapped reads are reported.
+        n_best_locations: Number of best mapping locations to report.
+        max_mismatches: Maximum number of mismatches allowed.
+    """
+    if not Path(readfile1).exists():
+        return {"error": f"Read file {readfile1} not found."}
+    
+    read2_param = f"'{readfile2}'" if readfile2 else "NULL"
+    
+    r_cmd = (
+        f"align(index='{index}', readfile1='{readfile1}', readfile2={read2_param}, "
+        f"output_file='{output_file}', input_format='{input_format}', output_format='{output_format}', "
+        f"nthreads={nthreads}, type='{type}', phredOffset={phred_offset}, "
+        f"unique={'TRUE' if unique else 'FALSE'}, nBestLocations={n_best_locations}, "
+        f"maxMismatches={max_mismatches})"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": "Rsubread::align",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [output_file]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def rsubread_subjunc(
+    index: str,
+    readfile1: str,
+    readfile2: Optional[str] = None,
+    output_file: str = "output_subjunc.bam",
+    input_format: str = "gzFASTQ",
+    output_format: str = "BAM",
+    nthreads: int = 1,
+    phred_offset: int = 33,
+    unique: bool = False
+):
+    """
+    Aligns RNA-seq reads and detects exon-exon junctions using the Subjunc aligner.
+    
+    Args:
+        index: Base name of the index.
+        readfile1: Path to the first read file.
+        readfile2: Path to the second read file (for paired-end).
+        output_file: Name of the output file.
+        input_format: Format of input reads.
+        output_format: Format of output.
+        nthreads: Number of threads.
+        phred_offset: Phred score offset.
+        unique: If True, only uniquely mapped reads are reported.
+    """
+    read2_param = f"'{readfile2}'" if readfile2 else "NULL"
+    
+    r_cmd = (
+        f"subjunc(index='{index}', readfile1='{readfile1}', readfile2={read2_param}, "
+        f"output_file='{output_file}', input_format='{input_format}', output_format='{output_format}', "
+        f"nthreads={nthreads}, phredOffset={phred_offset}, unique={'TRUE' if unique else 'FALSE'})"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": "Rsubread::subjunc",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": [output_file]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def rsubread_featurecounts(
+    files: List[str],
+    annot_ext: str,
+    is_gtf_annotation_file: bool = True,
+    gtf_feature_type: str = "exon",
+    gtf_attr_type: str = "gene_id",
+    use_meta_features: bool = True,
+    allow_multi_overlap: bool = False,
+    is_paired_end: bool = False,
+    nthreads: int = 1,
+    strand_specific: int = 0,
+    count_multi_mapping_reads: bool = False
+):
+    """
+    Assigns mapped reads to genomic features (e.g. genes, exons).
+    
+    Args:
+        files: List of paths to alignment files (BAM/SAM).
+        annot_ext: Path to the annotation file (GTF/GFF/SAF).
+        is_gtf_annotation_file: Whether the annotation file is in GTF format.
+        gtf_feature_type: Feature type in GTF to be used (e.g. 'exon').
+        gtf_attr_type: Attribute type in GTF to be used (e.g. 'gene_id').
+        use_meta_features: If True, reads are counted for meta-features (e.g. genes).
+        allow_multi_overlap: If True, a read is allowed to be assigned to multiple features.
+        is_paired_end: If True, reads are treated as paired-end.
+        nthreads: Number of threads.
+        strand_specific: Strand specificity (0: unstranded, 1: stranded, 2: reversely stranded).
+        count_multi_mapping_reads: If True, multi-mapping reads will be counted.
+    """
+    # Convert Python list to R vector
+    files_r = "c(" + ",".join([f"'{f}'" for f in files]) + ")"
+    
+    r_cmd = (
+        f"fc <- featureCounts(files={files_r}, annot.ext='{annot_ext}', "
+        f"isGTFAnnotationFile={'TRUE' if is_gtf_annotation_file else 'FALSE'}, "
+        f"GTF.featureType='{gtf_feature_type}', GTF.attrType='{gtf_attr_type}', "
+        f"useMetaFeatures={'TRUE' if use_meta_features else 'FALSE'}, "
+        f"allowMultiOverlap={'TRUE' if allow_multi_overlap else 'FALSE'}, "
+        f"isPairedEnd={'TRUE' if is_paired_end else 'FALSE'}, "
+        f"nthreads={nthreads}, strandSpecific={strand_specific}, "
+        f"countMultiMappingReads={'TRUE' if count_multi_mapping_reads else 'FALSE'}); "
+        f"write.table(fc$counts, file='counts.txt', sep='\\t', quote=FALSE); "
+        f"write.table(fc$stat, file='stats.txt', sep='\\t', quote=FALSE)"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": "Rsubread::featureCounts",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": ["counts.txt", "stats.txt"]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def rsubread_qualityscores(
+    filename: str,
+    input_format: str = "gzFASTQ",
+    offset: int = 33,
+    nreads: int = 10000
+):
+    """
+    Extracts quality scores from a read file.
+    
+    Args:
+        filename: Path to the read file.
+        input_format: Format of the input file.
+        offset: Phred score offset.
+        nreads: Number of reads to extract quality scores from.
+    """
+    if not Path(filename).exists():
+        return {"error": f"File {filename} not found."}
+
+    r_cmd = (
+        f"qs <- qualityScores(filename='{filename}', input_format='{input_format}', "
+        f"offset={offset}, nreads={nreads}); "
+        f"write.table(qs, file='quality_scores.txt', sep='\\t', quote=FALSE)"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": "Rsubread::qualityScores",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": ["quality_scores.txt"]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def rsubread_atgccontent(
+    filename: str,
+    input_format: str = "gzFASTQ",
+    basewise: bool = True
+):
+    """
+    Calculates ATGC content of reads.
+    
+    Args:
+        filename: Path to the read file.
+        input_format: Format of the input file.
+        basewise: If True, calculate content for each base position.
+    """
+    r_cmd = (
+        f"atgc <- atgcContent(filename='{filename}', input_format='{input_format}', "
+        f"basewise={'TRUE' if basewise else 'FALSE'}); "
+        f"write.table(atgc, file='atgc_content.txt', sep='\\t', quote=FALSE)"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": "Rsubread::atgcContent",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": ["atgc_content.txt"]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+@mcp.tool()
+def rsubread_propmapped(
+    files: List[str],
+    count_multi_mapping_reads: bool = False
+):
+    """
+    Calculates the proportion of mapped reads in BAM/SAM files.
+    
+    Args:
+        files: List of paths to alignment files.
+        count_multi_mapping_reads: Whether to include multi-mapping reads.
+    """
+    files_r = "c(" + ",".join([f"'{f}'" for f in files]) + ")"
+    
+    r_cmd = (
+        f"pm <- propMapped(files={files_r}, "
+        f"countMultiMappingReads={'TRUE' if count_multi_mapping_reads else 'FALSE'}); "
+        f"write.table(pm, file='prop_mapped.txt', sep='\\t', quote=FALSE, row.names=FALSE)"
+    )
+
+    try:
+        stdout, stderr = run_r_command(r_cmd)
+        return {
+            "command_executed": "Rsubread::propMapped",
+            "stdout": stdout,
+            "stderr": stderr,
+            "output_files": ["prop_mapped.txt"]
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-rsubread/app/bioconductor-rsubread_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-rsubread/app/bioconductor-rsubread_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_rsubread'
+
+
+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-rsubread/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bioconductor-rtracklayer/app/bioconductor-rtracklayer_server.py

@@ -0,0 +1,340 @@
+import subprocess
+import tempfile
+import re
+from pathlib import Path
+from typing import Optional, List
+
+# @mcp.tool() is a placeholder for the actual decorator.
+# The code is written to be compatible with the MCP framework.
+
+def mcp_tool_placeholder():
+    def decorator(func):
+        return func
+    return decorator
+
+@mcp_tool_placeholder()
+def rtracklayer_convert(
+    input_file: Path,
+    output_file: Path,
+    input_format: Optional[str] = None,
+    output_format: Optional[str] = None,
+    which: Optional[str] = None,
+    genome: Optional[str] = None,
+    gff_feature_type_filter: Optional[str] = None,
+    gff_version: Optional[str] = None,
+    export_source: Optional[str] = None,
+    index_output: bool = False,
+):
+    """
+    Converts genomic data files from one format to another using rtracklayer.
+
+    This tool wraps the core import() and export() functionality of the rtracklayer
+    R package, allowing for conversion between formats like BED, GFF, GTF, WIG,
+    and BigWig. It also supports filtering by genomic region.
+
+    Args:
+        input_file: Path to the input genomic data file.
+        output_file: Path to write the converted output file.
+        input_format: The format of the input file (e.g., 'bed', 'gff', 'bigWig').
+                      If not provided, rtracklayer will guess from the file extension.
+        output_format: The format for the output file. If not provided, rtracklayer
+                       will guess from the file extension.
+        which: A specific genomic region to process, in the format 'chr:start-end'
+               (e.g., 'chr1:1000-2000'). This is highly effective for indexed files.
+        genome: The genome assembly name (e.g., 'hg19', 'mm10').
+        gff_feature_type_filter: For GFF/GTF import, a comma-separated list of
+                                 feature types to keep (e.g., 'exon,gene').
+        gff_version: Specify the GFF version ('1', '2', or '3') for import/export.
+        export_source: The 'source' field to use for GFF/GTF export.
+        index_output: If True, create a tabix index (.tbi) for the output file.
+                      Applicable to formats like BED and GFF.
+    """
+    # 1. Input Validation
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    ALLOWED_FORMATS = ["bed", "gff", "gff1", "gff2", "gff3", "gtf", "wig", "bigWig", "bedGraph", "2bit", "fasta"]
+    if input_format and input_format not in ALLOWED_FORMATS:
+        raise ValueError(f"Invalid input_format '{input_format}'. Allowed formats: {ALLOWED_FORMATS}")
+    if output_format and output_format not in ALLOWED_FORMATS:
+        raise ValueError(f"Invalid output_format '{output_format}'. Allowed formats: {ALLOWED_FORMATS}")
+
+    if gff_version and gff_version not in ["1", "2", "3"]:
+        raise ValueError("gff_version must be one of '1', '2', or '3'.")
+
+    if which and not re.match(r"^\w+:\d+-\d+$", which):
+        raise ValueError("Invalid 'which' format. Expected 'chr:start-end' (e.g., 'chr1:1000-5000').")
+
+    # 2. Build R Script
+    r_script_lines = [
+        "suppressPackageStartupMessages(library(rtracklayer))",
+        "suppressPackageStartupMessages(library(GenomicRanges))",
+        "",
+        "# --- Import Arguments ---",
+        f"import_args <- list(con = '{input_file.resolve()}')",
+    ]
+    if input_format:
+        r_script_lines.append(f"import_args$format <- '{input_format}'")
+    if which:
+        r_script_lines.append(f"import_args$which <- GRanges('{which}')")
+    if genome:
+        r_script_lines.append(f"import_args$genome <- '{genome}'")
+    if gff_feature_type_filter:
+        r_vector = 'c(' + ', '.join([f'"{f.strip()}"' for f in gff_feature_type_filter.split(',')]) + ')'
+        r_script_lines.append(f"import_args$feature.type <- {r_vector}")
+    if gff_version:
+        r_script_lines.append(f"import_args$version <- '{gff_version}'")
+
+    r_script_lines.extend([
+        "",
+        "# --- Import Data ---",
+        "gr_object <- do.call(rtracklayer::import, import_args)",
+        "",
+        "# --- Export Arguments ---",
+        f"export_args <- list(object = gr_object, con = '{output_file.resolve()}')",
+    ])
+
+    if output_format:
+        r_script_lines.append(f"export_args$format <- '{output_format}'")
+    if export_source:
+        r_script_lines.append(f"export_args$source <- '{export_source}'")
+    if gff_version:
+        r_script_lines.append(f"export_args$version <- '{gff_version}'")
+    if index_output:
+        r_script_lines.append("export_args$index <- TRUE")
+
+    r_script_lines.extend([
+        "",
+        "# --- Export Data ---",
+        "do.call(rtracklayer::export, export_args)",
+        "cat('Conversion successful.\\n')"
+    ])
+
+    r_script = "\n".join(r_script_lines)
+
+    # 3. Execute R Script
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, dir=".") as tmp_script:
+        script_path = Path(tmp_script.name)
+        tmp_script.write(r_script)
+
+    command = ["Rscript", str(script_path.name)]
+    command_str = " ".join(command)
+    
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=Path.cwd()
+        )
+        
+        output_files = [str(output_file)]
+        index_file = Path(f"{output_file}.tbi")
+        if index_output and index_file.exists():
+            output_files.append(str(index_file))
+
+        return {
+            "command_executed": command_str,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with return code {e.returncode}.\n"
+            f"Command: {command_str}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}"
+        ) from e
+    finally:
+        script_path.unlink()
+
+
+@mcp_tool_placeholder()
+def rtracklayer_liftover(
+    input_file: Path,
+    output_file: Path,
+    chain_file: Path,
+    input_format: Optional[str] = None,
+    unmapped_output_file: Optional[Path] = None,
+):
+    """
+    Lifts over genomic coordinates from one assembly to another using a chain file.
+
+    This tool wraps the liftOver() function from rtracklayer, which is essential
+    for translating genomic features between different reference genome versions
+    (e.g., hg18 to hg19).
+
+    Args:
+        input_file: Path to the input genomic data file (e.g., BED, GFF) with
+                    coordinates to be lifted over.
+        output_file: Path to write the output file with lifted coordinates.
+        chain_file: Path to the liftOver chain file (.chain or .chain.gz).
+        input_format: The format of the input file (e.g., 'bed', 'gff'). If not
+                      provided, rtracklayer will guess from the file extension.
+        unmapped_output_file: Optional path to write features that could not be
+                              mapped to the new assembly.
+    """
+    # 1. Input Validation
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if not chain_file.exists():
+        raise FileNotFoundError(f"Chain file not found: {chain_file}")
+
+    # 2. Build R Script
+    r_script_lines = [
+        "suppressPackageStartupMessages(library(rtracklayer))",
+        "",
+        "# --- Import Data ---",
+        f"ch <- rtracklayer::import.chain('{chain_file.resolve()}')",
+        f"gr <- rtracklayer::import('{input_file.resolve()}'" + (f", format = '{input_format}'" if input_format else "") + ")",
+        "",
+        "# --- Perform LiftOver ---",
+        "lifted_grl <- rtracklayer::liftOver(gr, ch)",
+        "lifted_gr <- unlist(lifted_grl)",
+        "",
+        "# --- Export Lifted Data ---",
+        f"rtracklayer::export(lifted_gr, '{output_file.resolve()}')",
+    ]
+
+    if unmapped_output_file:
+        r_script_lines.extend([
+            "",
+            "# --- Handle Unmapped Regions ---",
+            "unmapped_indices <- elementNROWS(lifted_grl) == 0",
+            "unmapped_gr <- gr[unmapped_indices]",
+            f"if (length(unmapped_gr) > 0) {{",
+            f"  rtracklayer::export(unmapped_gr, '{unmapped_output_file.resolve()}')",
+            f"}}",
+        ])
+    
+    r_script_lines.append("cat('LiftOver successful.\\n')")
+    r_script = "\n".join(r_script_lines)
+
+    # 3. Execute R Script
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, dir=".") as tmp_script:
+        script_path = Path(tmp_script.name)
+        tmp_script.write(r_script)
+
+    command = ["Rscript", str(script_path.name)]
+    command_str = " ".join(command)
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=Path.cwd()
+        )
+        
+        output_files = [str(output_file)]
+        if unmapped_output_file and unmapped_output_file.exists():
+            output_files.append(str(unmapped_output_file))
+
+        return {
+            "command_executed": command_str,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with return code {e.returncode}.\n"
+            f"Command: {command_str}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}"
+        ) from e
+    finally:
+        script_path.unlink()
+
+
+@mcp_tool_placeholder()
+def rtracklayer_ucsc_query(
+    output_file: Path,
+    genome: str,
+    track: str,
+    which: Optional[str] = None,
+    output_format: Optional[str] = None,
+):
+    """
+    Downloads data directly from the UCSC Table Browser.
+
+    This tool provides an interface to query and download genomic tracks from the
+    UCSC database, saving them to a local file in a specified format.
+
+    Args:
+        output_file: Path to write the downloaded data.
+        genome: The UCSC genome assembly to query (e.g., 'hg19', 'mm10').
+        track: The name of the track/table to download (e.g., 'knownGene', 'cpgIslandExt').
+        which: A specific genomic region to query, in the format 'chr:start-end'
+               (e.g., 'chr1:1000-2000'). If not provided, the whole genome is queried.
+        output_format: The format for the output file (e.g., 'bed', 'gff'). If not
+                       provided, rtracklayer will guess from the file extension.
+    """
+    # 1. Input Validation
+    if which and not re.match(r"^\w+:\d+-\d+$", which):
+        raise ValueError("Invalid 'which' format. Expected 'chr:start-end' (e.g., 'chr1:1000-5000').")
+
+    # 2. Build R Script
+    r_script_lines = [
+        "suppressPackageStartupMessages(library(rtracklayer))",
+        "suppressPackageStartupMessages(library(GenomicRanges))",
+        "",
+        "# --- Build UCSC Data Source ---",
+        f"ucsc_args <- list(genome = '{genome}', tablename = '{track}')",
+    ]
+    if which:
+        r_script_lines.append(f"ucsc_args$range <- GRanges('{which}')")
+
+    r_script_lines.extend([
+        "ucsc_data_source <- do.call(UCSCData, ucsc_args)",
+        "",
+        "# --- Import Data from UCSC ---",
+        "gr_object <- rtracklayer::import(ucsc_data_source)",
+        "",
+        "# --- Export Data to File ---",
+        f"export_args <- list(object = gr_object, con = '{output_file.resolve()}')",
+    ])
+    if output_format:
+        r_script_lines.append(f"export_args$format <- '{output_format}'")
+
+    r_script_lines.extend([
+        "do.call(rtracklayer::export, export_args)",
+        "cat('UCSC data downloaded successfully.\\n')"
+    ])
+    r_script = "\n".join(r_script_lines)
+
+    # 3. Execute R Script
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, dir=".") as tmp_script:
+        script_path = Path(tmp_script.name)
+        tmp_script.write(r_script)
+
+    command = ["Rscript", str(script_path.name)]
+    command_str = " ".join(command)
+
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=Path.cwd()
+        )
+        
+        return {
+            "command_executed": command_str,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_file)]
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"Rscript execution failed with return code {e.returncode}.\n"
+            f"Command: {command_str}\n"
+            f"Stderr: {e.stderr}\n"
+            f"Stdout: {e.stdout}"
+        ) from e
+    finally:
+        script_path.unlink()

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

Biomni/mcp_generated/mcp_bioconductor-scdotplot/app/bioconductor-scdotplot_server.py

@@ -0,0 +1,273 @@
+import subprocess
+import tempfile
+import json
+from pathlib import Path
+from typing import List, Optional, Union
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_scdotplot'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def sc_dot_plot(
+    input_path: str,
+    features: List[str],
+    group_by: str,
+    output_path: str = "dotplot.pdf",
+    cluster_cols: bool = True,
+    cluster_rows: bool = True,
+    assay: str = "RNA",
+    slot: str = "data",
+    scale: bool = True,
+    cap: float = 2.5,
+    annotation_cols: Optional[List[str]] = None,
+    annotation_rows: Optional[List[str]] = None,
+) -> dict:
+    """
+    Generate a clustered single-cell RNA-seq dot plot using the scDotPlot package.
+    
+    Args:
+        input_path: Path to the input file (RDS format containing Seurat or SingleCellExperiment object).
+        features: List of gene names or features to plot.
+        group_by: Metadata column name to group cells by (e.g., 'ident' or 'cluster').
+        output_path: Path where the resulting plot (PDF, PNG, etc.) will be saved.
+        cluster_cols: Whether to perform hierarchical clustering on the columns (features).
+        cluster_rows: Whether to perform hierarchical clustering on the rows (cell groups).
+        assay: Name of the assay to use (for Seurat objects).
+        slot: Name of the slot to use (e.g., 'data', 'counts').
+        scale: Whether to scale the expression data.
+        cap: Value at which to cap the scaled expression data.
+        annotation_cols: Optional list of metadata columns to use for annotating the columns.
+        annotation_rows: Optional list of metadata columns to use for annotating the rows.
+    """
+    # Input validation
+    input_file = Path(input_path)
+    if not input_file.exists():
+        return {"error": f"Input file not found: {input_path}"}
+    
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Prepare R script
+    features_r = ", ".join([f"'{f}'" for f in features])
+    
+    # Handle optional annotations
+    ann_cols_r = "NULL"
+    if annotation_cols:
+        ann_cols_r = "c(" + ", ".join([f"'{a}'" for a in annotation_cols]) + ")"
+        
+    ann_rows_r = "NULL"
+    if annotation_rows:
+        ann_rows_r = "c(" + ", ".join([f"'{a}'" for a in annotation_rows]) + ")"
+
+    r_script = f"""
+    library(scDotPlot)
+    library(Seurat)
+    library(SingleCellExperiment)
+    library(ggplot2)
+
+    # Load object
+    obj <- readRDS('{input_path}')
+
+    # Generate plot
+    p <- scDotPlot(
+        object = obj,
+        features = c({features_r}),
+        group.by = '{group_by}',
+        cluster.cols = {str(cluster_cols).upper()},
+        cluster.rows = {str(cluster_rows).upper()},
+        assay = '{assay}',
+        slot = '{slot}',
+        scale = {str(scale).upper()},
+        cap = {cap},
+        annotation_cols = {ann_cols_r},
+        annotation_rows = {ann_rows_r}
+    )
+
+    # Save plot
+    ggsave('{output_path}', plot = p)
+    """
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        result = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"scDotPlot on {input_path}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_file.absolute())]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": f"Rscript {tmp_path}"
+        }
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+@mcp.tool()
+def sc_dot_plot_data(
+    input_path: str,
+    features: List[str],
+    group_by: str,
+    output_csv: str = "dotplot_data.csv",
+    assay: str = "RNA",
+    slot: str = "data",
+    scale: bool = True,
+    cap: float = 2.5,
+) -> dict:
+    """
+    Extract the underlying data frame used for generating a scDotPlot.
+    
+    Args:
+        input_path: Path to the input file (RDS format).
+        features: List of gene names or features.
+        group_by: Metadata column name to group cells by.
+        output_csv: Path to save the extracted data as a CSV file.
+        assay: Name of the assay to use.
+        slot: Name of the slot to use.
+        scale: Whether to scale the expression data.
+        cap: Value at which to cap the scaled expression data.
+    """
+    input_file = Path(input_path)
+    if not input_file.exists():
+        return {"error": f"Input file not found: {input_path}"}
+
+    features_r = ", ".join([f"'{f}'" for f in features])
+
+    r_script = f"""
+    library(scDotPlot)
+    library(Seurat)
+    library(SingleCellExperiment)
+
+    obj <- readRDS('{input_path}')
+
+    # Extract data using the internal data preparation logic
+    plot_data <- scDotPlotData(
+        object = obj,
+        features = c({features_r}),
+        group.by = '{group_by}',
+        assay = '{assay}',
+        slot = '{slot}',
+        scale = {str(scale).upper()},
+        cap = {cap}
+    )
+
+    write.csv(plot_data, '{output_csv}', row.names = FALSE)
+    """
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        result = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"scDotPlotData on {input_path}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(Path(output_csv).absolute())]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+@mcp.tool()
+def sc_dot_plot_custom_df(
+    data_path: str,
+    features_col: str,
+    groups_col: str,
+    avg_exp_col: str,
+    pct_exp_col: str,
+    output_path: str = "dotplot_from_df.pdf",
+    cluster_cols: bool = True,
+    cluster_rows: bool = True,
+) -> dict:
+    """
+    Generate a clustered dot plot from a pre-calculated data frame instead of a Seurat/SCE object.
+    
+    Args:
+        data_path: Path to a CSV file containing the summarized expression data.
+        features_col: Column name in the CSV containing gene/feature names.
+        groups_col: Column name in the CSV containing cell group/cluster names.
+        avg_exp_col: Column name in the CSV containing average expression values.
+        pct_exp_col: Column name in the CSV containing percent of cells expressing the gene.
+        output_path: Path where the resulting plot will be saved.
+        cluster_cols: Whether to perform hierarchical clustering on columns.
+        cluster_rows: Whether to perform hierarchical clustering on rows.
+    """
+    data_file = Path(data_path)
+    if not data_file.exists():
+        return {"error": f"Data file not found: {data_path}"}
+
+    r_script = f"""
+    library(scDotPlot)
+    library(ggplot2)
+
+    # Load data frame
+    df <- read.csv('{data_path}')
+
+    # Generate plot using the data frame method
+    # Note: scDotPlot handles data frames by mapping columns
+    p <- scDotPlot(
+        object = df,
+        features = '{features_col}',
+        group.by = '{groups_col}',
+        avg.exp = '{avg_exp_col}',
+        pct.exp = '{pct_exp_col}',
+        cluster.cols = {str(cluster_cols).upper()},
+        cluster.rows = {str(cluster_rows).upper()}
+    )
+
+    ggsave('{output_path}', plot = p)
+    """
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.R', delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        result = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"scDotPlot on data frame {data_path}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(Path(output_path).absolute())]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "R execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-scdotplot/app/bioconductor-scdotplot_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-scdotplot/app/bioconductor-scdotplot_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_scdotplot'
+
+
+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-scdotplot/app/requirements.txt

@@ -0,0 +1 @@
+

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

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