Add files using upload-large-folder tool

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/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"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_adapterremoval/app/adapterremoval_server.py

@@ -0,0 +1,283 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+@mcp.tool()
+def adapter_removal(
+    file1: str,
+    file2: Optional[str] = None,
+    adapter1: str = "AGATCGGAAGAGCACACGTCTGAACTCCAGTCAC",
+    adapter2: str = "AGATCGGAAGAGCGTCGTGTAGGGAAAGAGTGTAGATCTCGGTGGTCGCCGTATCATT",
+    adapter_list: Optional[str] = None,
+    basename: str = "adapterremoval_output",
+    trimns: bool = False,
+    trimqualities: bool = False,
+    minquality: int = 2,
+    minlength: int = 15,
+    maxlength: int = 0,
+    collapse: bool = False,
+    collapse_deterministic: bool = False,
+    mismatchrate: float = 0.333,
+    minadapteroverlap: int = 0,
+    gzip: bool = False,
+    bzip2: bool = False,
+    threads: int = 1,
+    interleaved: bool = False,
+    interleaved_output: bool = False,
+    qualitybase: int = 33,
+    qualitymax: int = 41,
+    mate_separator: str = "/",
+    trim_low_complexity: bool = False,
+):
+    """
+    Perform adapter trimming, quality trimming, and optional merging of paired-end reads using AdapterRemoval v2.
+
+    Args:
+        file1: Path to the first input FASTQ file (or interleaved file).
+        file2: Path to the second input FASTQ file (optional).
+        adapter1: Sequence of the first adapter.
+        adapter2: Sequence of the second adapter.
+        adapter_list: Path to a file containing a list of adapters (one per line).
+        basename: Prefix for all output files.
+        trimns: If True, trim ambiguous bases (N) from the 5' and 3' ends.
+        trimqualities: If True, trim low-quality bases from the 5' and 3' ends.
+        minquality: Minimum quality score for trimming (default 2).
+        minlength: Minimum read length after trimming (default 15).
+        maxlength: Maximum read length; reads longer than this are discarded (0 = disabled).
+        collapse: If True, merge overlapping paired-end reads into a single consensus sequence.
+        collapse_deterministic: If True, use deterministic merging for overlapping reads.
+        mismatchrate: Maximum allowed fraction of mismatches in the overlapping region (default 0.333).
+        minadapteroverlap: Minimum overlap between read and adapter (default 0).
+        gzip: If True, compress output files using gzip.
+        bzip2: If True, compress output files using bzip2.
+        threads: Number of threads to use.
+        interleaved: If True, input file1 is treated as an interleaved paired-end file.
+        interleaved_output: If True, output paired-end reads in a single interleaved file.
+        qualitybase: Phred quality score offset (33 or 64).
+        qualitymax: Maximum Phred quality score (default 41).
+        mate_separator: Character separating mate number in read names (default '/').
+        trim_low_complexity: If True, trim low complexity (e.g. poly-A) sequences.
+    """
+    # Input validation
+    f1_path = Path(file1)
+    if not f1_path.exists():
+        raise FileNotFoundError(f"Input file1 not found: {file1}")
+    
+    cmd = ["AdapterRemoval", "--file1", str(f1_path)]
+    
+    if file2:
+        f2_path = Path(file2)
+        if not f2_path.exists():
+            raise FileNotFoundError(f"Input file2 not found: {file2}")
+        cmd.extend(["--file2", str(f2_path)])
+
+    if adapter_list:
+        alist_path = Path(adapter_list)
+        if not alist_path.exists():
+            raise FileNotFoundError(f"Adapter list file not found: {adapter_list}")
+        cmd.extend(["--adapter-list", str(alist_path)])
+    else:
+        cmd.extend(["--adapter1", adapter1, "--adapter2", adapter2])
+
+    # Parameters
+    cmd.extend(["--basename", basename])
+    cmd.extend(["--minquality", str(minquality)])
+    cmd.extend(["--minlength", str(minlength)])
+    cmd.extend(["--mismatchrate", str(mismatchrate)])
+    cmd.extend(["--minadapteroverlap", str(minadapteroverlap)])
+    cmd.extend(["--threads", str(threads)])
+    cmd.extend(["--qualitybase", str(qualitybase)])
+    cmd.extend(["--qualitymax", str(qualitymax)])
+    cmd.extend(["--mate-separator", mate_separator])
+
+    if trimns: cmd.append("--trimns")
+    if trimqualities: cmd.append("--trimqualities")
+    if collapse: cmd.append("--collapse")
+    if collapse_deterministic: cmd.append("--collapse-deterministic")
+    if gzip: cmd.append("--gzip")
+    if bzip2: cmd.append("--bzip2")
+    if interleaved: cmd.append("--interleaved")
+    if interleaved_output: cmd.append("--interleaved-output")
+    if trim_low_complexity: cmd.append("--trim-low-complexity")
+    if maxlength > 0:
+        cmd.extend(["--maxlength", str(maxlength)])
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        # Identify potential output files based on basename and flags
+        ext = ".gz" if gzip else (".bz2" if bzip2 else "")
+        output_files = [f"{basename}.settings"]
+        
+        # Standard outputs
+        if file2 or interleaved:
+            output_files.extend([
+                f"{basename}.pair1.truncated{ext}",
+                f"{basename}.pair2.truncated{ext}",
+                f"{basename}.singleton.truncated{ext}"
+            ])
+            if collapse or collapse_deterministic:
+                output_files.extend([
+                    f"{basename}.collapsed{ext}",
+                    f"{basename}.collapsed.truncated{ext}"
+                ])
+        else:
+            output_files.append(f"{basename}.truncated{ext}")
+
+        # Filter for files that actually exist
+        existing_outputs = [f for f in output_files if Path(f).exists()]
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": existing_outputs
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def adapter_removal_identify_adapters(
+    file1: str,
+    file2: str,
+    threads: int = 1,
+    interleaved: bool = False,
+    qualitybase: int = 33,
+):
+    """
+    Attempt to identify adapter sequences by looking for consensus overlaps in paired-end reads.
+
+    Args:
+        file1: Path to the first input FASTQ file.
+        file2: Path to the second input FASTQ file.
+        threads: Number of threads to use.
+        interleaved: If True, input file1 is treated as an interleaved paired-end file.
+        qualitybase: Phred quality score offset (33 or 64).
+    """
+    f1_path = Path(file1)
+    f2_path = Path(file2)
+    
+    if not f1_path.exists():
+        raise FileNotFoundError(f"Input file1 not found: {file1}")
+    if not f2_path.exists() and not interleaved:
+        raise FileNotFoundError(f"Input file2 not found: {file2}")
+
+    cmd = [
+        "AdapterRemoval",
+        "--identify-adapters",
+        "--file1", str(f1_path),
+        "--threads", str(threads),
+        "--qualitybase", str(qualitybase)
+    ]
+    
+    if not interleaved:
+        cmd.extend(["--file2", str(f2_path)])
+    else:
+        cmd.append("--interleaved")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "identified_adapters": result.stdout # Usually printed to stdout
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def adapter_removal_demultiplex(
+    barcode_list: str,
+    file1: str,
+    file2: Optional[str] = None,
+    basename: str = "demux_output",
+    barcode_mm: int = 1,
+    barcode_mm_r1: Optional[int] = None,
+    barcode_mm_r2: Optional[int] = None,
+    gzip: bool = False,
+    threads: int = 1,
+    interleaved: bool = False,
+):
+    """
+    Demultiplex reads based on a list of barcodes using AdapterRemoval v2.
+
+    Args:
+        barcode_list: Path to a file containing barcodes (Format: Name Barcode1 Barcode2).
+        file1: Path to the first input FASTQ file.
+        file2: Path to the second input FASTQ file (optional).
+        basename: Prefix for all output files.
+        barcode_mm: Max number of mismatches allowed in barcodes (default 1).
+        barcode_mm_r1: Max mismatches for barcode 1 (overrides barcode_mm).
+        barcode_mm_r2: Max mismatches for barcode 2 (overrides barcode_mm).
+        gzip: If True, compress output files using gzip.
+        threads: Number of threads to use.
+        interleaved: If True, input file1 is treated as an interleaved paired-end file.
+    """
+    blist_path = Path(barcode_list)
+    f1_path = Path(file1)
+    
+    if not blist_path.exists():
+        raise FileNotFoundError(f"Barcode list file not found: {barcode_list}")
+    if not f1_path.exists():
+        raise FileNotFoundError(f"Input file1 not found: {file1}")
+
+    cmd = [
+        "AdapterRemoval",
+        "--barcode-list", str(blist_path),
+        "--file1", str(f1_path),
+        "--basename", basename,
+        "--threads", str(threads)
+    ]
+
+    if file2:
+        f2_path = Path(file2)
+        if not f2_path.exists():
+            raise FileNotFoundError(f"Input file2 not found: {file2}")
+        cmd.extend(["--file2", str(f2_path)])
+    
+    if interleaved:
+        cmd.append("--interleaved")
+    
+    if gzip:
+        cmd.append("--gzip")
+
+    if barcode_mm_r1 is not None:
+        cmd.extend(["--barcode-mm-r1", str(barcode_mm_r1)])
+    if barcode_mm_r2 is not None:
+        cmd.extend(["--barcode-mm-r2", str(barcode_mm_r2)])
+    if barcode_mm_r1 is None and barcode_mm_r2 is None:
+        cmd.extend(["--barcode-mm", str(barcode_mm)])
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        # Demultiplexing creates many files based on the barcode names in the list
+        # We'll return the settings file and a note about the outputs
+        ext = ".gz" if gzip else ""
+        settings_file = f"{basename}.settings"
+        
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "settings_file": settings_file if Path(settings_file).exists() else "Not found",
+            "info": "Demultiplexed files are created with the prefix specified in the barcode list."
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "error": str(e),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_adapterremoval/app/adapterremoval_shim_server.py

