Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_adapterremoval/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 adapterremoval via conda (e.g., from bioconda)
+RUN conda install -c bioconda adapterremoval -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/adapterremoval_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/adapterremoval_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/adapterremoval_server.py"]
+        

Biomni/mcp_generated/mcp_adapterremoval/app/adapterremoval_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_adapterremoval/app/adapterremoval_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_adapterremoval'
+
+
+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_adapterremoval/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_adapterremoval/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_adapterremoval/requirements.txt

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

Biomni/mcp_generated/mcp_alfred/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 alfred via conda (e.g., from bioconda)
+RUN conda install -c bioconda alfred -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/alfred_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/alfred_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/alfred_server.py"]
+        

Biomni/mcp_generated/mcp_alfred/app/alfred_server.py

@@ -0,0 +1,638 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Literal, Optional
+
+# MCP-related decorators are assumed to be available in the environment.
+#
+# For local testing, you can create a dummy decorator:
+#
+# def mcp_tool_dummy(*args, **kwargs):
+#     def decorator(func):
+#         return func
+#     return decorator
+#
+# mcp = type("mcp", (), {"tool": mcp_tool_dummy})
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_alfred'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def alfred_stats(
+    in_bam: Path,
+    ref: Path,
+    outfile: Optional[Path] = None,
+    bed: Optional[Path] = None,
+    threads: int = 1,
+    minmapq: int = 0,
+    flag: int = 0,
+    fflag: int = 1540,
+    coverage: Optional[Path] = None,
+    dist: Optional[Path] = None,
+    sampleid: Optional[str] = None,
+    libid: Optional[str] = None,
+    readgroup: Optional[str] = None,
+    uncompressed: bool = False,
+):
+    """
+    Compute alignment summary statistics for a BAM file.
+
+    Args:
+        in_bam: Input BAM file.
+        ref: Reference FASTA file.
+        outfile: Output file for alignment metrics (e.g., metrics.tsv.gz). Defaults to stdout.
+        bed: BED file with regions of interest.
+        threads: Number of threads to use.
+        minmapq: Minimum mapping quality for reads to be considered.
+        flag: Required SAM flag.
+        fflag: Filtering SAM flag (reads with these flags will be ignored).
+        coverage: Output file for coverage statistics (e.g., cov.txt.gz).
+        dist: Output file for insert size distribution (e.g., dist.txt.gz).
+        sampleid: Sample ID to be used in the output.
+        libid: Library ID to be used in the output.
+        readgroup: Read-group ID to be used in the output.
+        uncompressed: Write uncompressed output files.
+    """
+    if not in_bam.exists():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+    if not ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {ref}")
+    if bed and not bed.exists():
+        raise FileNotFoundError(f"BED file not found: {bed}")
+    if threads < 1:
+        raise ValueError("Number of threads must be at least 1.")
+
+    cmd = ["alfred", "stats", "-r", str(ref)]
+    output_files = []
+
+    if outfile:
+        cmd.extend(["-o", str(outfile)])
+        output_files.append(str(outfile))
+    if bed:
+        cmd.extend(["-b", str(bed)])
+    if threads > 1:
+        cmd.extend(["-p", str(threads)])
+    if minmapq != 0:
+        cmd.extend(["-m", str(minmapq)])
+    if flag != 0:
+        cmd.extend(["-f", str(flag)])
+    if fflag != 1540:
+        cmd.extend(["-F", str(fflag)])
+    if coverage:
+        cmd.extend(["-c", str(coverage)])
+        output_files.append(str(coverage))
+    if dist:
+        cmd.extend(["-d", str(dist)])
+        output_files.append(str(dist))
+    if sampleid:
+        cmd.extend(["-s", sampleid])
+    if libid:
+        cmd.extend(["-l", libid])
+    if readgroup:
+        cmd.extend(["-g", readgroup])
+    if uncompressed:
+        cmd.append("-u")
+
+    cmd.append(str(in_bam))
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred stats failed",
+            "return_code": e.returncode,
+        }
+
+
+@mcp.tool()
+def alfred_count(
+    in_bam: Path,
+    ref: Path,
+    bed: Optional[Path] = None,
+    gtf: Optional[Path] = None,
+    outfile: Optional[Path] = None,
+    threads: int = 1,
+    minmapq: int = 0,
+    flag: int = 0,
+    fflag: int = 1540,
+    sampleid: Optional[str] = None,
+    libid: Optional[str] = None,
+    readgroup: Optional[str] = None,
+    uncompressed: bool = False,
+    feature: str = "exon",
+    id_attribute: str = "gene_id",
+    stranded: Literal[0, 1, 2] = 0,
+    antisense: bool = False,
+):
+    """
+    Count reads in genomic features from a BAM file.
+
+    Args:
+        in_bam: Input BAM file.
+        ref: Reference FASTA file.
+        bed: BED file with features. Provide either 'bed' or 'gtf'.
+        gtf: GTF file with features. Provide either 'bed' or 'gtf'.
+        outfile: Output file for feature counts (e.g., counts.tsv.gz). Defaults to stdout.
+        threads: Number of threads to use.
+        minmapq: Minimum mapping quality.
+        flag: Required SAM flag.
+        fflag: Filtering SAM flag.
+        sampleid: Sample ID.
+        libid: Library ID.
+        readgroup: Read-group ID.
+        uncompressed: Write uncompressed output.
+        feature: GTF feature to count (e.g., 'exon').
+        id_attribute: GTF identifier to aggregate by (e.g., 'gene_id').
+        stranded: Strandedness (0: unstranded, 1: forward, 2: reverse).
+        antisense: Count antisense reads.
+    """
+    if not in_bam.exists():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+    if not ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {ref}")
+    if bed and gtf:
+        raise ValueError("Parameters 'bed' and 'gtf' are mutually exclusive.")
+    if not bed and not gtf:
+        raise ValueError("Either 'bed' or 'gtf' must be provided.")
+    if bed and not bed.exists():
+        raise FileNotFoundError(f"BED file not found: {bed}")
+    if gtf and not gtf.exists():
+        raise FileNotFoundError(f"GTF file not found: {gtf}")
+    if threads < 1:
+        raise ValueError("Number of threads must be at least 1.")
+
+    cmd = ["alfred", "count", "-r", str(ref)]
+    output_files = []
+
+    if bed:
+        cmd.extend(["-b", str(bed)])
+    if gtf:
+        cmd.extend(["-j", str(gtf)])
+    if outfile:
+        cmd.extend(["-o", str(outfile)])
+        output_files.append(str(outfile))
+    if threads > 1:
+        cmd.extend(["-p", str(threads)])
+    if minmapq != 0:
+        cmd.extend(["-m", str(minmapq)])
+    if flag != 0:
+        cmd.extend(["-f", str(flag)])
+    if fflag != 1540:
+        cmd.extend(["-F", str(fflag)])
+    if sampleid:
+        cmd.extend(["-s", sampleid])
+    if libid:
+        cmd.extend(["-l", libid])
+    if readgroup:
+        cmd.extend(["-g", readgroup])
+    if uncompressed:
+        cmd.append("-u")
+    if feature != "exon":
+        cmd.extend(["-e", feature])
+    if id_attribute != "gene_id":
+        cmd.extend(["-i", id_attribute])
+    if stranded != 0:
+        cmd.extend(["-a", str(stranded)])
+    if antisense:
+        cmd.append("-z")
+
+    cmd.append(str(in_bam))
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred count failed",
+            "return_code": e.returncode,
+        }
+
+
+@mcp.tool()
+def alfred_annotate(
+    in_vcf: Path,
+    in_bam: Path,
+    outfile: Path,
+    ref: Path,
+    bed: Optional[Path] = None,
+    gtf: Optional[Path] = None,
+    threads: int = 1,
+    minmapq: int = 0,
+    flag: int = 0,
+    fflag: int = 1540,
+    feature: str = "exon",
+    id_attribute: str = "gene_id",
+    annotation_type: Literal["INFO", "FORMAT"] = "FORMAT",
+    field: str = "FE",
+):
+    """
+    Annotate variants in a VCF/BCF file with feature overlaps from a BAM file.
+
+    Args:
+        in_vcf: Input VCF/BCF file.
+        in_bam: Input BAM file.
+        outfile: Output VCF/BCF file.
+        ref: Reference FASTA file.
+        bed: BED file with features. Provide either 'bed' or 'gtf'.
+        gtf: GTF file with features. Provide either 'bed' or 'gtf'.
+        threads: Number of threads to use.
+        minmapq: Minimum mapping quality.
+        flag: Required SAM flag.
+        fflag: Filtering SAM flag.
+        feature: GTF feature to count (e.g., 'exon').
+        id_attribute: GTF identifier to aggregate by (e.g., 'gene_id').
+        annotation_type: Annotation type ('INFO' or 'FORMAT').
+        field: Annotation field name.
+    """
+    if not in_vcf.exists():
+        raise FileNotFoundError(f"Input VCF/BCF file not found: {in_vcf}")
+    if not in_bam.exists():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+    if not ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {ref}")
+    if bed and gtf:
+        raise ValueError("Parameters 'bed' and 'gtf' are mutually exclusive.")
+    if not bed and not gtf:
+        raise ValueError("Either 'bed' or 'gtf' must be provided.")
+    if bed and not bed.exists():
+        raise FileNotFoundError(f"BED file not found: {bed}")
+    if gtf and not gtf.exists():
+        raise FileNotFoundError(f"GTF file not found: {gtf}")
+    if threads < 1:
+        raise ValueError("Number of threads must be at least 1.")
+
+    cmd = ["alfred", "annotate", "-o", str(outfile), "-r", str(ref)]
+    output_files = [str(outfile)]
+
+    if bed:
+        cmd.extend(["-b", str(bed)])
+    if gtf:
+        cmd.extend(["-j", str(gtf)])
+    if threads > 1:
+        cmd.extend(["-p", str(threads)])
+    if minmapq != 0:
+        cmd.extend(["-m", str(minmapq)])
+    if flag != 0:
+        cmd.extend(["-f", str(flag)])
+    if fflag != 1540:
+        cmd.extend(["-F", str(fflag)])
+    if feature != "exon":
+        cmd.extend(["-e", feature])
+    if id_attribute != "gene_id":
+        cmd.extend(["-i", id_attribute])
+    if annotation_type != "FORMAT":
+        cmd.extend(["-t", annotation_type])
+    if field != "FE":
+        cmd.extend(["-a", field])
+
+    cmd.extend([str(in_vcf), str(in_bam)])
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred annotate failed",
+            "return_code": e.returncode,
+        }
+
+
+@mcp.tool()
+def alfred_qc(
+    input_bams: List[Path],
+    outfile: Path,
+    ref: Path,
+    bed: Optional[Path] = None,
+    gtf: Optional[Path] = None,
+    threads: int = 1,
+    minmapq: int = 0,
+    flag: int = 0,
+    fflag: int = 1540,
+    contigs: Optional[str] = None,
+    feature: str = "exon",
+    id_attribute: str = "gene_id",
+    stranded: Literal[0, 1, 2] = 0,
+    antisense: bool = False,
+    uncompressed: bool = False,
+    sites: Optional[Path] = None,
+    genome: Optional[Path] = None,
+):
+    """
+    Generate a multi-sample QC report from one or more BAM files.
+
+    Args:
+        input_bams: List of input BAM files.
+        outfile: Output file for QC metrics (e.g., out.qc.json.gz).
+        ref: Reference FASTA file.
+        bed: BED file with regions of interest.
+        gtf: GTF file with features.
+        threads: Number of threads to use.
+        minmapq: Minimum mapping quality.
+        flag: Required SAM flag.
+        fflag: Filtering SAM flag.
+        contigs: Comma-separated list of contigs to include.
+        feature: GTF feature to count (e.g., 'exon').
+        id_attribute: GTF identifier to aggregate by (e.g., 'gene_id').
+        stranded: Strandedness (0: unstranded, 1: forward, 2: reverse).
+        antisense: Count antisense reads.
+        uncompressed: Write uncompressed output.
+        sites: VCF/BCF file with sites of interest.
+        genome: Genome accessibility file.
+    """
+    if not input_bams:
+        raise ValueError("At least one input BAM file is required.")
+    for bam in input_bams:
+        if not bam.exists():
+            raise FileNotFoundError(f"Input BAM file not found: {bam}")
+    if not ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {ref}")
+    if bed and not bed.exists():
+        raise FileNotFoundError(f"BED file not found: {bed}")
+    if gtf and not gtf.exists():
+        raise FileNotFoundError(f"GTF file not found: {gtf}")
+    if sites and not sites.exists():
+        raise FileNotFoundError(f"Sites VCF/BCF file not found: {sites}")
+    if genome and not genome.exists():
+        raise FileNotFoundError(f"Genome accessibility file not found: {genome}")
+    if threads < 1:
+        raise ValueError("Number of threads must be at least 1.")
+
+    cmd = ["alfred", "qc", "-o", str(outfile), "-r", str(ref)]
+    output_files = [str(outfile)]
+
+    if bed:
+        cmd.extend(["-b", str(bed)])
+    if gtf:
+        cmd.extend(["-j", str(gtf)])
+    if threads > 1:
+        cmd.extend(["-p", str(threads)])
+    if minmapq != 0:
+        cmd.extend(["-m", str(minmapq)])
+    if flag != 0:
+        cmd.extend(["-f", str(flag)])
+    if fflag != 1540:
+        cmd.extend(["-F", str(fflag)])
+    if contigs:
+        cmd.extend(["-c", contigs])
+    if feature != "exon":
+        cmd.extend(["-e", feature])
+    if id_attribute != "gene_id":
+        cmd.extend(["-i", id_attribute])
+    if stranded != 0:
+        cmd.extend(["-a", str(stranded)])
+    if antisense:
+        cmd.append("-z")
+    if uncompressed:
+        cmd.append("-u")
+    if sites:
+        cmd.extend(["-s", str(sites)])
+    if genome:
+        cmd.extend(["-g", str(genome)])
+
+    cmd.extend([str(bam) for bam in input_bams])
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred qc failed",
+            "return_code": e.returncode,
+        }
+
+
+@mcp.tool()
+def alfred_merge(
+    input_qc_files: List[Path], outfile: Path, uncompressed: bool = False
+):
+    """
+    Merge multiple alfred QC files.
+
+    Args:
+        input_qc_files: List of input QC JSON files (e.g., *.qc.json.gz).
+        outfile: Output file for merged QC metrics (e.g., out.qc.json.gz).
+        uncompressed: Write uncompressed output.
+    """
+    if not input_qc_files:
+        raise ValueError("At least one input QC file is required.")
+    for qc_file in input_qc_files:
+        if not qc_file.exists():
+            raise FileNotFoundError(f"Input QC file not found: {qc_file}")
+
+    cmd = ["alfred", "merge", "-o", str(outfile)]
+    output_files = [str(outfile)]
+
+    if uncompressed:
+        cmd.append("-u")
+
+    cmd.extend([str(f) for f in input_qc_files])
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred merge failed",
+            "return_code": e.returncode,
+        }
+
+
+@mcp.tool()
+def alfred_track(
+    in_bam: Path,
+    ref: Path,
+    outfile: Optional[Path] = None,
+    bed: Optional[Path] = None,
+    threads: int = 1,
+    minmapq: int = 0,
+    flag: int = 0,
+    fflag: int = 1540,
+    step: int = 1000,
+    window: int = 1000,
+    uncompressed: bool = False,
+):
+    """
+    Create a bedGraph track from a BAM file.
+
+    Args:
+        in_bam: Input BAM file.
+        ref: Reference FASTA file.
+        outfile: Output bedGraph file (e.g., track.bedGraph.gz). Defaults to stdout.
+        bed: BED file with regions of interest.
+        threads: Number of threads to use.
+        minmapq: Minimum mapping quality.
+        flag: Required SAM flag.
+        fflag: Filtering SAM flag.
+        step: Step size for coverage computation.
+        window: Window size for coverage computation.
+        uncompressed: Write uncompressed output.
+    """
+    if not in_bam.exists():
+        raise FileNotFoundError(f"Input BAM file not found: {in_bam}")
+    if not ref.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {ref}")
+    if bed and not bed.exists():
+        raise FileNotFoundError(f"BED file not found: {bed}")
+    if threads < 1:
+        raise ValueError("Number of threads must be at least 1.")
+    if step <= 0 or window <= 0:
+        raise ValueError("Step and window sizes must be positive.")
+
+    cmd = ["alfred", "track", "-r", str(ref)]
+    output_files = []
+
+    if outfile:
+        cmd.extend(["-o", str(outfile)])
+        output_files.append(str(outfile))
+    if bed:
+        cmd.extend(["-b", str(bed)])
+    if threads > 1:
+        cmd.extend(["-p", str(threads)])
+    if minmapq != 0:
+        cmd.extend(["-m", str(minmapq)])
+    if flag != 0:
+        cmd.extend(["-f", str(flag)])
+    if fflag != 1540:
+        cmd.extend(["-F", str(fflag)])
+    if step != 1000:
+        cmd.extend(["-s", str(step)])
+    if window != 1000:
+        cmd.extend(["-w", str(window)])
+    if uncompressed:
+        cmd.append("-u")
+
+    cmd.append(str(in_bam))
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred track failed",
+            "return_code": e.returncode,
+        }
+
+
+@mcp.tool()
+def alfred_motif(
+    ref_fa: Path,
+    motif: str,
+    outfile: Optional[Path] = None,
+    mincount: int = 1,
+    uncompressed: bool = False,
+):
+    """
+    Search for motifs in a FASTA file.
+
+    Args:
+        ref_fa: Reference FASTA file.
+        motif: Motif to search for.
+        outfile: Output BED file (e.g., motif.bed.gz). Defaults to stdout.
+        mincount: Minimum number of motif repeats.
+        uncompressed: Write uncompressed output.
+    """
+    if not ref_fa.exists():
+        raise FileNotFoundError(f"Reference FASTA file not found: {ref_fa}")
+    if not motif:
+        raise ValueError("Motif string cannot be empty.")
+    if mincount < 1:
+        raise ValueError("Minimum count must be at least 1.")
+
+    cmd = ["alfred", "motif", "-m", motif]
+    output_files = []
+
+    if outfile:
+        cmd.extend(["-o", str(outfile)])
+        output_files.append(str(outfile))
+    if mincount != 1:
+        cmd.extend(["-c", str(mincount)])
+    if uncompressed:
+        cmd.append("-u")
+
+    cmd.append(str(ref_fa))
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Alfred motif failed",
+            "return_code": e.returncode,
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_alfred/app/alfred_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_alfred/app/alfred_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_alfred'
+
+
+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_alfred/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_alfred/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_alfred/requirements.txt

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

