Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_bcftools/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 bcftools via conda (e.g., from bioconda)
+RUN conda install -c bioconda bcftools -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 bcftools_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/bcftools_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/bcftools_server.py"]
+        

Biomni/mcp_generated/mcp_bcftools/app/bcftools_server.py

@@ -0,0 +1,866 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# Note: The @mcp.tool decorator is not defined here.
+# It is assumed to be provided by the Model Context Protocol (MCP) framework.
+# This code is designed to be used within that framework.
+
+# Helper function to handle subprocess execution and error reporting
+def _run_bcftools_command(cmd: List[str], output_file: Optional[Path] = None):
+    """
+    A helper function to execute a bcftools command, handle errors,
+    and return a structured dictionary.
+    """
+    command_str = " ".join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        output_files = [str(output_file)] if output_file and output_file.exists() else []
+        
+        # For commands that create index files automatically
+        if output_file and str(output_file).endswith((".bcf", ".vcf.gz")):
+            index_extensions = [".csi", ".tbi"]
+            for ext in index_extensions:
+                index_file = Path(str(output_file) + ext)
+                if index_file.exists():
+                    output_files.append(str(index_file))
+
+        return {
+            "command_executed": command_str,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+            "return_code": 0,
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": command_str,
+            "stdout": "",
+            "stderr": "Error: 'bcftools' command not found. Please ensure it is in your PATH.",
+            "output_files": [],
+            "return_code": 1,
+            "error": "FileNotFoundError"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": [],
+            "return_code": e.returncode,
+            "error": "CalledProcessError"
+        }
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bcftools'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bcftools_annotate(
+    input_file: Path,
+    annotations: Optional[Path] = None,
+    columns: Optional[str] = None,
+    header_lines: Optional[Path] = None,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    remove: Optional[str] = None,
+    set_id: Optional[str] = None,
+    regions: Optional[str] = None,
+    regions_file: Optional[Path] = None,
+    targets: Optional[str] = None,
+    targets_file: Optional[Path] = None,
+    include: Optional[str] = None,
+    exclude: Optional[str] = None,
+    samples: Optional[str] = None,
+    samples_file: Optional[Path] = None,
+    threads: int = 1,
+    rename_chrs: Optional[Path] = None,
+    no_version: bool = False,
+    single_overlaps: bool = False,
+    mark_sites: Optional[str] = None,
+):
+    """
+    Annotate VCF/BCF files with information from other files.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if annotations and not annotations.exists():
+        raise FileNotFoundError(f"Annotations file not found: {annotations}")
+    if header_lines and not header_lines.exists():
+        raise FileNotFoundError(f"Header lines file not found: {header_lines}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "annotate", str(input_file)]
+
+    if annotations:
+        cmd.extend(["-a", str(annotations)])
+    if columns:
+        cmd.extend(["-c", columns])
+    if header_lines:
+        cmd.extend(["-h", str(header_lines)])
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if remove:
+        cmd.extend(["-x", remove])
+    if set_id:
+        cmd.extend(["--set-id", set_id])
+    if regions:
+        cmd.extend(["-r", regions])
+    if regions_file:
+        cmd.extend(["-R", str(regions_file)])
+    if targets:
+        cmd.extend(["-t", targets])
+    if targets_file:
+        cmd.extend(["-T", str(targets_file)])
+    if include:
+        cmd.extend(["-i", include])
+    if exclude:
+        cmd.extend(["-e", exclude])
+    if samples:
+        cmd.extend(["-s", samples])
+    if samples_file:
+        cmd.extend(["-S", str(samples_file)])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+    if rename_chrs:
+        cmd.extend(["--rename-chrs", str(rename_chrs)])
+    if no_version:
+        cmd.append("--no-version")
+    if single_overlaps:
+        cmd.append("--single-overlaps")
+    if mark_sites:
+        cmd.extend(["--mark-sites", mark_sites])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_call(
+    input_file: Path,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    ploidy: Optional[str] = None,
+    ploidy_file: Optional[Path] = None,
+    call_method: str = "multiallelic",
+    constrain_alleles: bool = False,
+    group_samples: Optional[str] = None,
+    samples: Optional[str] = None,
+    samples_file: Optional[Path] = None,
+    format_fields: Optional[str] = None,
+    keep_alts: bool = False,
+    keep_masked_ref: bool = False,
+    skip_variants: bool = False,
+    threads: int = 1,
+):
+    """
+    Call genotypes from likelihoods.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+    if call_method not in ["consensus", "multiallelic"]:
+        raise ValueError("call_method must be 'consensus' or 'multiallelic'.")
+
+    cmd = ["bcftools", "call", str(input_file)]
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if ploidy:
+        cmd.extend(["-p", ploidy])
+    if ploidy_file:
+        cmd.extend(["-P", str(ploidy_file)])
+    if call_method == "consensus":
+        cmd.append("-c")
+    else: # multiallelic is default, but -m is explicit
+        cmd.append("-m")
+    if constrain_alleles:
+        cmd.append("-C alleles")
+    if group_samples:
+        cmd.extend(["-G", group_samples])
+    if samples:
+        cmd.extend(["-s", samples])
+    if samples_file:
+        cmd.extend(["-S", str(samples_file)])
+    if format_fields:
+        cmd.extend(["-f", format_fields])
+    if keep_alts:
+        cmd.append("-A")
+    if keep_masked_ref:
+        cmd.append("-M")
+    if skip_variants:
+        cmd.append("-V")
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_concat(
+    input_files: List[Path],
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    allow_overlaps: bool = False,
+    remove_duplicates: bool = False,
+    naive: bool = False,
+    threads: int = 1,
+):
+    """
+    Concatenate VCF/BCF files from non-overlapping regions.
+    """
+    if not input_files:
+        raise ValueError("At least one input file must be provided.")
+    for f in input_files:
+        if not f.exists():
+            raise FileNotFoundError(f"Input file not found: {f}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "concat"]
+
+    if allow_overlaps:
+        cmd.append("-a")
+    if remove_duplicates:
+        cmd.append("-d")
+    if naive:
+        cmd.append("-n")
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    cmd.extend([str(f) for f in input_files])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_consensus(
+    input_file: Path,
+    fasta_ref: Path,
+    output: Optional[Path] = None,
+    chain: Optional[Path] = None,
+    haplotype: Optional[str] = None,
+    iupac_codes: bool = False,
+    mark_del: Optional[str] = None,
+    mark_ins: Optional[str] = None,
+    mark_snv: Optional[str] = None,
+    missing: Optional[str] = None,
+    sample: Optional[str] = None,
+    include: Optional[str] = None,
+    exclude: Optional[str] = None,
+):
+    """
+    Create a consensus sequence by applying VCF variants to a reference FASTA file.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input VCF/BCF file not found: {input_file}")
+    if not fasta_ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {fasta_ref}")
+    if haplotype and haplotype not in ["1", "2", "R", "A", "IUPAC", "all"]:
+        raise ValueError("haplotype must be one of '1', '2', 'R', 'A', 'IUPAC', 'all'.")
+
+    cmd = ["bcftools", "consensus", str(input_file)]
+    cmd.extend(["-f", str(fasta_ref)])
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if chain:
+        cmd.extend(["-c", str(chain)])
+    if haplotype:
+        cmd.extend(["-H", haplotype])
+    if iupac_codes:
+        cmd.append("-i")
+    if mark_del:
+        cmd.extend(["--mark-del", mark_del])
+    if mark_ins:
+        cmd.extend(["--mark-ins", mark_ins])
+    if mark_snv:
+        cmd.extend(["--mark-snv", mark_snv])
+    if missing:
+        cmd.extend(["-m", missing])
+    if sample:
+        cmd.extend(["-s", sample])
+    if include:
+        cmd.extend(["--include", include])
+    if exclude:
+        cmd.extend(["--exclude", exclude])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_filter(
+    input_file: Path,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    include: Optional[str] = None,
+    exclude: Optional[str] = None,
+    soft_filter: Optional[str] = None,
+    set_gt: Optional[str] = None,
+    mode: str = "+",
+    threads: int = 1,
+):
+    """
+    Apply filters to VCF/BCF files.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+    if mode not in ["+", "x", "X"]:
+        raise ValueError("mode must be one of '+', 'x', 'X'.")
+
+    cmd = ["bcftools", "filter", str(input_file)]
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if include:
+        cmd.extend(["-i", include])
+    if exclude:
+        cmd.extend(["-e", exclude])
+    if soft_filter:
+        cmd.extend(["-s", soft_filter])
+    if set_gt:
+        cmd.extend(["-S", set_gt])
+    if mode != "+":
+        cmd.extend(["-m", mode])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_index(
+    input_file: Path,
+    force: bool = False,
+    stats: bool = False,
+    threads: int = 1,
+    csi: bool = False,
+    tbi: bool = False,
+    min_csi_shift: int = 14,
+):
+    """
+    Index VCF/BCF files for fast random access.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if csi and tbi:
+        raise ValueError("Cannot specify both --csi (-c) and --tbi (-t).")
+
+    cmd = ["bcftools", "index"]
+
+    if force:
+        cmd.append("-f")
+    if stats:
+        cmd.append("-n")
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+    if csi:
+        cmd.append("-c")
+    if tbi:
+        cmd.append("-t")
+    if csi and min_csi_shift != 14:
+        cmd.extend(["-m", str(min_csi_shift)])
+
+    cmd.append(str(input_file))
+    
+    # The output file is the index file itself
+    output_idx_file = None
+    if csi:
+        output_idx_file = Path(str(input_file) + ".csi")
+    else: # default is tbi for vcf.gz, csi for bcf
+        if str(input_file).endswith(".bcf"):
+            output_idx_file = Path(str(input_file) + ".csi")
+        else:
+            output_idx_file = Path(str(input_file) + ".tbi")
+
+    return _run_bcftools_command(cmd, output_idx_file)
+
+@mcp.tool()
+def bcftools_isec(
+    input_files: List[Path],
+    output_dir: Path,
+    output_type: str = "v",
+    complement: bool = False,
+    collapse: Optional[str] = None,
+    exclude: Optional[str] = None,
+    include: Optional[str] = None,
+    n_sites: Optional[str] = None,
+    regions: Optional[str] = None,
+    regions_file: Optional[Path] = None,
+    targets: Optional[str] = None,
+    targets_file: Optional[Path] = None,
+    threads: int = 1,
+):
+    """
+    Create intersections, unions, and complements of VCF/BCF files.
+    """
+    if len(input_files) < 2:
+        raise ValueError("At least two input files must be provided for isec.")
+    for f in input_files:
+        if not f.exists():
+            raise FileNotFoundError(f"Input file not found: {f}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+    if collapse and collapse not in ["none", "all", "snps", "indels", "both", "any"]:
+        raise ValueError("Invalid value for collapse.")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    cmd = ["bcftools", "isec"]
+    cmd.extend(["-p", str(output_dir)])
+    cmd.extend(["-O", output_type])
+
+    if complement:
+        cmd.append("-c")
+    if collapse:
+        cmd.extend(["--collapse", collapse])
+    if exclude:
+        cmd.extend(["-e", exclude])
+    if include:
+        cmd.extend(["-i", include])
+    if n_sites:
+        cmd.extend(["-n", n_sites])
+    if regions:
+        cmd.extend(["-r", regions])
+    if regions_file:
+        cmd.extend(["-R", str(regions_file)])
+    if targets:
+        cmd.extend(["-t", targets])
+    if targets_file:
+        cmd.extend(["-T", str(targets_file)])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    cmd.extend([str(f) for f in input_files])
+
+    # isec doesn't have a single output file, it creates a directory
+    # We will return the directory path in a structured way if needed,
+    # but for now, we'll rely on the user knowing the output is a directory.
+    # The _run_bcftools_command helper won't find a single output file.
+    result = _run_bcftools_command(cmd)
+    
+    # Manually list created files
+    if result["return_code"] == 0:
+        created_files = [str(p) for p in output_dir.glob('*')]
+        result["output_files"] = created_files
+
+    return result
+
+@mcp.tool()
+def bcftools_merge(
+    input_files: List[Path],
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    info_rules: Optional[str] = None,
+    merge_logic: Optional[str] = None,
+    threads: int = 1,
+):
+    """
+    Merge multiple VCF/BCF files from different samples into a single file.
+    """
+    if not input_files:
+        raise ValueError("At least one input file must be provided.")
+    for f in input_files:
+        if not f.exists():
+            raise FileNotFoundError(f"Input file not found: {f}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "merge"]
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if info_rules:
+        cmd.extend(["--info-rules", info_rules])
+    if merge_logic:
+        cmd.extend(["-m", merge_logic])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    cmd.extend([str(f) for f in input_files])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_mpileup(
+    input_bams: List[Path],
+    fasta_ref: Path,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    regions: Optional[str] = None,
+    regions_file: Optional[Path] = None,
+    annotate: Optional[str] = None,
+    max_depth: int = 250,
+    min_base_quality: int = 13,
+    min_mapping_quality: int = 0,
+    adjust_mq: int = 50,
+    no_baq: bool = False,
+    threads: int = 1,
+):
+    """
+    Generate VCF/BCF from alignment files (BAM/CRAM).
+    """
+    if not input_bams:
+        raise ValueError("At least one input BAM/CRAM file must be provided.")
+    for f in input_bams:
+        if not f.exists():
+            raise FileNotFoundError(f"Input alignment file not found: {f}")
+    if not fasta_ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {fasta_ref}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "mpileup"]
+    cmd.extend(["-f", str(fasta_ref)])
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if regions:
+        cmd.extend(["-r", regions])
+    if regions_file:
+        cmd.extend(["-R", str(regions_file)])
+    if annotate:
+        cmd.extend(["-a", annotate])
+    if max_depth != 250:
+        cmd.extend(["-d", str(max_depth)])
+    if min_base_quality != 13:
+        cmd.extend(["-q", str(min_base_quality)])
+    if min_mapping_quality != 0:
+        cmd.extend(["-Q", str(min_mapping_quality)])
+    if adjust_mq != 50:
+        cmd.extend(["-C", str(adjust_mq)])
+    if no_baq:
+        cmd.append("-B")
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    cmd.extend([str(f) for f in input_bams])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_norm(
+    input_file: Path,
+    fasta_ref: Path,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    check_ref: str = "w",
+    multiallelics: Optional[str] = None,
+    atomize: bool = False,
+    rm_dup: Optional[str] = None,
+    threads: int = 1,
+):
+    """
+    Left-align and normalize indels, check REF, split multiallelic sites.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if not fasta_ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {fasta_ref}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+    if check_ref not in ["w", "e", "x", "s"]:
+        raise ValueError("check_ref must be one of 'w', 'e', 'x', 's'.")
+
+    cmd = ["bcftools", "norm", str(input_file)]
+    cmd.extend(["-f", str(fasta_ref)])
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if check_ref != "w":
+        cmd.extend(["-c", check_ref])
+    if multiallelics:
+        cmd.extend(["-m", multiallelics])
+    if atomize:
+        cmd.append("-a")
+    if rm_dup:
+        cmd.extend(["-d", rm_dup])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_query(
+    input_file: Path,
+    format_string: str,
+    output: Optional[Path] = None,
+    include: Optional[str] = None,
+    exclude: Optional[str] = None,
+    regions: Optional[str] = None,
+    regions_file: Optional[Path] = None,
+    samples: Optional[str] = None,
+    samples_file: Optional[Path] = None,
+    list_samples: bool = False,
+):
+    """
+    Extracts fields from VCF/BCF files and prints them in a user-defined format.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    cmd = ["bcftools", "query", str(input_file)]
+
+    if list_samples:
+        cmd.append("-l")
+    else:
+        cmd.extend(["-f", format_string])
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if include:
+        cmd.extend(["-i", include])
+    if exclude:
+        cmd.extend(["-e", exclude])
+    if regions:
+        cmd.extend(["-r", regions])
+    if regions_file:
+        cmd.extend(["-R", str(regions_file)])
+    if samples:
+        cmd.extend(["-s", samples])
+    if samples_file:
+        cmd.extend(["-S", str(samples_file)])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_reheader(
+    input_file: Path,
+    header: Optional[Path] = None,
+    samples: Optional[Path] = None,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+):
+    """
+    Modify VCF/BCF header, e.g., rename samples.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if header and not header.exists():
+        raise FileNotFoundError(f"Header file not found: {header}")
+    if samples and not samples.exists():
+        raise FileNotFoundError(f"Samples file not found: {samples}")
+    if not header and not samples:
+        raise ValueError("Either 'header' or 'samples' file must be provided.")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "reheader"]
+
+    if header:
+        cmd.extend(["-h", str(header)])
+    if samples:
+        cmd.extend(["-s", str(samples)])
+    if output:
+        cmd.extend(["-o", str(output)])
+    
+    cmd.append(str(input_file))
+
+    # Reheader does not support -O, output type is inferred from extension
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_sort(
+    input_file: Path,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    max_mem: str = "768M",
+    temp_dir: Optional[Path] = None,
+):
+    """
+    Sort VCF/BCF file by chromosome and position.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "sort", str(input_file)]
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if max_mem:
+        cmd.extend(["-m", max_mem])
+    if temp_dir:
+        temp_dir.mkdir(exist_ok=True, parents=True)
+        cmd.extend(["-T", str(temp_dir)])
+
+    return _run_bcftools_command(cmd, output)
+
+@mcp.tool()
+def bcftools_stats(
+    input_files: List[Path],
+    fasta_ref: Optional[Path] = None,
+    output_dir: Optional[Path] = None,
+    regions: Optional[str] = None,
+    regions_file: Optional[Path] = None,
+    samples: Optional[str] = None,
+    samples_file: Optional[Path] = None,
+    threads: int = 1,
+):
+    """
+    Produce VCF/BCF stats, create plots with plot-vcfstats.
+    """
+    if not input_files:
+        raise ValueError("At least one input file must be provided.")
+    for f in input_files:
+        if not f.exists():
+            raise FileNotFoundError(f"Input file not found: {f}")
+    if fasta_ref and not fasta_ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {fasta_ref}")
+
+    cmd = ["bcftools", "stats"]
+
+    if fasta_ref:
+        cmd.extend(["-f", str(fasta_ref)])
+    if regions:
+        cmd.extend(["-r", regions])
+    if regions_file:
+        cmd.extend(["-R", str(regions_file)])
+    if samples:
+        cmd.extend(["-s", samples])
+    if samples_file:
+        cmd.extend(["-S", str(samples_file)])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    cmd.extend([str(f) for f in input_files])
+
+    # stats command outputs to stdout by default.
+    # If output_dir is provided, we redirect stdout to a file.
+    output_file = None
+    if output_dir:
+        output_dir.mkdir(exist_ok=True, parents=True)
+        output_file = output_dir / "stats.txt"
+        with open(output_file, "w") as f_out:
+            command_str = " ".join(cmd)
+            try:
+                result = subprocess.run(
+                    cmd,
+                    stdout=f_out,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    check=True,
+                )
+                return {
+                    "command_executed": command_str,
+                    "stdout": f"Stats written to {output_file}",
+                    "stderr": result.stderr,
+                    "output_files": [str(output_file)],
+                    "return_code": 0,
+                }
+            except subprocess.CalledProcessError as e:
+                return {
+                    "command_executed": command_str,
+                    "stdout": e.stdout or "",
+                    "stderr": e.stderr,
+                    "output_files": [],
+                    "return_code": e.returncode,
+                    "error": "CalledProcessError"
+                }
+    else:
+        # No output file, capture stdout directly
+        return _run_bcftools_command(cmd)
+
+@mcp.tool()
+def bcftools_view(
+    input_file: Path,
+    output: Optional[Path] = None,
+    output_type: str = "v",
+    header_only: bool = False,
+    no_header: bool = False,
+    drop_genotypes: bool = False,
+    trim_alt_alleles: bool = False,
+    min_alleles: Optional[int] = None,
+    max_alleles: Optional[int] = None,
+    min_ac: Optional[int] = None,
+    max_ac: Optional[int] = None,
+    min_af: Optional[float] = None,
+    max_af: Optional[float] = None,
+    types: Optional[str] = None,
+    include: Optional[str] = None,
+    exclude: Optional[str] = None,
+    regions: Optional[str] = None,
+    regions_file: Optional[Path] = None,
+    samples: Optional[str] = None,
+    samples_file: Optional[Path] = None,
+    threads: int = 1,
+):
+    """
+    Subset, filter, and convert VCF and BCF files.
+    """
+    if not input_file.exists():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+    if output_type not in ["b", "u", "z", "v"]:
+        raise ValueError("output_type must be one of 'b', 'u', 'z', 'v'.")
+
+    cmd = ["bcftools", "view", str(input_file)]
+
+    if output:
+        cmd.extend(["-o", str(output)])
+    if output_type:
+        cmd.extend(["-O", output_type])
+    if header_only:
+        cmd.append("-h")
+    if no_header:
+        cmd.append("-H")
+    if drop_genotypes:
+        cmd.append("-G")
+    if trim_alt_alleles:
+        cmd.append("-a")
+    if min_alleles is not None:
+        cmd.extend(["-m", str(min_alleles)])
+    if max_alleles is not None:
+        cmd.extend(["-M", str(max_alleles)])
+    if min_ac is not None:
+        cmd.extend(["-c", str(min_ac)])
+    if max_ac is not None:
+        cmd.extend(["-C", str(max_ac)])
+    if min_af is not None:
+        cmd.extend(["-q", str(min_af)])
+    if max_af is not None:
+        cmd.extend(["-Q", str(max_af)])
+    if types:
+        cmd.extend(["-v", types])
+    if include:
+        cmd.extend(["-i", include])
+    if exclude:
+        cmd.extend(["-e", exclude])
+    if regions:
+        cmd.extend(["-r", regions])
+    if regions_file:
+        cmd.extend(["-R", str(regions_file)])
+    if samples:
+        cmd.extend(["-s", samples])
+    if samples_file:
+        cmd.extend(["-S", str(samples_file)])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+
+    return _run_bcftools_command(cmd, output)
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bcftools/app/bcftools_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_bcftools/app/bcftools_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bcftools'
+
+
+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_bcftools/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bcftools/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-alabaster.spatial/app/bioconductor-alabaster.spatial_server.py

@@ -0,0 +1,297 @@
+import subprocess
+import tempfile
+import os
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# No need to import mcp as per instructions.
+
+def _run_r_script(script_content: str, cwd: Path) -> Dict[str, Any]:
+    """
+    Executes an R script and captures its output.
+
+    Args:
+        script_content: The R script as a string.
+        cwd: The current working directory for the R script execution.
+
+    Returns:
+        A dictionary containing execution details, including command, stdout, stderr,
+        and an error message if the script fails.
+    """
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".R", delete=False) as r_script_file:
+        r_script_file.write(script_content)
+        r_script_path = Path(r_script_file.name)
+
+    command = ["Rscript", str(r_script_path)]
+    
+    stdout = ""
+    stderr = ""
+    try:
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+            cwd=cwd # Run R script in the specified working directory
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(command),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+    finally:
+        os.remove(r_script_path)
+
+    return {
+        "command_executed": " ".join(command),
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [], # This will be populated by the calling function
+    }
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_alabaster_spatial'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def save_spatial_experiment(
+    input_spatial_experiment_rds: Path,
+    output_directory: Path,
+    precomputed: bool = True,
+    deferred: bool = False,
+    compression_level: Optional[int] = None,
+    compression_filter: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Saves a SpatialExperiment object and its images into file artifacts.
+
+    This function serializes an R SpatialExperiment object (provided as an RDS file)
+    into a directory structure of file artifacts, offering a portable alternative
+    to direct RDS serialization. The `alabaster.spatial` package handles the
+    conversion and storage of the object and its associated images.
+
+    Args:
+        input_spatial_experiment_rds: Path to an RDS file containing the SpatialExperiment object.
+                                      This file must exist.
+        output_directory: Path to the directory where the file artifacts will be saved.
+                          This directory will be created if it does not exist.
+        precomputed: Logical, whether to save precomputed results. Defaults to TRUE.
+        deferred: Logical, whether to defer saving of certain components. Defaults to FALSE.
+        compression_level: Integer, compression level for HDF5 files (0-9).
+                           If None, R's default (typically 6) will be used.
+        compression_filter: String, compression filter for HDF5 files (e.g., "gzip", "lzf").
+                            If None, no specific filter is applied.
+
+    Returns:
+        A dictionary containing execution details, including the command executed,
+        stdout, stderr, and a list of generated output files/directories.
+        Returns an error if input file is not found, output path is invalid,
+        compression_level is out of range, or R script execution fails.
+    """
+    # Input validation
+    if not input_spatial_experiment_rds.is_file():
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: Input RDS file not found at '{input_spatial_experiment_rds}'",
+            "output_files": [],
+        }
+    
+    if output_directory.exists() and not output_directory.is_dir():
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: Output path '{output_directory}' exists but is not a directory.",
+            "output_files": [],
+        }
+    
+    try:
+        output_directory.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: Could not create output directory '{output_directory}': {e}",
+            "output_files": [],
+        }
+
+    if compression_level is not None and not (0 <= compression_level <= 9):
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: 'compression_level' must be an integer between 0 and 9, got {compression_level}",
+            "output_files": [],
+        }
+
+    # Construct R script
+    r_script_template = """
+    suppressPackageStartupMessages({{
+        library(alabaster.spatial)
+        library(SpatialExperiment)
+        library(S4Vectors)
+        library(alabaster.base)
+        library(rhdf5) # Explicitly load for HDF5 operations
+    }})
+
+    input_rds_path <- "{input_rds_path}"
+    output_dir_path <- "{output_dir_path}"
+
+    # Load the SpatialExperiment object
+    if (!file.exists(input_rds_path)) {{
+        stop(paste0("Input RDS file not found: ", input_rds_path))
+    }}
+    se_object <- readRDS(input_rds_path)
+
+    # Ensure it's a SpatialExperiment object
+    if (!is(se_object, "SpatialExperiment")) {{
+        stop("Loaded object is not a SpatialExperiment object.")
+    }}
+
+    # Prepare additional arguments for saveObject
+    save_args <- list(
+        x = se_object,
+        path = output_dir_path,
+        precomputed = {precomputed_r},
+        deferred = {deferred_r}
+    )
+    {compression_level_r}
+    {compression_filter_r}
+
+    # Call saveObject
+    do.call(alabaster.spatial::saveObject, save_args)
+
+    message(paste0("SpatialExperiment object saved to: ", output_dir_path))
+    """
+
+    compression_level_r = f"save_args$compression_level <- {compression_level}" if compression_level is not None else ""
+    compression_filter_r = f"save_args$compression_filter <- '{compression_filter}'" if compression_filter is not None else ""
+
+    r_script_content = r_script_template.format(
+        input_rds_path=input_spatial_experiment_rds.resolve(),
+        output_dir_path=output_directory.resolve(),
+        precomputed_r=str(precomputed).upper(),
+        deferred_r=str(deferred).upper(),
+        compression_level_r=compression_level_r,
+        compression_filter_r=compression_filter_r,
+    )
+
+    # Execute R script
+    result = _run_r_script(r_script_content, output_directory.parent) # Run in parent dir to allow output_directory creation
+    if "error" in result:
+        return result
+    
+    result["output_files"] = [str(output_directory.resolve())]
+    return result
+
+
+@mcp.tool()
+def read_spatial_experiment(
+    input_directory: Path,
+    output_spatial_experiment_rds: Path,
+    metadata_only: bool = False,
+    image_format: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Loads a SpatialExperiment object and its images from file artifacts.
+
+    This function reconstructs an R SpatialExperiment object from a directory
+    of file artifacts previously saved by `save_spatial_experiment`.
+
+    Args:
+        input_directory: Path to the directory containing the file artifacts.
+                         This directory must exist and be valid.
+        output_spatial_experiment_rds: Path to the output RDS file where the
+                                       reconstructed SpatialExperiment object will be saved.
+                                       The parent directory will be created if it does not exist.
+        metadata_only: Logical, whether to only load metadata and not the full data.
+                       Defaults to FALSE.
+        image_format: String, desired image format for loading (e.g., "png", "jpeg", "tiff").
+                      If None, images are loaded in their original format.
+
+    Returns:
+        A dictionary containing execution details, including the command executed,
+        stdout, stderr, and a list of generated output files.
+        Returns an error if input directory is not found, output path is invalid,
+        or R script execution fails.
+    """
+    # Input validation
+    if not input_directory.is_dir():
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: Input directory not found at '{input_directory}'",
+            "output_files": [],
+        }
+    
+    if output_spatial_experiment_rds.exists() and not output_spatial_experiment_rds.is_file():
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: Output path '{output_spatial_experiment_rds}' exists but is not a file.",
+            "output_files": [],
+        }
+    
+    try:
+        output_spatial_experiment_rds.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as e:
+        return {
+            "command_executed": "",
+            "stdout": "",
+            "stderr": f"Error: Could not create parent directory for output RDS file '{output_spatial_experiment_rds}': {e}",
+            "output_files": [],
+        }
+
+    # Construct R script
+    r_script_template = """
+    suppressPackageStartupMessages({{
+        library(alabaster.spatial)
+        library(SpatialExperiment)
+        library(S4Vectors)
+        library(alabaster.base)
+        library(rhdf5) # Explicitly load for HDF5 operations
+    }})
+
+    input_dir_path <- "{input_dir_path}"
+    output_rds_path <- "{output_rds_path}"
+
+    # Prepare additional arguments for readObject
+    read_args <- list(
+        path = input_dir_path,
+        metadata.only = {metadata_only_r}
+    )
+    {image_format_r}
+
+    # Call readObject
+    se_object <- do.call(alabaster.spatial::readObject, read_args)
+
+    # Save the SpatialExperiment object to RDS
+    saveRDS(se_object, file = output_rds_path)
+
+    message(paste0("SpatialExperiment object loaded from: ", input_dir_path, " and saved to: ", output_rds_path))
+    """
+
+    image_format_r = f"read_args$image.format <- '{image_format}'" if image_format is not None else ""
+
+    r_script_content = r_script_template.format(
+        input_dir_path=input_directory.resolve(),
+        output_rds_path=output_spatial_experiment_rds.resolve(),
+        metadata_only_r=str(metadata_only).upper(),
+        image_format_r=image_format_r,
+    )
+
+    # Execute R script
+    result = _run_r_script(r_script_content, output_spatial_experiment_rds.parent)
+    if "error" in result:
+        return result
+    
+    result["output_files"] = [str(output_spatial_experiment_rds.resolve())]
+    return result
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-alabaster.spatial/app/bioconductor-alabaster.spatial_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-alabaster.spatial/app/bioconductor-alabaster.spatial_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_alabaster_spatial'
+
+
+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-awaggregator/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-awaggregator via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-awaggregator -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-awaggregator_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-awaggregator_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-awaggregator_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-awaggregator/app/bioconductor-awaggregator_server.py

@@ -0,0 +1,222 @@
+import subprocess
+from pathlib import Path
+from typing import Dict, List
+
+# MCP decorator is assumed to be available in the execution environment.
+# No import is needed as per the instructions.
+# class mcp:
+#     @staticmethod
+#     def tool():
+#         def decorator(func):
+#             return func
+#         return decorator
+
+
+def _run_awaggregator_cli(cmd: List[str], output_map: Dict[str, Path]) -> Dict:
+    """
+    A private helper function to execute the awaggregator wrapper script,
+    handle subprocess execution, and format the output.
+    """
+    command_executed = " ".join(map(str, 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": {key: str(path) for key, path in output_map.items()},
+        }
+    except FileNotFoundError:
+        # This error is raised if 'Rscript' or the wrapper is not in PATH
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: 'Rscript' or the wrapper script 'run_awaggregator.R' not found. "
+                      "Please ensure R and the tool's wrapper script are in the system's PATH.",
+            "output_files": {},
+            "error": "Executable not found."
+        }
+    except subprocess.CalledProcessError as e:
+        # This error is raised for non-zero exit codes from the tool
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": {},
+            "error": f"Tool execution failed with exit code {e.returncode}",
+        }
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_awaggregator'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def aw_weight(
+    expression_matrix: Path,
+    design_matrix: Path,
+    output_weights_file: Path,
+):
+    """
+    Computes adaptive weights for gene expression data meta-analysis.
+
+    This tool wraps the `aw.weight` function from the Bioconductor `awaggregator` package.
+    It takes an expression data matrix and a design matrix to compute weights for each study.
+    The resulting weights matrix can be used with the `aw_mean` or `aw_median` tools.
+
+    Args:
+        expression_matrix: Path to the input expression data matrix file (e.g., CSV, TSV).
+                           Rows should represent genes and columns should represent samples.
+        design_matrix: Path to the input design matrix file (e.g., CSV, TSV).
+                       This matrix describes the experimental design.
+        output_weights_file: Path to save the computed weights matrix.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and a
+        path to the output weights file.
+    """
+    # --- Input Validation ---
+    if not expression_matrix.is_file():
+        raise FileNotFoundError(f"Input expression matrix file not found: {expression_matrix}")
+    if not design_matrix.is_file():
+        raise FileNotFoundError(f"Input design matrix file not found: {design_matrix}")
+
+    output_dir = output_weights_file.parent
+    if not output_dir.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_dir}")
+
+    # --- Command Construction ---
+    # Assumes a wrapper script 'run_awaggregator.R' is available that handles CLI parsing.
+    cmd = [
+        "Rscript",
+        "run_awaggregator.R",
+        "--method",
+        "weight",
+        "--expression",
+        expression_matrix,
+        "--design",
+        design_matrix,
+        "--output",
+        output_weights_file,
+    ]
+
+    return _run_awaggregator_cli(cmd, {"weights_matrix": output_weights_file})
+
+
+@mcp.tool()
+def aw_mean(
+    data_matrix: Path,
+    weights_matrix: Path,
+    output_file: Path,
+    na_rm: bool = False,
+):
+    """
+    Performs adaptive-weighted mean aggregation on gene expression data.
+
+    This tool wraps the `aw.mean` function from the Bioconductor `awaggregator` package.
+    It takes a data matrix and a corresponding weights matrix to compute the weighted mean
+    for each gene (row) across studies (columns).
+
+    Args:
+        data_matrix: Path to the input data matrix file (e.g., CSV, TSV).
+                     Rows should represent genes and columns should represent studies.
+        weights_matrix: Path to the input weights matrix file (e.g., CSV, TSV).
+                        Must have the same dimensions as the data matrix.
+        output_file: Path to save the aggregated results.
+        na_rm: If True, NA values will be removed before computation. Defaults to False.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and a
+        path to the output file.
+    """
+    # --- Input Validation ---
+    if not data_matrix.is_file():
+        raise FileNotFoundError(f"Input data matrix file not found: {data_matrix}")
+    if not weights_matrix.is_file():
+        raise FileNotFoundError(f"Input weights matrix file not found: {weights_matrix}")
+
+    output_dir = output_file.parent
+    if not output_dir.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_dir}")
+
+    # --- Command Construction ---
+    cmd = [
+        "Rscript",
+        "run_awaggregator.R",
+        "--method",
+        "mean",
+        "--data",
+        data_matrix,
+        "--weights",
+        weights_matrix,
+        "--output",
+        output_file,
+    ]
+    if na_rm:
+        cmd.append("--na-rm")
+
+    return _run_awaggregator_cli(cmd, {"aggregated_data": output_file})
+
+
+@mcp.tool()
+def aw_median(
+    data_matrix: Path,
+    weights_matrix: Path,
+    output_file: Path,
+    na_rm: bool = False,
+):
+    """
+    Performs adaptive-weighted median aggregation on gene expression data.
+
+    This tool wraps the `aw.median` function from the Bioconductor `awaggregator` package.
+    It takes a data matrix and a corresponding weights matrix to compute the weighted median
+    for each gene (row) across studies (columns).
+
+    Args:
+        data_matrix: Path to the input data matrix file (e.g., CSV, TSV).
+                     Rows should represent genes and columns should represent studies.
+        weights_matrix: Path to the input weights matrix file (e.g., CSV, TSV).
+                        Must have the same dimensions as the data matrix.
+        output_file: Path to save the aggregated results.
+        na_rm: If True, NA values will be removed before computation. Defaults to False.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and a
+        path to the output file.
+    """
+    # --- Input Validation ---
+    if not data_matrix.is_file():
+        raise FileNotFoundError(f"Input data matrix file not found: {data_matrix}")
+    if not weights_matrix.is_file():
+        raise FileNotFoundError(f"Input weights matrix file not found: {weights_matrix}")
+
+    output_dir = output_file.parent
+    if not output_dir.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_dir}")
+
+    # --- Command Construction ---
+    cmd = [
+        "Rscript",
+        "run_awaggregator.R",
+        "--method",
+        "median",
+        "--data",
+        data_matrix,
+        "--weights",
+        weights_matrix,
+        "--output",
+        output_file,
+    ]
+    if na_rm:
+        cmd.append("--na-rm")
+
+    return _run_awaggregator_cli(cmd, {"aggregated_data": output_file})
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-awaggregator/app/bioconductor-awaggregator_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-awaggregator/app/bioconductor-awaggregator_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_awaggregator'
+
+
+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-awaggregator/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-awaggregator/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-deseq2/app/bioconductor-deseq2_server.py

@@ -0,0 +1,299 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_deseq2'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def deseq2_differential_expression(
+    counts_path: str,
+    metadata_path: str,
+    design_formula: str,
+    output_results_path: str,
+    contrast_column: Optional[str] = None,
+    reference_level: Optional[str] = None,
+    treated_level: Optional[str] = None,
+    alpha: float = 0.05,
+    lfc_threshold: float = 0.0,
+    test_type: str = "Wald",
+    fit_type: str = "parametric",
+    reduced_formula: Optional[str] = None,
+    shrink_lfc: bool = True,
+    shrink_type: str = "apeglm"
+):
+    """
+    Performs differential expression analysis using DESeq2.
+    
+    Args:
+        counts_path: Path to the raw counts matrix (CSV/TSV, genes as rows, samples as columns).
+        metadata_path: Path to the sample metadata (CSV/TSV, samples as rows).
+        design_formula: The design formula (e.g., '~ condition' or '~ genotype + condition').
+        output_results_path: Path where the results CSV will be saved.
+        contrast_column: The column in metadata to use for comparison.
+        reference_level: The baseline/control level in the contrast column.
+        treated_level: The treatment level in the contrast column.
+        alpha: Significance threshold (FDR).
+        lfc_threshold: Log2 fold change threshold for null hypothesis.
+        test_type: 'Wald' or 'LRT' (Likelihood Ratio Test).
+        fit_type: 'parametric', 'local', or 'mean'.
+        reduced_formula: Required if test_type is 'LRT' (e.g., '~ 1').
+        shrink_lfc: Whether to apply Log2 Fold Change shrinkage.
+        shrink_type: Type of shrinkage estimator ('apeglm', 'ashr', or 'normal').
+    """
+    counts_p = Path(counts_path)
+    meta_p = Path(metadata_path)
+    out_p = Path(output_results_path)
+
+    if not counts_p.exists():
+        raise FileNotFoundError(f"Counts file not found: {counts_path}")
+    if not meta_p.exists():
+        raise FileNotFoundError(f"Metadata file not found: {metadata_path}")
+    if test_type == "LRT" and not reduced_formula:
+        raise ValueError("reduced_formula is required when test_type is 'LRT'")
+
+    # Construct R script
+    r_script = f"""
+    library(DESeq2)
+    
+    # Load data
+    counts <- read.csv("{counts_p}", row.names=1, check.names=FALSE)
+    coldata <- read.csv("{meta_p}", row.names=1, check.names=FALSE)
+    
+    # Ensure factors
+    for(col in colnames(coldata)) {{
+        if(is.character(coldata[[col]])) coldata[[col]] <- as.factor(coldata[[col]])
+    }}
+    
+    # Create DESeqDataSet
+    dds <- DESeqDataSetFromMatrix(countData=counts, colData=coldata, design=as.formula("{design_formula}"))
+    
+    # Run DESeq
+    if ("{test_type}" == "LRT") {{
+        dds <- DESeq(dds, test="LRT", reduced=as.formula("{reduced_formula}"), fitType="{fit_type}")
+    }} else {{
+        dds <- DESeq(dds, test="Wald", fitType="{fit_type}")
+    }}
+    
+    # Results extraction
+    if (!is.null("{contrast_column}") && !is.null("{reference_level}") && !is.null("{treated_level}")) {{
+        res <- results(dds, contrast=c("{contrast_column}", "{treated_level}", "{reference_level}"), 
+                       alpha={alpha}, lfcThreshold={lfc_threshold})
+        
+        if ({str(shrink_lfc).upper()}) {{
+            # Shrinkage requires the coefficient name or contrast
+            # apeglm is preferred but requires 'coef'
+            res <- lfcShrink(dds, contrast=c("{contrast_column}", "{treated_level}", "{reference_level}"), 
+                             res=res, type="{shrink_type}")
+        }}
+    }} else {{
+        res <- results(dds, alpha={alpha}, lfcThreshold={lfc_threshold})
+    }}
+    
+    write.csv(as.data.frame(res), file="{out_p}")
+    """
+
+    with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_p)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "DESeq2 execution failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": " ".join(e.cmd)
+        }
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+@mcp.tool()
+def deseq2_transform_counts(
+    counts_path: str,
+    metadata_path: str,
+    design_formula: str,
+    output_path: str,
+    method: str = "vst",
+    blind: bool = True
+):
+    """
+    Transforms count data using Variance Stabilizing Transformation (VST) or Regularized Log (rlog).
+    Useful for PCA, clustering, and visualization.
+    
+    Args:
+        counts_path: Path to raw counts matrix.
+        metadata_path: Path to sample metadata.
+        design_formula: Design formula (e.g., '~ condition').
+        output_path: Path to save the transformed matrix CSV.
+        method: Transformation method ('vst' or 'rlog').
+        blind: Whether to perform transformation in a blind manner (independent of design).
+    """
+    counts_p = Path(counts_path)
+    meta_p = Path(metadata_path)
+    out_p = Path(output_path)
+
+    if method not in ["vst", "rlog"]:
+        raise ValueError("Method must be 'vst' or 'rlog'")
+
+    r_script = f"""
+    library(DESeq2)
+    counts <- read.csv("{counts_p}", row.names=1, check.names=FALSE)
+    coldata <- read.csv("{meta_p}", row.names=1, check.names=FALSE)
+    dds <- DESeqDataSetFromMatrix(countData=counts, colData=coldata, design=as.formula("{design_formula}"))
+    
+    if ("{method}" == "vst") {{
+        transformed <- vst(dds, blind={str(blind).upper()})
+    }} else {{
+        transformed <- rlog(dds, blind={str(blind).upper()})
+    }}
+    
+    write.csv(assay(transformed), file="{out_p}")
+    """
+
+    with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_p)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": str(e), "stderr": e.stderr}
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+@mcp.tool()
+def deseq2_get_normalized_counts(
+    counts_path: str,
+    metadata_path: str,
+    design_formula: str,
+    output_path: str,
+    normalization_type: str = "ratio"
+):
+    """
+    Calculates size factors and returns normalized counts.
+    
+    Args:
+        counts_path: Path to raw counts matrix.
+        metadata_path: Path to sample metadata.
+        design_formula: Design formula.
+        output_path: Path to save normalized counts CSV.
+        normalization_type: Method for size factor estimation ('ratio', 'poscounts', 'iterate').
+    """
+    counts_p = Path(counts_path)
+    meta_p = Path(metadata_path)
+    out_p = Path(output_path)
+
+    r_script = f"""
+    library(DESeq2)
+    counts <- read.csv("{counts_p}", row.names=1, check.names=FALSE)
+    coldata <- read.csv("{meta_p}", row.names=1, check.names=FALSE)
+    dds <- DESeqDataSetFromMatrix(countData=counts, colData=coldata, design=as.formula("{design_formula}"))
+    dds <- estimateSizeFactors(dds, type="{normalization_type}")
+    norm_counts <- counts(dds, normalized=TRUE)
+    write.csv(norm_counts, file="{out_p}")
+    """
+
+    with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_p)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": str(e), "stderr": e.stderr}
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+@mcp.tool()
+def deseq2_plot_pca(
+    counts_path: str,
+    metadata_path: str,
+    design_formula: str,
+    intgroup_columns: List[str],
+    output_plot_path: str,
+    ntop: int = 500
+):
+    """
+    Generates a PCA plot from DESeq2 transformed data.
+    
+    Args:
+        counts_path: Path to raw counts matrix.
+        metadata_path: Path to sample metadata.
+        design_formula: Design formula.
+        intgroup_columns: List of columns in metadata to use for grouping/coloring.
+        output_plot_path: Path to save the PCA plot (PDF or PNG).
+        ntop: Number of top variable genes to use for PCA.
+    """
+    counts_p = Path(counts_path)
+    meta_p = Path(metadata_path)
+    out_p = Path(output_plot_path)
+    
+    intgroup_r = 'c("' + '","'.join(intgroup_columns) + '")'
+
+    r_script = f"""
+    library(DESeq2)
+    library(ggplot2)
+    counts <- read.csv("{counts_p}", row.names=1, check.names=FALSE)
+    coldata <- read.csv("{meta_p}", row.names=1, check.names=FALSE)
+    dds <- DESeqDataSetFromMatrix(countData=counts, colData=coldata, design=as.formula("{design_formula}"))
+    vsd <- vst(dds, blind=TRUE)
+    
+    pca_data <- plotPCA(vsd, intgroup={intgroup_r}, ntop={ntop}, returnData=TRUE)
+    percentVar <- round(100 * attr(pca_data, "percentVar"))
+    
+    p <- ggplot(pca_data, aes(PC1, PC2, color={intgroup_columns[0]})) +
+         geom_point(size=3) +
+         xlab(paste0("PC1: ", percentVar[1], "% variance")) +
+         ylab(paste0("PC2: ", percentVar[2], "% variance")) +
+         coord_fixed() +
+         theme_bw()
+    
+    ggsave("{out_p}", plot=p, device="{out_p.suffix[1:]}")
+    """
+
+    with tempfile.NamedTemporaryFile(suffix=".R", mode="w", delete=False) as tmp:
+        tmp.write(r_script)
+        tmp_path = tmp.name
+
+    try:
+        cmd = ["Rscript", tmp_path]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(out_p)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {"error": str(e), "stderr": e.stderr}
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-deseq2/app/bioconductor-deseq2_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-deseq2/app/bioconductor-deseq2_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_deseq2'
+
+
+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-deseq2/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-deseq2/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-gosemsim/app/bioconductor-gosemsim_server.py

@@ -0,0 +1,281 @@
+import subprocess
+import json
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Literal, Union
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_gosemsim'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def go_similarity(
+    term1: str,
+    term2: str,
+    org_db: str = "org.Hs.eg.db",
+    ont: Literal["BP", "MF", "CC"] = "BP",
+    measure: Literal["Resnik", "Lin", "Rel", "Jiang", "Wang"] = "Wang",
+    keytype: str = "ENTREZID"
+):
+    """
+    Calculate semantic similarity between two GO terms using GOSemSim.
+
+    Args:
+        term1: First GO term ID (e.g., 'GO:0004022').
+        term2: Second GO term ID (e.g., 'GO:0005515').
+        org_db: The annotation OrgDb package (e.g., 'org.Hs.eg.db' for human).
+        ont: One of "BP", "MF", or "CC" ontologies.
+        measure: Semantic similarity method ("Resnik", "Lin", "Rel", "Jiang", or "Wang").
+        keytype: Key type of the gene identifiers in the OrgDb.
+    """
+    if not term1.startswith("GO:") or not term2.startswith("GO:"):
+        return {"error": "GO terms must start with 'GO:' prefix."}
+
+    r_script = f"""
+    suppressPackageStartupMessages(library(GOSemSim))
+    suppressPackageStartupMessages(library({org_db}))
+    
+    hsGO <- godata('{org_db}', ont='{ont}', computeIC=TRUE, keytype='{keytype}')
+    sim <- goSim('{term1}', '{term2}', semData=hsGO, measure='{measure}')
+    cat(sim)
+    """
+
+    return _execute_r_script(r_script)
+
+@mcp.tool()
+def mgo_similarity(
+    terms: List[str],
+    org_db: str = "org.Hs.eg.db",
+    ont: Literal["BP", "MF", "CC"] = "BP",
+    measure: Literal["Resnik", "Lin", "Rel", "Jiang", "Wang"] = "Wang",
+    keytype: str = "ENTREZID"
+):
+    """
+    Calculate semantic similarity matrix for a list of GO terms.
+
+    Args:
+        terms: List of GO term IDs.
+        org_db: The annotation OrgDb package.
+        ont: One of "BP", "MF", or "CC" ontologies.
+        measure: Semantic similarity method.
+        keytype: Key type of the gene identifiers.
+    """
+    terms_r = 'c("' + '","'.join(terms) + '")'
+    r_script = f"""
+    suppressPackageStartupMessages(library(GOSemSim))
+    suppressPackageStartupMessages(library({org_db}))
+    
+    hsGO <- godata('{org_db}', ont='{ont}', computeIC=TRUE, keytype='{keytype}')
+    sim_matrix <- mgoSim({terms_r}, semData=hsGO, measure='{measure}', combine=NULL)
+    write.csv(sim_matrix, row.names=TRUE)
+    """
+
+    return _execute_r_script(r_script)
+
+@mcp.tool()
+def gene_similarity(
+    gene1: str,
+    gene2: str,
+    org_db: str = "org.Hs.eg.db",
+    ont: Literal["BP", "MF", "CC"] = "BP",
+    measure: Literal["Resnik", "Lin", "Rel", "Jiang", "Wang"] = "Wang",
+    combine: Literal["max", "avg", "rcmax", "BMA"] = "BMA",
+    keytype: str = "ENTREZID"
+):
+    """
+    Calculate semantic similarity between two genes based on their GO annotations.
+
+    Args:
+        gene1: First gene ID.
+        gene2: Second gene ID.
+        org_db: The annotation OrgDb package.
+        ont: One of "BP", "MF", or "CC" ontologies.
+        measure: Semantic similarity method.
+        combine: Strategy to combine similarities of multiple GO terms ("max", "avg", "rcmax", "BMA").
+        keytype: Key type of the gene identifiers (e.g., 'ENTREZID', 'SYMBOL').
+    """
+    r_script = f"""
+    suppressPackageStartupMessages(library(GOSemSim))
+    suppressPackageStartupMessages(library({org_db}))
+    
+    hsGO <- godata('{org_db}', ont='{ont}', computeIC=TRUE, keytype='{keytype}')
+    sim <- geneSim('{gene1}', '{gene2}', semData=hsGO, measure='{measure}', combine='{combine}')
+    print(sim)
+    """
+
+    return _execute_r_script(r_script)
+
+@mcp.tool()
+def mgene_similarity(
+    genes: List[str],
+    org_db: str = "org.Hs.eg.db",
+    ont: Literal["BP", "MF", "CC"] = "BP",
+    measure: Literal["Resnik", "Lin", "Rel", "Jiang", "Wang"] = "Wang",
+    combine: Literal["max", "avg", "rcmax", "BMA"] = "BMA",
+    keytype: str = "ENTREZID"
+):
+    """
+    Calculate semantic similarity matrix for a list of genes.
+
+    Args:
+        genes: List of gene IDs.
+        org_db: The annotation OrgDb package.
+        ont: One of "BP", "MF", or "CC" ontologies.
+        measure: Semantic similarity method.
+        combine: Strategy to combine similarities.
+        keytype: Key type of the gene identifiers.
+    """
+    genes_r = 'c("' + '","'.join(genes) + '")'
+    r_script = f"""
+    suppressPackageStartupMessages(library(GOSemSim))
+    suppressPackageStartupMessages(library({org_db}))
+    
+    hsGO <- godata('{org_db}', ont='{ont}', computeIC=TRUE, keytype='{keytype}')
+    sim_matrix <- mgeneSim({genes_r}, semData=hsGO, measure='{measure}', combine='{combine}')
+    write.csv(sim_matrix, row.names=TRUE)
+    """
+
+    return _execute_r_script(r_script)
+
+@mcp.tool()
+def cluster_similarity(
+    cluster1: List[str],
+    cluster2: List[str],
+    org_db: str = "org.Hs.eg.db",
+    ont: Literal["BP", "MF", "CC"] = "BP",
+    measure: Literal["Resnik", "Lin", "Rel", "Jiang", "Wang"] = "Wang",
+    combine: Literal["max", "avg", "rcmax", "BMA"] = "BMA",
+    keytype: str = "ENTREZID"
+):
+    """
+    Calculate semantic similarity between two clusters (sets) of genes.
+
+    Args:
+        cluster1: List of gene IDs in the first cluster.
+        cluster2: List of gene IDs in the second cluster.
+        org_db: The annotation OrgDb package.
+        ont: One of "BP", "MF", or "CC" ontologies.
+        measure: Semantic similarity method.
+        combine: Strategy to combine similarities.
+        keytype: Key type of the gene identifiers.
+    """
+    c1_r = 'c("' + '","'.join(cluster1) + '")'
+    c2_r = 'c("' + '","'.join(cluster2) + '")'
+    
+    r_script = f"""
+    suppressPackageStartupMessages(library(GOSemSim))
+    suppressPackageStartupMessages(library({org_db}))
+    
+    hsGO <- godata('{org_db}', ont='{ont}', computeIC=TRUE, keytype='{keytype}')
+    sim <- clusterSim({c1_r}, {c2_r}, semData=hsGO, measure='{measure}', combine='{combine}')
+    cat(sim)
+    """
+
+    return _execute_r_script(r_script)
+
+@mcp.tool()
+def mcluster_similarity(
+    clusters_json: str,
+    org_db: str = "org.Hs.eg.db",
+    ont: Literal["BP", "MF", "CC"] = "BP",
+    measure: Literal["Resnik", "Lin", "Rel", "Jiang", "Wang"] = "Wang",
+    combine: Literal["max", "avg", "rcmax", "BMA"] = "BMA",
+    keytype: str = "ENTREZID"
+):
+    """
+    Calculate semantic similarity matrix between multiple clusters of genes.
+
+    Args:
+        clusters_json: A JSON string representing a dictionary where keys are cluster names 
+                       and values are lists of gene IDs.
+        org_db: The annotation OrgDb package.
+        ont: One of "BP", "MF", or "CC" ontologies.
+        measure: Semantic similarity method.
+        combine: Strategy to combine similarities.
+        keytype: Key type of the gene identifiers.
+    """
+    try:
+        clusters_dict = json.loads(clusters_json)
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON format for clusters_json."}
+
+    # Construct R list of character vectors
+    r_list_elements = []
+    for name, genes in clusters_dict.items():
+        genes_str = 'c("' + '","'.join(genes) + '")'
+        r_list_elements.append(f'"{name}" = {genes_str}')
+    
+    clusters_r = "list(" + ", ".join(r_list_elements) + ")"
+
+    r_script = f"""
+    suppressPackageStartupMessages(library(GOSemSim))
+    suppressPackageStartupMessages(library({org_db}))
+    
+    hsGO <- godata('{org_db}', ont='{ont}', computeIC=TRUE, keytype='{keytype}')
+    clusters <- {clusters_r}
+    sim_matrix <- mclusterSim(clusters, semData=hsGO, measure='{measure}', combine='{combine}')
+    write.csv(sim_matrix, row.names=TRUE)
+    """
+
+    return _execute_r_script(r_script)
+
+def _execute_r_script(script_content: str):
+    """
+    Internal helper 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:
+        # Note: We assume Rscript is in the PATH and GOSemSim is installed.
+        # If using a specific conda environment, the user should run the MCP server within it.
+        result = subprocess.run(
+            ["Rscript", tmp_path],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        return {
+            "command_executed": f"Rscript {tmp_path}",
+            "stdout": result.stdout.strip(),
+            "stderr": result.stderr.strip(),
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": f"Rscript {tmp_path}",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R execution failed. Ensure R and GOSemSim are installed and the OrgDb package is available.",
+            "status": "error"
+        }
+    finally:
+        if Path(tmp_path).exists():
+            Path(tmp_path).unlink()
+
+@mcp.tool()
+def list_supported_orgdbs():
+    """
+    Returns a list of commonly used Bioconductor OrgDb packages for GOSemSim.
+    """
+    org_dbs = {
+        "human": "org.Hs.eg.db",
+        "mouse": "org.Mm.eg.db",
+        "rat": "org.Rn.eg.db",
+        "fly": "org.Dm.eg.db",
+        "zebrafish": "org.Dr.eg.db",
+        "yeast": "org.Sc.sgd.db",
+        "arabidopsis": "org.At.tair.db",
+        "chicken": "org.Gg.eg.db",
+        "bovine": "org.Bt.eg.db",
+        "worm": "org.Ce.eg.db",
+        "pig": "org.Ss.eg.db",
+        "rhesus": "org.Mmu.eg.db"
+    }
+    return {"supported_org_dbs": org_dbs}
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-gosemsim/app/bioconductor-gosemsim_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-gosemsim/app/bioconductor-gosemsim_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_gosemsim'
+
+
+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-gosemsim/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-gosemsim/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-infercnv/app/bioconductor-infercnv_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-infercnv/app/bioconductor-infercnv_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_infercnv'
+
+
+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-matrixgenerics/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-matrixgenerics via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-matrixgenerics -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-matrixgenerics_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-matrixgenerics_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-matrixgenerics_server.py"]
+        

Biomni/mcp_generated/mcp_bioconductor-matrixgenerics/app/bioconductor-matrixgenerics_server.py

@@ -0,0 +1,231 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Literal, Optional
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be imported.
+def mcp_tool_decorator_placeholder(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+mcp = type("mcp", (), {"tool": mcp_tool_decorator_placeholder})
+
+
+# A comprehensive list of functions provided by the MatrixGenerics package.
+MatrixGenericsOperation = Literal[
+    "colAlls", "colAnyNAs", "colAnys", "colAvgsPerRow", "colCounts", "colCummaxs",
+    "colCummins", "colCumprods", "colCumsums", "colDiffs", "colIQRDiffs", "colIQRs",
+    "colLogSumExps", "colMadDiffs", "colMads", "colMaxs", "colMeans2", "colMedians",
+    "colMins", "colOrderStats", "colProds", "colQuantiles", "colRanges", "colRanks",
+    "colSdDiffs", "colSds", "colSums2", "colTabulates", "colVarDiffs", "colVars",
+    "colWeightedMads", "colWeightedMeans", "colWeightedMedians", "colWeightedSds",
+    "colWeightedVars", "rowAlls", "rowAnyNAs", "rowAnys", "rowAvgsPerCol",
+    "rowCounts", "rowCummaxs", "rowCummins", "rowCumprods", "rowCumsums",
+    "rowDiffs", "rowIQRDiffs", "rowIQRs", "rowLogSumExps", "rowMadDiffs",
+    "rowMads", "rowMaxs", "rowMeans2", "rowMedians", "rowMins", "rowOrderStats",
+    "rowProds", "rowQuantiles", "rowRanges", "rowRanks", "rowSdDiffs", "rowSds",
+    "rowSums2", "rowTabulates", "rowVarDiffs", "rowVars", "rowWeightedMads",
+    "rowWeightedMeans", "rowWeightedMedians", "rowWeightedSds", "rowWeightedVars"
+]
+
+TiesMethod = Literal["average", "first", "last", "random", "max", "min"]
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_matrixgenerics'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def perform_matrix_statistic(
+    input_matrix: Path,
+    operation: MatrixGenericsOperation,
+    output_filename: str,
+    na_rm: bool = True,
+    delimiter: Literal[",", "\t"] = "\t",
+    has_header: bool = True,
+    has_rownames: bool = True,
+    probs: Optional[str] = None,
+    weights: Optional[Path] = None,
+    ties_method: TiesMethod = "average",
+    value: Optional[float] = None,
+    lag: int = 1,
+    differences: int = 1,
+    which: Optional[int] = None,
+    preserve_shape: bool = False
+) -> dict:
+    """
+    Performs a specified summary statistic on a matrix using the MatrixGenerics R package.
+
+    This tool serves as a wrapper around the bioconductor-matrixgenerics R library,
+    which provides generic functions for matrix statistics. It reads a matrix from a file,
+    applies the chosen statistical operation, and saves the result to a new file.
+
+    Args:
+        input_matrix: Path to the input matrix file (e.g., CSV or TSV).
+        operation: The summary statistic to compute.
+        output_filename: The name for the output file that will be created.
+        na_rm: If True, NA/NaN values are removed before computation.
+        delimiter: Delimiter used in the input matrix file (',' or '\t').
+        has_header: Whether the input file has a header row.
+        has_rownames: Whether the first column of the input file contains row names.
+        probs: Comma-separated string of probabilities for quantile functions (e.g., "0.25,0.5,0.75").
+        weights: Path to a single-column file of numeric weights for weighted operations.
+        ties_method: Method for handling ties in ranking functions.
+        value: The specific value to count for '*Counts' functions.
+        lag: The lag for '*Diffs' functions.
+        differences: The number of differences for '*Diffs' functions.
+        which: The order statistic to extract for '*OrderStats' functions.
+        preserve_shape: For '*Ranks' functions, if TRUE the output has the same dimensions as the input.
+    
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not input_matrix.is_file():
+        raise FileNotFoundError(f"Input matrix file not found: {input_matrix}")
+
+    if weights and not weights.is_file():
+        raise FileNotFoundError(f"Weights file not found: {weights}")
+
+    if not output_filename:
+        raise ValueError("Output filename cannot be empty.")
+
+    # --- R Script Generation ---
+    r_script = f"""
+    # Load necessary library
+    if (!require("MatrixGenerics", quietly = TRUE)) {{
+        stop("MatrixGenerics package is not installed.")
+    }}
+
+    # --- Argument Parsing ---
+    args <- commandArgs(trailingOnly = TRUE)
+    input_file <- args[1]
+    output_file <- args[2]
+    operation <- args[3]
+    na_rm <- as.logical(args[4])
+    sep <- args[5]
+    header <- as.logical(args[6])
+    rownames_col <- if (as.logical(args[7])) 1 else NULL
+    probs_str <- args[8]
+    weights_file <- args[9]
+    ties_method <- args[10]
+    value_str <- args[11]
+    lag <- as.integer(args[12])
+    differences <- as.integer(args[13])
+    which_str <- args[14]
+    preserve_shape <- as.logical(args[15])
+
+    # --- Data Loading ---
+    tryCatch({{
+        data <- read.delim(input_file, sep = sep, header = header, row.names = rownames_col, check.names = FALSE)
+        mat <- as.matrix(data)
+    }}, error = function(e) {{
+        stop(paste("Error reading input matrix:", e$message))
+    }})
+
+    # --- Dynamic Function Call ---
+    # Build the list of parameters
+    params <- list(x = mat)
+    
+    # Add common parameters if the function accepts them
+    func_args <- names(formals(operation))
+    if ("na.rm" %in% func_args) params$na.rm <- na_rm
+    if ("ties.method" %in% func_args) params$ties.method <- ties_method
+    if ("value" %in% func_args && value_str != "NULL") params$value <- as.numeric(value_str)
+    if ("lag" %in% func_args) params$lag <- lag
+    if ("differences" %in% func_args) params$differences <- differences
+    if ("which" %in% func_args && which_str != "NULL") params$which <- as.integer(which_str)
+    if ("preserveShape" %in% func_args) params$preserveShape <- preserve_shape
+
+    # Handle special parameters
+    if (grepl("Quantiles", operation) && probs_str != "NULL") {{
+        params$probs <- as.numeric(strsplit(probs_str, ",")[[1]])
+    }}
+    if (grepl("Weighted", operation) && weights_file != "NULL") {{
+        tryCatch({{
+            weights_vector <- read.table(weights_file, header = FALSE, colClasses = "numeric")[[1]]
+            params$w <- weights_vector
+        }}, error = function(e) {{
+            stop(paste("Error reading weights file:", e$message))
+        }})
+    }}
+
+    # Get the function from the package namespace
+    func <- get(operation, asNamespace("MatrixGenerics"))
+
+    # Execute the function
+    result <- do.call(func, params)
+
+    # --- Output Writing ---
+    # write.table is robust for vectors, matrices, and data.frames
+    write.table(result, file = output_file, sep = "\\t", quote = FALSE, col.names = NA)
+    """
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        temp_path = Path(temp_dir)
+        r_script_path = temp_path / "matrix_op.R"
+        with open(r_script_path, "w") as f:
+            f.write(r_script)
+
+        output_path = Path.cwd() / output_filename
+
+        # --- Command Construction ---
+        cmd = [
+            "Rscript",
+            str(r_script_path),
+            str(input_matrix),
+            str(output_path),
+            operation,
+            str(na_rm).upper(),
+            "\\t" if delimiter == "\t" else ",",
+            str(has_header).upper(),
+            str(has_rownames).upper(),
+            probs if probs else "NULL",
+            str(weights) if weights else "NULL",
+            ties_method,
+            str(value) if value is not None else "NULL",
+            str(lag),
+            str(differences),
+            str(which) if which is not None else "NULL",
+            str(preserve_shape).upper()
+        ]
+
+        # --- Subprocess Execution ---
+        try:
+            process = subprocess.run(
+                cmd,
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            stdout = process.stdout
+            stderr = process.stderr
+        except subprocess.CalledProcessError as e:
+            return {
+                "command_executed": " ".join(map(str, cmd)),
+                "stdout": e.stdout,
+                "stderr": e.stderr,
+                "output_files": [],
+                "error": "R script execution failed."
+            }
+        except FileNotFoundError:
+            return {
+                "command_executed": " ".join(map(str, cmd)),
+                "stdout": "",
+                "stderr": "Rscript command not found. Please ensure R is installed and in your PATH.",
+                "output_files": [],
+                "error": "Dependency not found."
+            }
+
+    # --- Structured Result Return ---
+    return {
+        "command_executed": " ".join(map(str, cmd)),
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [str(output_path)]
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-matrixgenerics/app/bioconductor-matrixgenerics_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-matrixgenerics/app/bioconductor-matrixgenerics_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_matrixgenerics'
+
+
+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-matrixgenerics/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-matrixgenerics/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-mia/app/bioconductor-mia_server.py

@@ -0,0 +1,134 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_mia'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_mia_r_script(
+    r_script_content: str,
+    input_rds_path: Optional[Path] = None,
+    output_rds_path: Optional[Path] = None,
+    working_directory: Optional[Path] = None,
+) -> Dict[str, Any]:
+    """
+    Executes an R script that utilizes the bioconductor-mia package for microbiome analysis.
+
+    This tool provides a generic interface to run arbitrary R code that is expected
+    to use the 'mia' Bioconductor package. It allows for loading an input R data
+    object (e.g., a SummarizedExperiment saved as .rds) and saving an output R data
+    object.
+
+    Args:
+        r_script_content: A string containing the R script to be executed.
+                          The script should assume 'mia' is loaded.
+                          If `input_rds_path` is provided, the loaded object will
+                          be available as `input_data`.
+                          If `output_rds_path` is provided, the script should
+                          assign the object to be saved to a variable named
+                          `output_data`.
+        input_rds_path: Optional path to an R data object (.rds file) to be loaded
+                        into the R environment before executing the script.
+                        The object will be loaded as 'input_data'.
+        output_rds_path: Optional path where the R script should save an R data
+                         object (e.g., a SummarizedExperiment) using saveRDS().
+                         The R script must assign the object to be saved to a
+                         variable named 'output_data'.
+        working_directory: Optional path to a directory where the R script will be
+                           executed. This can be useful for scripts that use
+                           relative paths for additional input/output files.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any
+        generated output files.
+    """
+    if not r_script_content.strip():
+        raise ValueError("r_script_content cannot be empty.")
+
+    output_files: List[Path] = []
+    
+    # Validate input_rds_path if provided
+    if input_rds_path:
+        if not input_rds_path.is_file():
+            raise FileNotFoundError(f"Input RDS file not found: {input_rds_path}")
+        if not input_rds_path.suffix == ".rds":
+            raise ValueError(f"Input RDS file must have a '.rds' extension: {input_rds_path}")
+
+    # Prepare output_rds_path if provided
+    if output_rds_path:
+        output_rds_path = output_rds_path.resolve() # Ensure absolute path
+        output_rds_path.parent.mkdir(parents=True, exist_ok=True) # Create parent dirs
+        if not output_rds_path.suffix == ".rds":
+            raise ValueError(f"Output RDS file must have a '.rds' extension: {output_rds_path}")
+        output_files.append(output_rds_path)
+
+    # Create a temporary directory for the R script
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+        
+        # Determine the actual working directory for the R process
+        actual_working_dir = working_directory if working_directory else tmpdir_path
+        actual_working_dir.mkdir(parents=True, exist_ok=True) # Ensure it exists
+
+        r_script_file = tmpdir_path / "mia_script.R"
+        
+        # Construct the full R script content
+        full_r_script_lines = [
+            "library(mia)",
+            "options(warn=-1)", # Suppress warnings for cleaner output
+        ]
+
+        if input_rds_path:
+            full_r_script_lines.append(f"input_data <- readRDS('{input_rds_path.resolve()}')")
+        
+        full_r_script_lines.append(r_script_content)
+
+        if output_rds_path:
+            # The user's script is expected to assign the result to 'output_data'
+            # We will then save 'output_data' to the specified path.
+            full_r_script_lines.append(f"if (exists('output_data')) {{ saveRDS(output_data, '{output_rds_path}') }} else {{ message('Warning: output_data variable not found, no RDS file saved.') }}")
+
+        r_script_file.write_text("\n".join(full_r_script_lines))
+
+        command = ["Rscript", str(r_script_file)]
+
+        try:
+            process = subprocess.run(
+                command,
+                cwd=actual_working_dir,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            stdout = process.stdout
+            stderr = process.stderr
+        except subprocess.CalledProcessError as e:
+            return {
+                "command_executed": " ".join(command),
+                "stdout": e.stdout,
+                "stderr": e.stderr,
+                "error": f"Rscript execution failed with exit code {e.returncode}",
+                "output_files": [],
+            }
+        except FileNotFoundError:
+            return {
+                "command_executed": " ".join(command),
+                "stdout": "",
+                "stderr": "Error: Rscript command not found. Is R installed and in PATH?",
+                "error": "Rscript not found",
+                "output_files": [],
+            }
+
+    return {
+        "command_executed": " ".join(command),
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [str(p) for p in output_files],
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-mia/app/bioconductor-mia_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-mia/app/bioconductor-mia_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_mia'
+
+
+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-mia/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-mia/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-org.ce.eg.db/Dockerfile

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

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

@@ -0,0 +1,380 @@
+import subprocess
+import textwrap
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# MCP decorator is not imported as per instructions, but assumed to be present.
+# from mcp import tool as mcp_tool
+# For the purpose of this script, we'll define a dummy decorator.
+class mcp:
+    def tool():
+        def decorator(f):
+            return f
+        return decorator
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_org_ce_eg_db'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def select_annotations(
+    keys: List[str],
+    keytype: str,
+    columns: List[str],
+    output_file: str,
+    output_format: str = "tsv",
+) -> Dict[str, Any]:
+    """
+    Perform a complex query on the org.Ce.eg.db C. elegans annotation database using the select() method.
+    This returns a table of mappings between the provided keys and requested columns.
+
+    Args:
+        keys: List of identifiers to look up (e.g., ["172469", "172470"] or ["skn-1", "gfp"]).
+        keytype: The type of the input keys (e.g., "ENTREZID", "SYMBOL", "WORMBASE", "ENSEMBL").
+        columns: The annotation types to retrieve (e.g., ["GO", "EVIDENCE", "ONTOLOGY", "GENENAME"]).
+        output_file: Path to save the resulting table.
+        output_format: Format of the output file ("tsv" or "csv"). Defaults to "tsv".
+    """
+    # Input validation
+    if not keys:
+        raise ValueError("The 'keys' list cannot be empty.")
+    if not keytype:
+        raise ValueError("The 'keytype' parameter must be specified.")
+    if not columns:
+        raise ValueError("The 'columns' list cannot be empty.")
+    
+    valid_formats = ["tsv", "csv"]
+    if output_format not in valid_formats:
+        raise ValueError(f"output_format must be one of {valid_formats}")
+
+    out_path = Path(output_file).resolve()
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Prepare R vectors safely
+    keys_str = ", ".join([f'"{k}"' for k in keys])
+    cols_str = ", ".join([f'"{c}"' for c in columns])
+    
+    # The R script uses f-string formatting. Literal curly braces for R code blocks
+    # must be escaped by doubling them (e.g., {{ and }}).
+    r_script = textwrap.dedent(f"""
+        suppressPackageStartupMessages(library(org.Ce.eg.db))
+        suppressPackageStartupMessages(library(AnnotationDbi))
+
+        # Validate inputs in R
+        if (!("{keytype}" %in% keytypes(org.Ce.eg.db))) {{{{
+            stop(paste("Invalid keytype:", "{keytype}"))
+        }}}}
+        
+        requested_cols <- c({cols_str})
+        valid_cols <- columns(org.Ce.eg.db)
+        if (!all(requested_cols %in% valid_cols)) {{{{
+            invalid_ones <- requested_cols[!(requested_cols %in% valid_cols)]
+            stop(paste("Invalid columns:", paste(invalid_ones, collapse=", ")))
+        }}}}
+
+        res <- tryCatch({{{{
+            AnnotationDbi::select(
+                org.Ce.eg.db,
+                keys = c({keys_str}),
+                columns = requested_cols,
+                keytype = "{keytype}"
+            )
+        }}}}, error = function(e) {{{{
+            stop(paste("Select failed:", e$message))
+        }}}})
+
+        if ("{output_format}" == "tsv") {{{{
+            write.table(res, file = "{out_path}", sep = "\\t", quote = FALSE, row.names = FALSE)
+        }}}} else {{{{
+            write.csv(res, file = "{out_path}", quote = FALSE, row.names = FALSE)
+        }}}}
+    """)
+
+    command_str = f"Rscript -e \"{r_script}\""
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+        return {
+            "command_executed": "Rscript -e 'AnnotationDbi::select(...)'",
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "output_files": [str(out_path)]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": "Rscript -e 'AnnotationDbi::select(...)'",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed. Stderr: {e.stderr}"
+        }
+
+@mcp.tool()
+def map_ids(
+    keys: List[str],
+    keytype: str,
+    column: str,
+    multi_vals: str = "first",
+) -> Dict[str, Any]:
+    """
+    Map identifiers from one type to another using the mapIds() method.
+    This is optimized for 1-to-1 or 1-to-many mapping.
+
+    Args:
+        keys: List of identifiers to map.
+        keytype: The type of the input keys (e.g., "WORMBASE").
+        column: The type of identifier to map to (e.g., "SYMBOL").
+        multi_vals: How to handle multiple matches. Options: "first", "list", "filter", "asNA", "CharacterList".
+    """
+    if not keys:
+        raise ValueError("The 'keys' list cannot be empty.")
+    
+    valid_multi = ["first", "list", "filter", "asNA", "CharacterList"]
+    if multi_vals not in valid_multi:
+        raise ValueError(f"multi_vals must be one of {valid_multi}")
+
+    keys_str = ", ".join([f'"{k}"' for k in keys])
+    
+    r_script = textwrap.dedent(f"""
+        suppressPackageStartupMessages(library(org.Ce.eg.db))
+        suppressPackageStartupMessages(library(AnnotationDbi))
+
+        res <- mapIds(
+            org.Ce.eg.db,
+            keys = c({keys_str}),
+            column = "{column}",
+            keytype = "{keytype}",
+            multiVals = "{multi_vals}"
+        )
+        
+        # Convert to a structured key-value output for easy parsing
+        cat("---RESULT_START---\\n")
+        if (is.list(res) || is(res, "CharacterList")) {{{{
+            for (n in names(res)) {{{{
+                # Handle NULLs which represent no mapping
+                value <- if (is.null(res[[n]])) "NA" else paste(res[[n]], collapse=",")
+                cat(n, ":", value, "\\n")
+            }}}}
+        }}}} else {{{{
+            for (n in names(res)) {{{{
+                value <- if (is.na(res[n])) "NA" else res[n]
+                cat(n, ":", value, "\\n")
+            }}}}
+        }}}}
+        cat("---RESULT_END---\\n")
+    """)
+
+    command_str = "Rscript -e 'AnnotationDbi::mapIds(...)'"
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script],
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+        
+        # Parse the structured output from R
+        output_str = process.stdout
+        result_block = output_str.split("---RESULT_START---\n")[-1].split("---RESULT_END---")[0].strip()
+        mappings = {}
+        if result_block:
+            for line in result_block.split('\n'):
+                parts = line.split(':', 1)
+                if len(parts) == 2:
+                    key = parts[0].strip()
+                    val_str = parts[1].strip()
+                    if val_str == "NA":
+                        mappings[key] = None
+                    else:
+                        values = [v.strip() for v in val_str.split(',')]
+                        if multi_vals in ["first", "asNA"] and len(values) == 1:
+                             mappings[key] = values[0]
+                        else:
+                             mappings[key] = values
+
+        return {
+            "command_executed": command_str,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "mappings": mappings
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed. Stderr: {e.stderr}"
+        }
+
+@mcp.tool()
+def list_resources() -> Dict[str, Any]:
+    """
+    List all available keytypes and columns (annotation types) in the org.Ce.eg.db package.
+    """
+    r_script = textwrap.dedent("""
+        suppressPackageStartupMessages(library(org.Ce.eg.db))
+        cat("---COLUMNS_START---\\n")
+        cat(paste(columns(org.Ce.eg.db), collapse=", "), "\\n")
+        cat("---COLUMNS_END---\\n")
+        cat("---KEYTYPES_START---\\n")
+        cat(paste(keytypes(org.Ce.eg.db), collapse=", "), "\\n")
+        cat("---KEYTYPES_END---\\n")
+    """)
+    
+    command_str = "Rscript -e 'columns(...); keytypes(...)'"
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script], 
+            capture_output=True, 
+            text=True, 
+            check=True,
+            encoding='utf-8'
+        )
+        
+        # Parse structured output
+        stdout_str = process.stdout
+        columns_str = stdout_str.split("---COLUMNS_START---\n")[1].split("---COLUMNS_END---")[0].strip()
+        keytypes_str = stdout_str.split("---KEYTYPES_START---\n")[1].split("---KEYTYPES_END---")[0].strip()
+        
+        return {
+            "command_executed": command_str,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "columns": columns_str.split(", ") if columns_str else [],
+            "keytypes": keytypes_str.split(", ") if keytypes_str else []
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed. Stderr: {e.stderr}"
+        }
+
+@mcp.tool()
+def get_db_metadata() -> Dict[str, Any]:
+    """
+    Retrieve metadata about the org.Ce.eg.db package, such as version, species, and data sources.
+    """
+    r_script = "suppressPackageStartupMessages(library(org.Ce.eg.db)); print(metadata(org.Ce.eg.db))"
+    command_str = f"Rscript -e \"{r_script}\""
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script], 
+            capture_output=True, 
+            text=True, 
+            check=True,
+            encoding='utf-8'
+        )
+        return {
+            "command_executed": command_str,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "metadata": process.stdout.strip().split('\n')
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed. Stderr: {e.stderr}"
+        }
+
+@mcp.tool()
+def get_available_keys(
+    keytype: str,
+    pattern: Optional[str] = None,
+    limit: int = 100
+) -> Dict[str, Any]:
+    """
+    Retrieve a list of all available keys for a specific keytype, optionally filtered by a pattern.
+
+    Args:
+        keytype: The type of keys to retrieve (e.g., "SYMBOL").
+        pattern: An optional regular expression pattern to filter keys.
+        limit: Maximum number of keys to return. Defaults to 100.
+    """
+    if limit <= 0:
+        raise ValueError("Limit must be a positive integer.")
+
+    pattern_arg = f', pattern = "{pattern}"' if pattern else ""
+    
+    r_script = textwrap.dedent(f"""
+        suppressPackageStartupMessages(library(org.Ce.eg.db))
+        all_keys <- keys(org.Ce.eg.db, keytype = "{keytype}"{pattern_arg})
+        cat(head(all_keys, {limit}), sep="\\n")
+        cat("\\n---TOTAL_COUNT:", length(all_keys), "---\\n")
+    """)
+
+    command_str = f"Rscript -e 'keys(..., keytype=\"{keytype}\")'"
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script], 
+            capture_output=True, 
+            text=True, 
+            check=True,
+            encoding='utf-8'
+        )
+        
+        # Robust parsing
+        output_str = process.stdout
+        if "---TOTAL_COUNT:" in output_str:
+            keys_part, total_part = output_str.split("---TOTAL_COUNT:")
+            keys_list = keys_part.strip().split("\n") if keys_part.strip() else []
+            total_count = int(total_part.replace("---", "").strip())
+        else:
+            keys_list = output_str.strip().split("\n") if output_str.strip() else []
+            total_count = len(keys_list)
+
+        return {
+            "command_executed": command_str,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "keys": keys_list,
+            "total_available": total_count
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed. Stderr: {e.stderr}"
+        }
+
+@mcp.tool()
+def get_species_info() -> Dict[str, Any]:
+    """
+    Get the species name for which this annotation package was designed.
+    """
+    r_script = "suppressPackageStartupMessages(library(org.Ce.eg.db)); cat(species(org.Ce.eg.db))"
+    command_str = f"Rscript -e \"{r_script}\""
+    try:
+        process = subprocess.run(
+            ["Rscript", "-e", r_script], 
+            capture_output=True, 
+            text=True, 
+            check=True,
+            encoding='utf-8'
+        )
+        return {
+            "command_executed": command_str,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "species": process.stdout.strip()
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"R script execution failed. Stderr: {e.stderr}"
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-org.ce.eg.db/app/bioconductor-org.ce.eg.db_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_org_ce_eg_db'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool(*args, **kwargs):
+        if args and callable(args[0]) and len(args) == 1 and not kwargs:
+            return args[0]
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _resolve_source_server():
+    if LOCAL_SERVER.exists() and LOCAL_SERVER.name != Path(__file__).name:
+        return LOCAL_SERVER
+    return SOURCE_SERVER
+
+
+def _load_functions():
+    source_server = _resolve_source_server()
+    code = source_server.read_text(encoding="utf-8")
+    tree = ast.parse(code, filename=str(source_server))
+    function_names = [n.name for n in tree.body if isinstance(n, ast.FunctionDef) and not n.name.startswith("_")]
+    namespace = {
+        "__name__": "__mcp_source__",
+        "mcp": _ShimMCP(),
+    }
+    exec(compile(code, str(source_server), "exec"), namespace, namespace)
+    loaded = []
+    for name in function_names:
+        fn = namespace.get(name)
+        if callable(fn):
+            loaded.append(fn)
+    return loaded
+
+
+mcp = FastMCP(SERVER_NAME)
+for _fn in _load_functions():
+    mcp.tool()(_fn)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")