@@ -0,0 +1,45 @@
+#!/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')
+SERVER_NAME = 'biosci_adapterremoval'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_adapterremoval/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/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
+    

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_adapterremoval/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_adapterremoval/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/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"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_alfred/app/alfred_server.py

@@ -0,0 +1,630 @@
+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})
+
+
+@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,
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_alfred/app/alfred_shim_server.py

@@ -0,0 +1,45 @@
+#!/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')
+SERVER_NAME = 'biosci_alfred'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_alfred/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/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
+    

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_alfred/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_alfred/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_anansescanpy/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 anansescanpy via conda (e.g., from bioconda)
+RUN conda install -c bioconda anansescanpy -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 anansescanpy_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/anansescanpy_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/anansescanpy_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_anansescanpy/app/anansescanpy_server.py

@@ -0,0 +1,270 @@
+import subprocess
+from pathlib import Path
+from typing import Optional
+import shlex
+import textwrap
+
+@mcp.tool()
+def export_scanpy(
+    adata_path: str,
+    cluster_id: str,
+    output_dir: str = "scANANSE",
+    rna_type: str = "raw",
+    min_cells: int = 50,
+    is_multiome: bool = False,
+):
+    """
+    Export Scanpy AnnData object to files compatible with ANANSE.
+    This function prepares the gene expression and (optionally) accessibility data 
+    for each cluster defined in the AnnData object.
+
+    Args:
+        adata_path: Path to the input AnnData file (.h5ad).
+        cluster_id: The column in adata.obs containing cluster/cell-type labels.
+        output_dir: Directory where the exported files will be saved.
+        rna_type: Type of RNA data ('raw' or 'recount').
+        min_cells: Minimum number of cells per cluster to be included in the export.
+        is_multiome: Set to True if the AnnData object contains both RNA and ATAC data.
+    """
+    # Input validation
+    p_adata = Path(adata_path)
+    if not p_adata.exists():
+        return {"error": f"Input file {adata_path} not found."}
+    
+    if rna_type not in ["raw", "recount"]:
+        return {"error": "rna_type must be either 'raw' or 'recount'."}
+
+    if min_cells < 0:
+        return {"error": "min_cells must be a non-negative integer."}
+
+    # Construct Python script to execute the library function
+    # We use a subprocess to ensure we can capture output and handle the environment
+    py_script = textwrap.dedent(f"""
+        import scanpy as sc
+        import anansescanpy as aspy
+        import os
+        
+        try:
+            adata = sc.read_h5ad('{adata_path}')
+            aspy.export_scanpy(
+                adata, 
+                cluster_id='{cluster_id}', 
+                rna_type='{rna_type}', 
+                min_cells={min_cells}, 
+                output_dir='{output_dir}', 
+                is_multiome={is_multiome}
+            )
+            print("Export successful")
+        except Exception as e:
+            print(f"Error: {{str(e)}}")
+            exit(1)
+    """)
+
+    try:
+        result = subprocess.run(
+            ["python3", "-c", py_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"anansescanpy.export_scanpy on {adata_path}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_dir": output_dir
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Failed to export Scanpy object",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def import_scanpy(
+    adata_path: str,
+    ananse_dir: str,
+    cluster_id: str,
+    output_path: str,
+):
+    """
+    Import ANANSE results (influence scores, GRN) back into a Scanpy AnnData object.
+
+    Args:
+        adata_path: Path to the original AnnData file (.h5ad).
+        ananse_dir: Directory containing the ANANSE output files.
+        cluster_id: The column in adata.obs that was used for the ANANSE analysis.
+        output_path: Path where the updated AnnData file will be saved.
+    """
+    p_adata = Path(adata_path)
+    p_ananse = Path(ananse_dir)
+    
+    if not p_adata.exists():
+        return {"error": f"Input AnnData file {adata_path} not found."}
+    if not p_ananse.is_dir():
+        return {"error": f"ANANSE directory {ananse_dir} not found."}
+
+    py_script = textwrap.dedent(f"""
+        import scanpy as sc
+        import anansescanpy as aspy
+        
+        try:
+            adata = sc.read_h5ad('{adata_path}')
+            adata = aspy.import_scanpy(
+                adata, 
+                cluster_id='{cluster_id}', 
+                ananse_dir='{ananse_dir}'
+            )
+            adata.write_h5ad('{output_path}')
+            print("Import successful")
+        except Exception as e:
+            print(f"Error: {{str(e)}}")
+            exit(1)
+    """)
+
+    try:
+        result = subprocess.run(
+            ["python3", "-c", py_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"anansescanpy.import_scanpy from {ananse_dir}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_file": output_path
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Failed to import ANANSE results",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def anansnake_config(
+    adata_path: str,
+    cluster_id: str,
+    genome: str,
+    output_dir: str,
+    sample_col: Optional[str] = None,
+    atac_column: Optional[str] = None,
+):
+    """
+    Generate a configuration file for the anansnake pipeline based on a Scanpy object.
+
+    Args:
+        adata_path: Path to the AnnData file (.h5ad).
+        cluster_id: The column in adata.obs containing cluster labels.
+        genome: Genome assembly name (e.g., 'hg38', 'mm10').
+        output_dir: Directory where the config.yaml and analysis files will be created.
+        sample_col: Optional column in adata.obs containing sample identifiers.
+        atac_column: Optional column in adata.obs containing ATAC-seq peak data.
+    """
+    p_adata = Path(adata_path)
+    if not p_adata.exists():
+        return {"error": f"Input file {adata_path} not found."}
+
+    sample_arg = f"'{sample_col}'" if sample_col else "None"
+    atac_arg = f"'{atac_column}'" if atac_column else "None"
+
+    py_script = textwrap.dedent(f"""
+        import scanpy as sc
+        import anansescanpy as aspy
+        
+        try:
+            adata = sc.read_h5ad('{adata_path}')
+            aspy.anansnake_config(
+                adata, 
+                cluster_id='{cluster_id}', 
+                genome='{genome}', 
+                output_dir='{output_dir}', 
+                sample_col={sample_arg}, 
+                atac_column={atac_arg}
+            )
+            print("Config generation successful")
+        except Exception as e:
+            print(f"Error: {{str(e)}}")
+            exit(1)
+    """)
+
+    try:
+        result = subprocess.run(
+            ["python3", "-c", py_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": "anansescanpy.anansnake_config",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_dir": output_dir
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Failed to generate anansnake config",
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }
+
+@mcp.tool()
+def run_anansnake(
+    config_file: str,
+    snakefile: str,
+    cores: int = 12,
+    memory_mb: int = 48000,
+    use_conda: bool = True,
+    conda_frontend: str = "mamba",
+):
+    """
+    Execute the anansnake GRN analysis pipeline using Snakemake.
+
+    Args:
+        config_file: Path to the config.yaml file (generated by anansnake_config).
+        snakefile: Path to the anansnake Snakefile.
+        cores: Number of CPU cores to use.
+        memory_mb: Memory resource limit in MB.
+        use_conda: Whether to use conda environments for the pipeline steps.
+        conda_frontend: The conda frontend to use ('mamba' or 'conda').
+    """
+    p_config = Path(config_file)
+    p_snake = Path(snakefile)
+
+    if not p_config.exists():
+        return {"error": f"Config file {config_file} not found."}
+    if not p_snake.exists():
+        return {"error": f"Snakefile {snakefile} not found."}
+
+    cmd = [
+        "snakemake",
+        "--configfile", str(p_config),
+        "--snakefile", str(p_snake),
+        "--cores", str(cores),
+        "--resources", f"mem_mb={memory_mb}"
+    ]
+
+    if use_conda:
+        cmd.append("--use-conda")
+        cmd.extend(["--conda-frontend", conda_frontend])
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Snakemake pipeline execution failed",
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_anansescanpy/app/anansescanpy_shim_server.py

@@ -0,0 +1,45 @@
+#!/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_anansescanpy/app/anansescanpy_server.py')
+SERVER_NAME = 'biosci_anansescanpy'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_anansescanpy/docker-compose.yml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_anansescanpy/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_anansescanpy/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/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"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_aria2/app/aria2_server.py

@@ -0,0 +1,307 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Union
+
+@mcp.tool()
+def aria2_download(
+    uris: List[str],
+    dir: Optional[str] = None,
+    out: Optional[str] = None,
+    split: int = 5,
+    max_connection_per_server: int = 1,
+    min_split_size: str = "20M",
+    continue_download: bool = True,
+    max_download_limit: str = "0",
+    user_agent: Optional[str] = None,
+    header: Optional[List[str]] = None,
+    all_proxy: Optional[str] = None,
+):
+    """
+    Download files from HTTP/HTTPS/FTP/SFTP URIs using aria2c.
+    
+    :param uris: List of URIs to download.
+    :param dir: The directory to store the downloaded file.
+    :param out: The file name of the downloaded file.
+    :param split: Download a file using N connections.
+    :param max_connection_per_server: The maximum number of connections to one server for each download.
+    :param min_split_size: aria2 does not split less than this size. (e.g., 20M)
+    :param continue_download: Continue downloading a partially downloaded file.
+    :param max_download_limit: Set max download speed in bytes/sec. 0 means unrestricted. (e.g., 1M, 500K)
+    :param user_agent: Set user agent.
+    :param header: Append HTTP header.
+    :param all_proxy: Use proxy server for all protocols.
+    """
+    cmd = ["aria2c"]
+    
+    if dir:
+        path_dir = Path(dir)
+        path_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--dir", str(path_dir)])
+    
+    if out:
+        cmd.extend(["--out", out])
+        
+    cmd.extend([
+        f"--split={split}",
+        f"--max-connection-per-server={max_connection_per_server}",
+        f"--min-split-size={min_split_size}",
+        f"--continue={str(continue_download).lower()}",
+        f"--max-download-limit={max_download_limit}"
+    ])
+    
+    if user_agent:
+        cmd.extend([f"--user-agent={user_agent}"])
+    
+    if header:
+        for h in header:
+            cmd.extend([f"--header={h}"])
+            
+    if all_proxy:
+        cmd.extend([f"--all-proxy={all_proxy}"])
+        
+    cmd.extend(uris)
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "error"
+        }
+
+@mcp.tool()
+def aria2_torrent(
+    torrent_path: str,
+    dir: Optional[str] = None,
+    seed_time: int = 0,
+    max_upload_limit: str = "0",
+    listen_port: str = "6881-6999",
+    select_file: Optional[str] = None,
+    follow_torrent: str = "true",
+):
+    """
+    Download files using a BitTorrent file or Magnet URI.
+    
+    :param torrent_path: Path to .torrent file or a Magnet URI.
+    :param dir: The directory to store the downloaded file.
+    :param seed_time: Specify seeding time in minutes. 0 means do not seed.
+    :param max_upload_limit: Set max upload speed in bytes/sec.
+    :param listen_port: Set TCP port number for BitTorrent.
+    :param select_file: Index of the file to download (e.g., "1,2,5").
+    :param follow_torrent: If 'true' or 'mem', aria2 will download the torrent file if URI is a torrent file.
+    """
+    cmd = ["aria2c"]
+    
+    if dir:
+        path_dir = Path(dir)
+        path_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--dir", str(path_dir)])
+        
+    cmd.extend([
+        f"--seed-time={seed_time}",
+        f"--max-upload-limit={max_upload_limit}",
+        f"--listen-port={listen_port}",
+        f"--follow-torrent={follow_torrent}"
+    ])
+    
+    if select_file:
+        cmd.extend([f"--select-file={select_file}"])
+        
+    # Check if it's a local file or a magnet link
+    if not torrent_path.startswith("magnet:?"):
+        path_torrent = Path(torrent_path)
+        if not path_torrent.exists():
+            return {"error": f"Torrent file not found: {torrent_path}"}
+        cmd.append(str(path_torrent))
+    else:
+        cmd.append(torrent_path)
+        
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "error"
+        }
+
+@mcp.tool()
+def aria2_metalink(
+    metalink_file: str,
+    dir: Optional[str] = None,
+    metalink_language: Optional[str] = None,
+    metalink_location: Optional[str] = None,
+    metalink_os: Optional[str] = None,
+):
+    """
+    Download files using a Metalink file.
+    
+    :param metalink_file: Path to the .metalink file.
+    :param dir: The directory to store the downloaded file.
+    :param metalink_language: The language of the file to download.
+    :param metalink_location: The location of the preferred server.
+    :param metalink_os: The operating system of the file to download.
+    """
+    path_meta = Path(metalink_file)
+    if not path_meta.exists():
+        return {"error": f"Metalink file not found: {metalink_file}"}
+        
+    cmd = ["aria2c"]
+    
+    if dir:
+        path_dir = Path(dir)
+        path_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--dir", str(path_dir)])
+        
+    if metalink_language:
+        cmd.extend([f"--metalink-language={metalink_language}"])
+    if metalink_location:
+        cmd.extend([f"--metalink-location={metalink_location}"])
+    if metalink_os:
+        cmd.extend([f"--metalink-os={metalink_os}"])
+        
+    cmd.append(str(path_meta))
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "error"
+        }
+
+@mcp.tool()
+def aria2_batch_download(
+    input_file: str,
+    dir: Optional[str] = None,
+    force_sequential: bool = False,
+    max_concurrent_downloads: int = 5,
+    parameterized_uris: bool = False,
+):
+    """
+    Download multiple URIs from a text file.
+    
+    :param input_file: Path to the file containing URIs (one per line).
+    :param dir: The directory to store the downloaded files.
+    :param force_sequential: Fetch URIs in the order they appear in the input file.
+    :param max_concurrent_downloads: Set maximum number of parallel downloads.
+    :param parameterized_uris: Enable parameterized URI support (e.g. http://{host1,host2}/file).
+    """
+    path_input = Path(input_file)
+    if not path_input.exists():
+        return {"error": f"Input file not found: {input_file}"}
+        
+    cmd = ["aria2c", f"--input-file={str(path_input)}"]
+    
+    if dir:
+        path_dir = Path(dir)
+        path_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--dir", str(path_dir)])
+        
+    cmd.extend([
+        f"--force-sequential={str(force_sequential).lower()}",
+        f"--max-concurrent-downloads={max_concurrent_downloads}",
+        f"--parameterized-uri={str(parameterized_uris).lower()}"
+    ])
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "error"
+        }
+
+@mcp.tool()
+def aria2_rpc_server(
+    rpc_listen_port: int = 6800,
+    rpc_listen_all: bool = False,
+    rpc_secret: Optional[str] = None,
+    rpc_allow_origin_all: bool = False,
+    rpc_max_request_size: str = "2M",
+    daemon: bool = False,
+):
+    """
+    Start aria2 in RPC mode to allow remote control via JSON-RPC or XML-RPC.
+    
+    :param rpc_listen_port: Port number for RPC server.
+    :param rpc_listen_all: Listen for RPC requests on all network interfaces.
+    :param rpc_secret: Set RPC secret authorization token.
+    :param rpc_allow_origin_all: Add Access-Control-Allow-Origin: * to HTTP response.
+    :param rpc_max_request_size: Set max size of JSON-RPC/XML-RPC request.
+    :param daemon: Run as a background process.
+    """
+    cmd = ["aria2c", "--enable-rpc"]
+    
+    cmd.extend([
+        f"--rpc-listen-port={rpc_listen_port}",
+        f"--rpc-listen-all={str(rpc_listen_all).lower()}",
+        f"--rpc-allow-origin-all={str(rpc_allow_origin_all).lower()}",
+        f"--rpc-max-request-size={rpc_max_request_size}",
+        f"--daemon={str(daemon).lower()}"
+    ])
+    
+    if rpc_secret:
+        cmd.append(f"--rpc-secret={rpc_secret}")
+        
+    try:
+        # If daemon is True, we don't wait for completion
+        if daemon:
+            subprocess.Popen(cmd)
+            return {
+                "command_executed": " ".join(cmd),
+                "status": "daemon_started",
+                "message": f"aria2 RPC server started in background on port {rpc_listen_port}"
+            }
+        else:
+            # This will block until the server is stopped
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            return {
+                "command_executed": " ".join(cmd),
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "status": "success"
+            }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "error"
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_aria2/app/aria2_shim_server.py