Biomni/mcp_generated/mcp_aria2/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 aria2 via conda (e.g., from bioconda)
+RUN conda install -c bioconda aria2 -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 aria2_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/aria2_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/aria2_server.py"]
+        

Biomni/mcp_generated/mcp_aria2/app/aria2_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_aria2/app/aria2_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_aria2'
+
+
+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_aria2/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_augur/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-biocfilecache/app/bioconductor-biocfilecache_server.py

@@ -0,0 +1,314 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import List, Literal, Optional, Dict
+
+# This is a placeholder for the actual MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(func):
+            return func
+        return decorator
+
+def _validate_cache_path(cache_path: Path, check_exists: bool = True) -> None:
+    """Helper function to validate the cache path."""
+    if check_exists and not cache_path.is_dir():
+        raise FileNotFoundError(f"BiocFileCache directory not found at '{cache_path}'")
+
+def _r_string_vector(items: List[str]) -> str:
+    """Converts a Python list of strings to an R character vector string."""
+    if not items:
+        return "c()"
+    # Escape single quotes for R: ' -> \'
+    escaped_items = [item.replace("'", "\\'") for item in items]
+    quoted_items = [f"'{item}'" for item in escaped_items]
+    return f"c({', '.join(quoted_items)})"
+
+def _run_r_command(r_command: str) -> Dict:
+    """Executes an R command and returns a structured response."""
+    command = ["Rscript", "-e", r_command]
+    command_str = " ".join(command)
+    try:
+        result = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+        return {
+            "command_executed": command_str,
+            "stdout": result.stdout.strip(),
+            "stderr": result.stderr.strip(),
+        }
+    except FileNotFoundError:
+        logging.error("Rscript not found. R must be installed and in the system's PATH.")
+        raise RuntimeError("Rscript not found. R must be installed and in the system's PATH.")
+    except subprocess.CalledProcessError as e:
+        logging.error(f"R script execution failed.\nStderr: {e.stderr}\nStdout: {e.stdout}")
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout.strip(),
+            "stderr": e.stderr.strip(),
+            "error": "R script execution failed."
+        }
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_biocfilecache'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def biocfilecache_new(cache_path: Path) -> Dict:
+    """
+    Creates a new, empty BiocFileCache at the specified location.
+
+    Args:
+        cache_path: The directory path where the cache will be created.
+                    The parent directory must exist, and the target path must not.
+
+    Returns:
+        A dictionary containing the command executed, stdout (the cache path),
+        stderr, and the path to the created cache directory.
+    """
+    if cache_path.exists():
+        raise ValueError(f"Cache path '{cache_path}' already exists. Cannot create a new cache here.")
+    if not cache_path.parent.is_dir():
+        raise FileNotFoundError(f"Parent directory '{cache_path.parent}' does not exist.")
+
+    # Use forward slashes for R path compatibility
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- bfcnew('{safe_cache_path}', ask=FALSE); "
+        f"cat(bfcpath(bfc))"
+    )
+    
+    response = _run_r_command(r_command)
+    if "error" not in response:
+        response["output_files"] = {"cache_directory": str(cache_path)}
+    return response
+
+@mcp.tool()
+def biocfilecache_add(
+    cache_path: Path,
+    rname: str,
+    fpath: str,
+    action: Literal["copy", "move", "asis"] = "copy",
+    rtype: Literal["web", "local"] = "web"
+) -> Dict:
+    """
+    Adds a resource to the BiocFileCache.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        rname: A user-friendly name for the resource.
+        fpath: The path to the resource, either a URL or a local file path.
+        action: How to handle the file. 'copy' (default), 'move', or 'asis' (for remote files).
+        rtype: The type of resource, 'web' (default) or 'local'.
+
+    Returns:
+        A dictionary containing the command executed, stdout (the new resource ID), and stderr.
+    """
+    _validate_cache_path(cache_path)
+    if rtype == "local" and not Path(fpath).exists():
+        raise FileNotFoundError(f"Local file '{fpath}' not found for adding to cache.")
+
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    # Escape single quotes and normalize path for R
+    safe_rname = rname.replace("'", "\\'")
+    safe_fpath = fpath.replace('\\', '/').replace("'", "\\'")
+    
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"rid <- bfcadd(bfc, rname='{safe_rname}', fpath='{safe_fpath}', action='{action}', rtype='{rtype}'); "
+        f"cat(rid)"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_rpath(cache_path: Path, rids: List[str]) -> Dict:
+    """
+    Retrieves the local file paths of resources from the cache using their resource IDs (rids).
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        rids: A list of resource IDs (e.g., ['BFC1', 'BFC2']) to look up.
+
+    Returns:
+        A dictionary containing the command executed, stdout (newline-separated file paths), and stderr.
+    """
+    _validate_cache_path(cache_path)
+    if not rids:
+        raise ValueError("The 'rids' list cannot be empty.")
+
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    rids_vector = _r_string_vector(rids)
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"paths <- bfcrpath(bfc, rids={rids_vector}); "
+        f"cat(paths, sep='\\n')"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_query(cache_path: Path, query: str, field: Optional[str] = None) -> Dict:
+    """
+    Queries the cache metadata using an SQL-like expression.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        query: The SQL 'WHERE' clause for filtering resources (e.g., "rname == 'my_file'").
+        field: Optional. The specific column/field to return from the query results.
+
+    Returns:
+        A dictionary containing the command executed, stdout (query results as a table), and stderr.
+    """
+    _validate_cache_path(cache_path)
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    safe_query = query.replace("'", "\\'")
+    
+    field_arg = ""
+    if field:
+        safe_field = field.replace("'", "\\'")
+        field_arg = f", field='{safe_field}'"
+    
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"res <- bfcquery(bfc, query='{safe_query}'{field_arg}); "
+        f"print(res)"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_remove(cache_path: Path, rids: List[str]) -> Dict:
+    """
+    Removes resources and their associated files from the cache.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        rids: A list of resource IDs to remove.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    _validate_cache_path(cache_path)
+    if not rids:
+        raise ValueError("The 'rids' list cannot be empty.")
+
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    rids_vector = _r_string_vector(rids)
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"bfcremove(bfc, rids={rids_vector}); "
+        f"cat('Specified resources removed.')"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_ls(cache_path: Path, pattern: Optional[str] = None) -> Dict:
+    """
+    Lists resources in the cache, optionally filtering by a regular expression.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        pattern: An optional regular expression to filter resource names (rname).
+
+    Returns:
+        A dictionary containing the command executed, stdout (a table of resources), and stderr.
+    """
+    _validate_cache_path(cache_path)
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    
+    pattern_arg = ""
+    if pattern:
+        safe_pattern = pattern.replace("'", "\\'")
+        pattern_arg = f", pattern='{safe_pattern}'"
+    
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"res <- bfcls(bfc{pattern_arg}); "
+        f"print(res)"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_update(cache_path: Path, rids: List[str]) -> Dict:
+    """
+    Updates resources in the cache by re-downloading them.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        rids: A list of resource IDs to update.
+
+    Returns:
+        A dictionary containing the command executed, stdout (updated resource info), and stderr.
+    """
+    _validate_cache_path(cache_path)
+    if not rids:
+        raise ValueError("The 'rids' list cannot be empty.")
+
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    rids_vector = _r_string_vector(rids)
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"res <- bfcupdate(bfc, rids={rids_vector}); "
+        f"print(res)"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_clean(cache_path: Path) -> Dict:
+    """
+    Cleans the cache by removing files that are no longer tracked in the database.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    _validate_cache_path(cache_path)
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"bfcclean(bfc, ask=FALSE); "
+        f"cat('Cache cleaned.')"
+    )
+    return _run_r_command(r_command)
+
+@mcp.tool()
+def biocfilecache_info(cache_path: Path, rids: Optional[List[str]] = None) -> Dict:
+    """
+    Retrieves detailed metadata for all or specified resources in the cache.
+
+    Args:
+        cache_path: Path to the BiocFileCache directory.
+        rids: Optional list of resource IDs to get information for. If None, info for all resources is returned.
+
+    Returns:
+        A dictionary containing the command executed, stdout (a table of resource info), and stderr.
+    """
+    _validate_cache_path(cache_path)
+    safe_cache_path = str(cache_path).replace('\\', '/')
+    rids_arg = f", rids={_r_string_vector(rids)}" if rids else ""
+    
+    r_command = (
+        f"library(BiocFileCache); "
+        f"bfc <- BiocFileCache('{safe_cache_path}', ask=FALSE); "
+        f"res <- bfcinfo(bfc{rids_arg}); "
+        f"print(res)"
+    )
+    return _run_r_command(r_command)
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-biocfilecache/app/bioconductor-biocfilecache_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-biocfilecache/app/bioconductor-biocfilecache_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_biocfilecache'
+
+
+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-biocfilecache/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