@@ -0,0 +1,45 @@
+#!/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')
+SERVER_NAME = 'biosci_aria2'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/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
+    

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_aria2/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_aria2/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/Dockerfile

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/app/bcbio-nextgen_server.py

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/app/bcbio-nextgen_shim_server.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/app/bcbio-nextgen_server.py')
+SERVER_NAME = 'biosci_bcbio_nextgen'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/docker-compose.yml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bcbio-nextgen/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/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 bioconda-utils via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconda-utils -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/bioconda-utils_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/bioconda-utils_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/bioconda-utils_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/app/bioconda-utils_server.py

@@ -0,0 +1,490 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# @mcp.tool() decorator is assumed to be imported from a library like 'mcp'
+# In this code, it is commented out as per the instructions.
+
+# @mcp.tool()
+def bioconductor_skeleton(
+    packages: List[str],
+    recipes: Optional[Path] = None,
+    config: Optional[Path] = None,
+    recursive: bool = False,
+    skip_existing: bool = False,
+    skip_if_in_other_channels: bool = False,
+    output_dir: Optional[Path] = None,
+    pkg_version: Optional[str] = None,
+    bioc_version: Optional[str] = None,
+    force: bool = False,
+):
+    """
+    Creates skeleton recipes for one or more Bioconductor packages.
+
+    Args:
+        packages: One or more Bioconductor package names to create skeletons for.
+        recipes: Path to the recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        recursive: If True, create recipes for missing dependencies as well.
+        skip_existing: If True, skip recipes that already exist.
+        skip_if_in_other_channels: If True, skip recipes that exist in other channels.
+        output_dir: Directory to write the new recipes to. Defaults to the recipes folder.
+        pkg_version: Specific package version to create a skeleton for.
+        bioc_version: Specific Bioconductor version to use.
+        force: If True, force creation of a recipe even if it already exists.
+    """
+    if not packages:
+        raise ValueError("At least one package name must be provided.")
+
+    cmd = ["bioconda-utils", "bioconductor-skeleton"]
+    if recipes:
+        cmd.extend(["--recipes", str(recipes)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    if recursive:
+        cmd.append("--recursive")
+    if skip_existing:
+        cmd.append("--skip-existing")
+    if skip_if_in_other_channels:
+        cmd.append("--skip-if-in-other-channels")
+    if output_dir:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--output-dir", str(output_dir)])
+    if pkg_version:
+        cmd.extend(["--pkg-version", pkg_version])
+    if bioc_version:
+        cmd.extend(["--bioc-version", bioc_version])
+    if force:
+        cmd.append("--force")
+
+    cmd.extend(packages)
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        output_files = [str(output_dir)] if output_dir else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+
+# @mcp.tool()
+def cran_skeleton(
+    packages: List[str],
+    recipes: Optional[Path] = None,
+    config: Optional[Path] = None,
+    recursive: bool = False,
+    skip_existing: bool = False,
+    skip_if_in_other_channels: bool = False,
+    output_dir: Optional[Path] = None,
+    pkg_version: Optional[str] = None,
+    force: bool = False,
+):
+    """
+    Creates skeleton recipes for one or more CRAN packages.
+
+    Args:
+        packages: One or more CRAN package names to create skeletons for.
+        recipes: Path to the recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        recursive: If True, create recipes for missing dependencies as well.
+        skip_existing: If True, skip recipes that already exist.
+        skip_if_in_other_channels: If True, skip recipes that exist in other channels.
+        output_dir: Directory to write the new recipes to. Defaults to the recipes folder.
+        pkg_version: Specific package version to create a skeleton for.
+        force: If True, force creation of a recipe even if it already exists.
+    """
+    if not packages:
+        raise ValueError("At least one package name must be provided.")
+
+    cmd = ["bioconda-utils", "cran-skeleton"]
+    if recipes:
+        cmd.extend(["--recipes", str(recipes)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    if recursive:
+        cmd.append("--recursive")
+    if skip_existing:
+        cmd.append("--skip-existing")
+    if skip_if_in_other_channels:
+        cmd.append("--skip-if-in-other-channels")
+    if output_dir:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--output-dir", str(output_dir)])
+    if pkg_version:
+        cmd.extend(["--pkg-version", pkg_version])
+    if force:
+        cmd.append("--force")
+
+    cmd.extend(packages)
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        output_files = [str(output_dir)] if output_dir else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+
+# @mcp.tool()
+def pypi_skeleton(
+    packages: List[str],
+    recipes: Optional[Path] = None,
+    config: Optional[Path] = None,
+    recursive: bool = False,
+    skip_existing: bool = False,
+    skip_if_in_other_channels: bool = False,
+    output_dir: Optional[Path] = None,
+    pkg_version: Optional[str] = None,
+    python_version: Optional[str] = None,
+    force: bool = False,
+):
+    """
+    Creates skeleton recipes for one or more PyPI packages.
+
+    Args:
+        packages: One or more PyPI package names to create skeletons for.
+        recipes: Path to the recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        recursive: If True, create recipes for missing dependencies as well.
+        skip_existing: If True, skip recipes that already exist.
+        skip_if_in_other_channels: If True, skip recipes that exist in other channels.
+        output_dir: Directory to write the new recipes to. Defaults to the recipes folder.
+        pkg_version: Specific package version to create a skeleton for.
+        python_version: Python version to use for the skeleton.
+        force: If True, force creation of a recipe even if it already exists.
+    """
+    if not packages:
+        raise ValueError("At least one package name must be provided.")
+
+    cmd = ["bioconda-utils", "pypi-skeleton"]
+    if recipes:
+        cmd.extend(["--recipes", str(recipes)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    if recursive:
+        cmd.append("--recursive")
+    if skip_existing:
+        cmd.append("--skip-existing")
+    if skip_if_in_other_channels:
+        cmd.append("--skip-if-in-other-channels")
+    if output_dir:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--output-dir", str(output_dir)])
+    if pkg_version:
+        cmd.extend(["--pkg-version", pkg_version])
+    if python_version:
+        cmd.extend(["--python-version", python_version])
+    if force:
+        cmd.append("--force")
+
+    cmd.extend(packages)
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        output_files = [str(output_dir)] if output_dir else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+
+# @mcp.tool()
+def lint(
+    recipes_to_lint: Optional[List[str]] = None,
+    recipes_folder: Optional[Path] = None,
+    config: Optional[Path] = None,
+    fail_level: str = "error",
+    no_fail_on_error: bool = False,
+    report_file: Optional[Path] = None,
+    exclude: Optional[List[str]] = None,
+):
+    """
+    Lints bioconda recipes to check for common errors and style issues.
+
+    Args:
+        recipes_to_lint: Specific recipes to lint. Can be paths, package names, or glob patterns.
+        recipes_folder: Path to the top-level recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        fail_level: The linting level at which to fail ('error', 'warning', 'info').
+        no_fail_on_error: If True, do not exit with an error code on linting failures.
+        report_file: File to write the linting report to.
+        exclude: A list of recipes to exclude from linting.
+    """
+    fail_level_choices = ["error", "warning", "info"]
+    if fail_level not in fail_level_choices:
+        raise ValueError(f"fail_level must be one of {fail_level_choices}")
+
+    cmd = ["bioconda-utils", "lint"]
+    if recipes_folder:
+        cmd.extend(["--recipes", str(recipes_folder)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    cmd.extend(["--fail-level", fail_level])
+    if no_fail_on_error:
+        cmd.append("--no-fail-on-error")
+    if report_file:
+        cmd.extend(["--report-file", str(report_file)])
+    if exclude:
+        for item in exclude:
+            cmd.extend(["--exclude", item])
+    if recipes_to_lint:
+        cmd.extend(recipes_to_lint)
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        output_files = [str(report_file)] if report_file else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+
+# @mcp.tool()
+def build(
+    recipes_to_build: List[str],
+    recipes_folder: Optional[Path] = None,
+    config: Optional[Path] = None,
+    package_folder: Optional[Path] = None,
+    force: bool = False,
+    docker: bool = False,
+    mulled_test: Optional[bool] = None,
+    extra_channels: Optional[List[str]] = None,
+    anaconda_upload: bool = False,
+    anaconda_token: Optional[str] = None,
+    user: Optional[str] = None,
+    dry_run: bool = False,
+):
+    """
+    Builds one or more bioconda recipes.
+
+    Args:
+        recipes_to_build: Recipes to build. Can be paths, package names, or glob patterns.
+        recipes_folder: Path to the top-level recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        package_folder: Folder to store the built packages.
+        force: If True, force the build even if the package already exists.
+        docker: If True, build inside a Docker container.
+        mulled_test: Set to True to run mulled tests, False to disable them. Default is tool's default.
+        extra_channels: Additional channels to use during the build.
+        anaconda_upload: If True, upload the built package to anaconda.org.
+        anaconda_token: Anaconda token for uploading.
+        user: Anaconda user/organization to upload to.
+        dry_run: If True, show what would be done without executing.
+    """
+    if not recipes_to_build:
+        raise ValueError("At least one recipe must be provided to build.")
+
+    cmd = ["bioconda-utils", "build"]
+    if recipes_folder:
+        cmd.extend(["--recipes", str(recipes_folder)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    if package_folder:
+        package_folder.mkdir(parents=True, exist_ok=True)
+        cmd.extend(["--package-folder", str(package_folder)])
+    if force:
+        cmd.append("--force")
+    if docker:
+        cmd.append("--docker")
+    if mulled_test is True:
+        cmd.append("--mulled-test")
+    elif mulled_test is False:
+        cmd.append("--no-mulled-test")
+    if extra_channels:
+        for channel in extra_channels:
+            cmd.extend(["-c", channel])
+    if not anaconda_upload:
+        cmd.append("--no-anaconda-upload")
+    if anaconda_token:
+        cmd.extend(["--anaconda-token", anaconda_token])
+    if user:
+        cmd.extend(["--user", user])
+    if dry_run:
+        cmd.append("--dry-run")
+
+    cmd.extend(recipes_to_build)
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        output_files = [str(package_folder)] if package_folder else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+
+# @mcp.tool()
+def dag(
+    recipes_for_dag: Optional[List[str]] = None,
+    recipes_folder: Optional[Path] = None,
+    config: Optional[Path] = None,
+    file_out: Optional[Path] = None,
+    format: str = "gml",
+):
+    """
+    Generates a dependency graph (DAG) for recipes.
+
+    Args:
+        recipes_for_dag: Recipes to include in the DAG. If None, all recipes are considered.
+        recipes_folder: Path to the top-level recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        file_out: Path to write the output DAG file.
+        format: The output format for the DAG ('gml', 'dot', 'pdf').
+    """
+    format_choices = ["gml", "dot", "pdf"]
+    if format not in format_choices:
+        raise ValueError(f"format must be one of {format_choices}")
+
+    cmd = ["bioconda-utils", "dag"]
+    if recipes_folder:
+        cmd.extend(["--recipes", str(recipes_folder)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    if file_out:
+        cmd.extend(["--file-out", str(file_out)])
+    cmd.extend(["--format", format])
+    if recipes_for_dag:
+        cmd.extend(recipes_for_dag)
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        output_files = [str(file_out)] if file_out else []
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }
+
+
+# @mcp.tool()
+def update_pinning(
+    recipes_folder: Optional[Path] = None,
+    config: Optional[Path] = None,
+    packages: Optional[str] = None,
+    no_pr: bool = False,
+    dry_run: bool = False,
+):
+    """
+    Updates pinning in recipes based on the global pinning file.
+
+    Args:
+        recipes_folder: Path to the top-level recipes folder.
+        config: Path to the bioconda-utils configuration file.
+        packages: Comma-separated string of package names to update pinning for.
+        no_pr: If True, do not create a pull request with the changes.
+        dry_run: If True, show what would be done without executing.
+    """
+    cmd = ["bioconda-utils", "update-pinning"]
+    if recipes_folder:
+        cmd.extend(["--recipes", str(recipes_folder)])
+    if config:
+        cmd.extend(["--config", str(config)])
+    if packages:
+        cmd.extend(["--packages", packages])
+    if no_pr:
+        cmd.append("--no-pr")
+    if dry_run:
+        cmd.append("--dry-run")
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd, check=True, capture_output=True, text=True, encoding="utf-8"
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"Command failed with exit code {e.returncode}",
+            "output_files": [],
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/app/bioconda-utils_shim_server.py

@@ -0,0 +1,45 @@
+#!/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_bioconda-utils/app/bioconda-utils_server.py')
+SERVER_NAME = 'biosci_bioconda_utils'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/docker-compose.yml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconda-utils/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/Dockerfile

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/app/bioconductor-banksy_server.py

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/app/bioconductor-banksy_shim_server.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/app/bioconductor-banksy_server.py')
+SERVER_NAME = 'biosci_bioconductor_banksy'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/docker-compose.yml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/environment.yaml

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-banksy/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-benchdamic/Dockerfile

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-benchdamic/app/bioconductor-benchdamic_server.py

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-benchdamic/app/bioconductor-benchdamic_shim_server.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+
+SOURCE_SERVER = Path('/225040511/project/BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-benchdamic/app/bioconductor-benchdamic_server.py')
+SERVER_NAME = 'biosci_bioconductor_benchdamic'
+
+
+class _ShimMCP:
+    @staticmethod
+    def tool():
+        def _decorator(fn):
+            return fn
+        return _decorator
+
+
+def _load_functions():
+    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")