Biomni/mcp_generated/mcp_bioconductor-biocfilecache/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-biocgenerics/app/bioconductor-biocgenerics_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-biocgenerics/app/bioconductor-biocgenerics_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_biocgenerics'
+
+
+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-biocgenerics/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-delayedarray/requirements.txt

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

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

Biomni/mcp_generated/mcp_bioconductor-nebulosa/app/bioconductor-nebulosa_server.py

@@ -0,0 +1,185 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be imported.
+def tool(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+mcp = type("mcp", (), {"tool": tool})
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_nebulosa'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def nebulosa_plot_density(
+    object_file: Path,
+    features: List[str],
+    output_file: Path,
+    reduction: Optional[str] = None,
+    dims: Tuple[int, int] = (1, 2),
+    pal: str = "viridis",
+    joint: bool = False,
+    combine: bool = True,
+    pt_size: float = 0.1,
+    pt_shape: int = 16,
+    pt_alpha: float = 1.0,
+    dens_alpha: float = 0.5,
+    plot_width: float = 8.0,
+    plot_height: float = 6.0,
+) -> dict:
+    """
+    Generates density plots for single-cell features using the Nebulosa R package.
+
+    This tool wraps the `plot_density` function from `bioconductor-nebulosa`. It takes a
+    single-cell object (e.g., from Seurat, saved as an .rds file), a list of features
+    (e.g., genes), and generates a plot showing the expression density of these
+    features on a dimensionality reduction embedding (like UMAP or t-SNE).
+
+    Args:
+        object_file: Path to the input single-cell object file in .rds format.
+        features: A list of features (e.g., genes) to plot.
+        output_file: Path to save the output plot. Supported formats include PDF, PNG, JPEG.
+        reduction: The dimensionality reduction to use (e.g., 'umap', 'tsne').
+                   If None, the default from the object is used.
+        dims: A tuple of two integers specifying the dimensions to plot (e.g., (1, 2)).
+        pal: The color palette to use for the density plot (e.g., 'viridis', 'magma').
+        joint: If True, plots all features jointly on a single plot.
+        combine: If True and `joint` is False, combines multiple feature plots into a single grid.
+        pt_size: The size of the points in the plot.
+        pt_shape: The shape of the points (integer code).
+        pt_alpha: The transparency of the points (0.0 to 1.0).
+        dens_alpha: The transparency of the density layer (0.0 to 1.0).
+        plot_width: The width of the output plot in inches.
+        plot_height: The height of the output plot in inches.
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and a
+        mapping to the generated output plot file.
+    """
+    # --- Input Validation ---
+    if not object_file.is_file():
+        raise FileNotFoundError(f"Input object file not found: {object_file}")
+
+    if not features:
+        raise ValueError("The 'features' list cannot be empty.")
+
+    if not output_file.parent.exists():
+        raise FileNotFoundError(f"Output directory does not exist: {output_file.parent}")
+
+    if len(dims) != 2:
+        raise ValueError(f"'dims' must be a tuple of two integers, but got {dims}")
+
+    if not (0.0 <= pt_alpha <= 1.0):
+        raise ValueError(f"'pt_alpha' must be between 0.0 and 1.0, but got {pt_alpha}")
+
+    if not (0.0 <= dens_alpha <= 1.0):
+        raise ValueError(f"'dens_alpha' must be between 0.0 and 1.0, but got {dens_alpha}")
+
+    # --- R Script Generation ---
+    # Convert Python types to R syntax strings
+    features_r_str = ', '.join(f'"{f}"' for f in features)
+    reduction_r_str = f'"{reduction}"' if reduction else "NULL"
+    joint_r_str = str(joint).upper()
+    combine_r_str = str(combine).upper()
+
+    r_script_content = f"""
+    # Suppress package startup messages for cleaner output
+    suppressPackageStartupMessages(library(Nebulosa))
+    suppressPackageStartupMessages(library(Seurat)) # Assumes a Seurat object for loading
+    suppressPackageStartupMessages(library(ggplot2))
+
+    # --- Parameters from Python ---
+    object_path <- "{object_file.resolve()}"
+    output_path <- "{output_file.resolve()}"
+    features_vec <- c({features_r_str})
+    reduction_val <- {reduction_r_str}
+    dims_vec <- c({dims[0]}, {dims[1]})
+    pal_str <- "{pal}"
+    joint_bool <- {joint_r_str}
+    combine_bool <- {combine_r_str}
+    pt_size_num <- {pt_size}
+    pt_shape_num <- {pt_shape}
+    pt_alpha_num <- {pt_alpha}
+    dens_alpha_num <- {dens_alpha}
+    plot_width_num <- {plot_width}
+    plot_height_num <- {plot_height}
+
+    # --- Main Logic ---
+    cat("Loading single-cell object from:", object_path, "\\n")
+    sobj <- readRDS(object_path)
+
+    cat("Generating density plot for features:", paste(features_vec, collapse=", "), "\\n")
+    p <- plot_density(
+      object = sobj,
+      features = features_vec,
+      reduction = reduction_val,
+      dims = dims_vec,
+      pal = pal_str,
+      joint = joint_bool,
+      combine = combine_bool,
+      pt.size = pt_size_num,
+      pt.shape = pt_shape_num,
+      pt.alpha = pt_alpha_num,
+      dens.alpha = dens_alpha_num
+    )
+
+    cat("Saving plot to:", output_path, "\\n")
+    ggsave(
+      filename = output_path,
+      plot = p,
+      width = plot_width_num,
+      height = plot_height_num,
+      units = "in"
+    )
+
+    cat("Plot generation complete.\\n")
+    """
+
+    # --- Subprocess Execution ---
+    stdout_str, stderr_str = "", ""
+    command_to_run = []
+
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".R", delete=False
+        ) as tmp_script:
+            tmp_script_path = Path(tmp_script.name)
+            tmp_script.write(r_script_content)
+
+        command_to_run = ["Rscript", str(tmp_script_path)]
+        process = subprocess.run(
+            command_to_run,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout_str = process.stdout
+        stderr_str = process.stderr
+
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        stderr_str = e.stderr + f"\n--- R Script Content ---\n{r_script_content}"
+        raise RuntimeError(f"R script execution failed with exit code {e.returncode}:\n{stderr_str}")
+    finally:
+        if 'tmp_script_path' in locals() and tmp_script_path.exists():
+            tmp_script_path.unlink()
+
+    # --- Structured Result Return ---
+    return {
+        "command_executed": " ".join(command_to_run),
+        "stdout": stdout_str,
+        "stderr": stderr_str,
+        "output_files": {"density_plot": str(output_file)},
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-nebulosa/app/bioconductor-nebulosa_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-nebulosa/app/bioconductor-nebulosa_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bioconductor_nebulosa'
+
+
+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-nebulosa/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bioconductor-nebulosa/requirements.txt

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

Biomni/mcp_generated/mcp_brooklyn_plot/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 brooklyn_plot via conda (e.g., from bioconda)
+RUN conda install -c bioconda brooklyn_plot -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 brooklyn_plot_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/brooklyn_plot_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/brooklyn_plot_server.py"]
+        

Biomni/mcp_generated/mcp_brooklyn_plot/app/brooklyn_plot_server.py

@@ -0,0 +1,170 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import List, Optional, Literal, Dict, Any
+
+# Set up a logger for internal use
+logger = logging.getLogger(__name__)
+
+# @mcp.tool() decorator is assumed to be imported from the MCP framework.
+# No need to define it here.
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_brooklyn_plot'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def run_brooklyn_plot(
+    input_file: Path,
+    output_file: str,
+    input_type: Literal["vcf", "txt"],
+    title: str = "Brooklyn Plot",
+    width: int = 12,
+    height: int = 8,
+    dpi: int = 300,
+    output_format: Literal["png", "pdf", "svg", "jpg"] = "png",
+    style: str = "seaborn-whitegrid",
+    palette: str = "colorblind",
+    font_scale: float = 1.2,
+    hide_legend: bool = False,
+    show_genes: bool = False,
+    gene_fontsize: int = 8,
+    min_vaf: float = 0.0,
+    max_vaf: float = 1.0,
+    min_depth: int = 0,
+    genes_to_label: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """
+    Generates a Brooklyn plot from variant data.
+
+    A Brooklyn plot is a type of visualization used in genomics to display variant allele frequencies (VAFs)
+    of mutations across different samples or time points, often used in cancer genomics to track clonal evolution.
+    This tool takes a VCF or a tab-delimited file as input and produces a customizable plot.
+
+    Args:
+        input_file: Path to the input file containing variant data (VCF or tab-delimited text).
+        output_file: Name for the output plot file. The extension should match the chosen format.
+        input_type: Type of the input file.
+        title: Title of the plot.
+        width: Width of the plot in inches.
+        height: Height of the plot in inches.
+        dpi: Resolution of the plot in dots per inch.
+        output_format: Format of the output plot.
+        style: Style of the plot. Any valid matplotlib style is accepted.
+        palette: Color palette for the plot. Any valid seaborn palette is accepted.
+        font_scale: Font scale for the plot.
+        hide_legend: If True, hides the legend from the plot.
+        show_genes: If True, shows gene names on the plot.
+        gene_fontsize: Font size for gene names.
+        min_vaf: Minimum variant allele frequency (VAF) to include in the plot.
+        max_vaf: Maximum variant allele frequency (VAF) to include in the plot.
+        min_depth: Minimum read depth to include in the plot.
+        genes_to_label: A list of specific gene names to label on the plot.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not input_file.is_file():
+        raise FileNotFoundError(f"Input file not found: {input_file}")
+
+    if width <= 0 or height <= 0 or dpi <= 0:
+        raise ValueError("Plot dimensions (width, height, dpi) must be positive.")
+    if font_scale <= 0 or gene_fontsize <= 0:
+        raise ValueError("Font scaling parameters (font_scale, gene_fontsize) must be positive.")
+    if min_depth < 0:
+        raise ValueError("min_depth cannot be negative.")
+
+    if not (0.0 <= min_vaf <= 1.0):
+        raise ValueError(f"min_vaf must be between 0.0 and 1.0, but got {min_vaf}")
+    if not (0.0 <= max_vaf <= 1.0):
+        raise ValueError(f"max_vaf must be between 0.0 and 1.0, but got {max_vaf}")
+    if min_vaf > max_vaf:
+        raise ValueError(f"min_vaf ({min_vaf}) cannot be greater than max_vaf ({max_vaf})")
+
+    # --- Command Construction ---
+    cmd = [
+        "brooklyn_plot",
+        "-i", str(input_file),
+        "-o", output_file,
+        "-t", input_type,
+    ]
+
+    # Add optional arguments if they differ from the default
+    if title != "Brooklyn Plot":
+        cmd.extend(["--title", title])
+    if width != 12:
+        cmd.extend(["--width", str(width)])
+    if height != 8:
+        cmd.extend(["--height", str(height)])
+    if dpi != 300:
+        cmd.extend(["--dpi", str(dpi)])
+    if output_format != "png":
+        cmd.extend(["--format", output_format])
+    if style != "seaborn-whitegrid":
+        cmd.extend(["--style", style])
+    if palette != "colorblind":
+        cmd.extend(["--palette", palette])
+    if font_scale != 1.2:
+        cmd.extend(["--font_scale", str(font_scale)])
+    if gene_fontsize != 8:
+        cmd.extend(["--gene_fontsize", str(gene_fontsize)])
+    if min_vaf != 0.0:
+        cmd.extend(["--min_vaf", str(min_vaf)])
+    if max_vaf != 1.0:
+        cmd.extend(["--max_vaf", str(max_vaf)])
+    if min_depth != 0:
+        cmd.extend(["--min_depth", str(min_depth)])
+
+    # Add boolean flags if True
+    if hide_legend:
+        cmd.append("--hide_legend")
+    if show_genes:
+        cmd.append("--show_genes")
+
+    # Add list-based argument
+    if genes_to_label:
+        cmd.append("--genes_to_label")
+        cmd.extend(genes_to_label)
+
+    command_executed = " ".join(cmd)
+    logger.info(f"Executing command: {command_executed}")
+
+    # --- Subprocess Execution ---
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        
+        output_path = Path(output_file)
+        output_files = [str(output_path)] if output_path.exists() else []
+        if not output_files:
+            logger.warning(f"Output file '{output_file}' was not created by the tool.")
+
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        error_message = "Error: 'brooklyn_plot' command not found. Please ensure the tool is installed and in the system's PATH."
+        logger.error(error_message)
+        # Re-raising as a more specific error for the MCP framework
+        raise RuntimeError(error_message) from None
+    except subprocess.CalledProcessError as e:
+        logger.error(f"brooklyn_plot failed with exit code {e.returncode}")
+        # Return structured error information as per MCP guidelines
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": [],
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_brooklyn_plot/app/brooklyn_plot_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_brooklyn_plot/app/brooklyn_plot_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_brooklyn_plot'
+
+
+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_brooklyn_plot/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_brooklyn_plot/requirements.txt

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

Biomni/mcp_generated/mcp_bx-python/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 bx-python via conda (e.g., from bioconda)
+RUN conda install -c bioconda bx-python -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/bx-python_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/bx-python_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/bx-python_server.py"]
+        

Biomni/mcp_generated/mcp_bx-python/app/bx-python_server.py

@@ -0,0 +1,361 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# Note: The bx-python package is a suite of individual command-line scripts.
+# Each script is wrapped as a separate MCP tool function. The following is a
+# representative selection of these tools.
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bx_python'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bed_intersect(
+    bed1: Path,
+    bed2: Path,
+    output_file: Optional[Path] = None,
+    find_intersections: bool = False,
+    find_non_intersections: bool = False,
+    count_intersections: bool = False,
+    min_overlap_cols: int = 1,
+    preserve_intervals: bool = True,
+) -> dict:
+    """
+    Finds intersecting regions between two BED files.
+
+    This tool corresponds to the `bed_intersect.py` script.
+    It can report the intersections, non-intersections, or just the count.
+    """
+    # Input validation
+    if not bed1.is_file():
+        raise FileNotFoundError(f"Input BED file not found: {bed1}")
+    if not bed2.is_file():
+        raise FileNotFoundError(f"Second input BED file not found: {bed2}")
+    if find_intersections and find_non_intersections:
+        raise ValueError("Cannot specify both --find-intersections (-i) and --find-non-intersections (-I).")
+    if min_overlap_cols < 1:
+        raise ValueError("--min-overlap-cols must be a positive integer.")
+
+    cmd = ["bed_intersect", str(bed1), str(bed2)]
+
+    if find_intersections:
+        cmd.append("-i")
+    if find_non_intersections:
+        cmd.append("-I")
+    if count_intersections:
+        cmd.append("-c")
+    if min_overlap_cols != 1:
+        cmd.extend(["-m", str(min_overlap_cols)])
+    if not preserve_intervals:
+        cmd.append("-p") # The script's -p flag means "don't chop up intervals", which is counter-intuitive. We reverse it for clarity.
+
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture = ""
+    stderr_capture = ""
+
+    try:
+        if output_file:
+            output_files.append(str(output_file))
+            with open(output_file, "w") as f_out:
+                result = subprocess.run(
+                    cmd,
+                    check=True,
+                    text=True,
+                    stdout=f_out,
+                    stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd,
+                check=True,
+                text=True,
+                capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+
+    except FileNotFoundError:
+        raise RuntimeError("bed_intersect command not found. Is bx-python installed and in the system's PATH?")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files
+    }
+
+@mcp.tool()
+def maf_filter(
+    maf_file: Path,
+    expression: str,
+    output_file: Optional[Path] = None,
+    species: Optional[str] = None,
+    min_score: Optional[float] = None,
+    actions: Optional[str] = None,
+    score_column: Optional[str] = None,
+    score_op: Optional[str] = None,
+) -> dict:
+    """
+    Filters a MAF file based on a given expression.
+
+    This tool corresponds to the `maf_filter.py` script. It allows for complex
+    filtering of Multiple Alignment Format (MAF) files.
+    """
+    if not maf_file.is_file():
+        raise FileNotFoundError(f"Input MAF file not found: {maf_file}")
+    if score_op and score_op not in ["avg", "min", "max", "sum"]:
+        raise ValueError(f"Invalid score_op: {score_op}. Must be one of 'avg', 'min', 'max', 'sum'.")
+
+    cmd = ["maf_filter"]
+    cmd.extend(["-e", expression])
+
+    if species:
+        cmd.extend(["-s", species])
+    if min_score is not None:
+        cmd.extend(["-m", str(min_score)])
+    if actions:
+        cmd.extend(["-a", actions])
+    if score_column:
+        cmd.extend(["-S", score_column])
+    if score_op:
+        cmd.extend(["-O", score_op])
+
+    cmd.append(str(maf_file))
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture = ""
+    stderr_capture = ""
+
+    try:
+        if output_file:
+            output_files.append(str(output_file))
+            with open(output_file, "w") as f_out:
+                result = subprocess.run(
+                    cmd,
+                    check=True,
+                    text=True,
+                    stdout=f_out,
+                    stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd,
+                check=True,
+                text=True,
+                capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+
+    except FileNotFoundError:
+        raise RuntimeError("maf_filter command not found. Is bx-python installed and in the system's PATH?")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files
+    }
+
+@mcp.tool()
+def fasta_formatter(
+    fasta_file: Path,
+    output_file: Optional[Path] = None,
+    line_length: int = 80,
+) -> dict:
+    """
+    Reformats a FASTA file to a specified line length.
+
+    This tool corresponds to the `fasta_formatter.py` script.
+    """
+    if not fasta_file.is_file():
+        raise FileNotFoundError(f"Input FASTA file not found: {fasta_file}")
+    if line_length <= 0:
+        raise ValueError("line_length must be a positive integer.")
+
+    cmd = ["fasta_formatter", str(fasta_file)]
+    if line_length != 80: # Assuming 80 is the default, though the script might not have one.
+        cmd.extend(["-c", str(line_length)])
+
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture = ""
+    stderr_capture = ""
+
+    try:
+        if output_file:
+            output_files.append(str(output_file))
+            with open(output_file, "w") as f_out:
+                result = subprocess.run(
+                    cmd,
+                    check=True,
+                    text=True,
+                    stdout=f_out,
+                    stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd,
+                check=True,
+                text=True,
+                capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+
+    except FileNotFoundError:
+        raise RuntimeError("fasta_formatter command not found. Is bx-python installed and in the system's PATH?")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files
+    }
+
+@mcp.tool()
+def wig_to_bigwig(
+    wig_file: Path,
+    chrom_sizes: Path,
+    bigwig_output: Path,
+    clip_val: Optional[int] = None,
+    chunk_size: int = 1024,
+) -> dict:
+    """
+    Converts a Wiggle (WIG) format file to a BigWig file.
+
+    This tool corresponds to the `wig_to_bigwig.py` script.
+    """
+    if not wig_file.is_file():
+        raise FileNotFoundError(f"Input Wiggle file not found: {wig_file}")
+    if not chrom_sizes.is_file():
+        raise FileNotFoundError(f"Chromosome sizes file not found: {chrom_sizes}")
+    if chunk_size <= 0:
+        raise ValueError("chunk_size must be a positive integer.")
+
+    cmd = ["wig_to_bigwig", str(wig_file), str(chrom_sizes), str(bigwig_output)]
+
+    if clip_val is not None:
+        cmd.extend(["-clip", str(clip_val)])
+    if chunk_size != 1024:
+        cmd.extend(["-chunk", str(chunk_size)])
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            text=True,
+            capture_output=True
+        )
+    except FileNotFoundError:
+        raise RuntimeError("wig_to_bigwig command not found. Is bx-python installed and in the system's PATH?")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": [str(bigwig_output)]
+    }
+
+@mcp.tool()
+def get_flanking_sequences(
+    bed_file: Path,
+    genome_file: Path,
+    output_fasta: Path,
+    length: int,
+    location: str = "g",
+) -> dict:
+    """
+    Extracts flanking sequences for regions in a BED file from a genome FASTA file.
+
+    This tool corresponds to the `get_flanking_sequences.py` script.
+    """
+    if not bed_file.is_file():
+        raise FileNotFoundError(f"Input BED file not found: {bed_file}")
+    if not genome_file.is_file():
+        raise FileNotFoundError(f"Genome FASTA file not found: {genome_file}")
+    if length <= 0:
+        raise ValueError("length must be a positive integer.")
+    valid_locations = ["b", "e", "g", "G"]
+    if location not in valid_locations:
+        raise ValueError(f"Invalid location '{location}'. Must be one of {valid_locations}.")
+
+    cmd = [
+        "get_flanking_sequences",
+        str(bed_file),
+        "-g", str(genome_file),
+        "-o", str(output_fasta),
+        "-l", str(length),
+        "-L", location
+    ]
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            text=True,
+            capture_output=True
+        )
+    except FileNotFoundError:
+        raise RuntimeError("get_flanking_sequences command not found. Is bx-python installed and in the system's PATH?")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": [str(output_fasta)]
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bx-python/app/bx-python_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_bx-python/app/bx-python_server.py')
+LOCAL_SERVER = Path(__file__).with_name(SOURCE_SERVER.name)
+SERVER_NAME = 'biosci_bx_python'
+
+
+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_bx-python/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bx-python/docker-compose.yml

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

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

Biomni/mcp_generated/mcp_bx-python/requirements.txt

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

Biomni/mcp_generated/mcp_cd-hit/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 cd-hit via conda (e.g., from bioconda)
+RUN conda install -c bioconda cd-hit -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/cd-hit_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/cd-hit_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/cd-hit_server.py"]
+