Add files using upload-large-folder tool

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abricate/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 abricate via conda (e.g., from bioconda)
+RUN conda install -c bioconda abricate -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/abricate_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/abricate_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/abricate_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abricate/app/abricate_server.py

@@ -0,0 +1,304 @@
+import logging
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+log = logging.getLogger(__name__)
+
+# MCP decorator is not defined here, but the functions are structured
+# to be compatible with it.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(f):
+            return f
+        return decorator
+
+@mcp.tool()
+def abricate_run(
+    contigs: List[Path],
+    db: str = "resfinder",
+    minid: float = 80.0,
+    mincov: float = 80.0,
+    threads: int = 1,
+    report: Optional[Path] = None,
+    summary: Optional[Path] = None,
+    json_output: Optional[Path] = None,
+    gff: Optional[Path] = None,
+    fofn: Optional[Path] = None,
+    datadir: Optional[Path] = None,
+    mismatches: Optional[int] = None,
+    minlen: Optional[int] = None,
+    quiet: bool = False,
+    debug: bool = False,
+    nopathogen: bool = False,
+    csv: bool = False,
+    noheader: bool = False,
+    all_genes: bool = False,
+    nukem: bool = False,
+    long_report: bool = False,
+    pretty: bool = False,
+    agrvate: bool = False,
+    roary: bool = False,
+    prokka: bool = False,
+    plasmid: bool = False,
+    resistance: bool = False,
+    virulence: bool = False,
+    locus: bool = False,
+    seqid: bool = False,
+) -> Dict[str, Any]:
+    """
+    Mass screen contigs for antimicrobial resistance or virulence genes using Abricate.
+
+    This is the main analysis function of Abricate. It takes one or more FASTA files
+    and screens them against a specified database.
+    """
+    # --- Input Validation ---
+    if not contigs and not fofn:
+        raise ValueError("Either 'contigs' (a list of FASTA files) or 'fofn' (a file of FASTA paths) must be provided.")
+    if contigs and fofn:
+        raise ValueError("Provide either 'contigs' or 'fofn', but not both.")
+    
+    if contigs:
+        for file_path in contigs:
+            if not file_path.exists():
+                raise FileNotFoundError(f"Input contig file not found: {file_path}")
+    
+    if fofn and not fofn.exists():
+        raise FileNotFoundError(f"Input FOFN file not found: {fofn}")
+
+    if not 0.0 <= minid <= 100.0:
+        raise ValueError(f"'minid' must be between 0.0 and 100.0, but got {minid}")
+    if not 0.0 <= mincov <= 100.0:
+        raise ValueError(f"'mincov' must be between 0.0 and 100.0, but got {mincov}")
+    if threads < 1:
+        raise ValueError(f"'threads' must be a positive integer, but got {threads}")
+    if mismatches is not None and mismatches < 0:
+        raise ValueError(f"'mismatches' cannot be negative, but got {mismatches}")
+    if minlen is not None and minlen < 0:
+        raise ValueError(f"'minlen' cannot be negative, but got {minlen}")
+
+    # --- Command Construction ---
+    cmd = ["abricate"]
+    output_files = []
+
+    # Add options with values
+    cmd.extend(["--db", db])
+    cmd.extend(["--minid", str(minid)])
+    cmd.extend(["--mincov", str(mincov)])
+    cmd.extend(["--threads", str(threads)])
+
+    if report:
+        cmd.extend(["--report", str(report)])
+        output_files.append(str(report))
+    if summary:
+        cmd.extend(["--summary", str(summary)])
+        output_files.append(str(summary))
+    if json_output:
+        cmd.extend(["--json", str(json_output)])
+        output_files.append(str(json_output))
+    if gff:
+        cmd.extend(["--gff", str(gff)])
+        output_files.append(str(gff))
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if mismatches is not None:
+        cmd.extend(["--mismatches", str(mismatches)])
+    if minlen is not None:
+        cmd.extend(["--minlen", str(minlen)])
+    if fofn:
+        cmd.extend(["--fofn", str(fofn)])
+
+    # Add boolean flags
+    if quiet: cmd.append("--quiet")
+    if debug: cmd.append("--debug")
+    if nopathogen: cmd.append("--nopathogen")
+    if csv: cmd.append("--csv")
+    if noheader: cmd.append("--noheader")
+    if all_genes: cmd.append("--all")
+    if nukem: cmd.append("--nukem")
+    if long_report: cmd.append("--long")
+    if pretty: cmd.append("--pretty")
+    if agrvate: cmd.append("--agrvate")
+    if roary: cmd.append("--roary")
+    if prokka: cmd.append("--prokka")
+    if plasmid: cmd.append("--plasmid")
+    if resistance: cmd.append("--resistance")
+    if virulence: cmd.append("--virulence")
+    if locus: cmd.append("--locus")
+    if seqid: cmd.append("--seqid")
+
+    # Add positional arguments (input files)
+    if contigs:
+        cmd.extend([str(p) for p in contigs])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        log.error(f"Abricate execution failed with exit code {e.returncode}")
+        log.error(f"STDOUT: {e.stdout}")
+        log.error(f"STDERR: {e.stderr}")
+        raise RuntimeError(f"Abricate failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_list_databases(
+    datadir: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False
+) -> Dict[str, Any]:
+    """Lists all available abricate databases."""
+    cmd = ["abricate", "--list"]
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if quiet:
+        cmd.append("--quiet")
+    if debug:
+        cmd.append("--debug")
+
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate failed to list databases: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_check_databases(
+    datadir: Optional[Path] = None,
+    quiet: bool = False,
+    debug: bool = False
+) -> Dict[str, Any]:
+    """Checks if the abricate databases are installed correctly."""
+    cmd = ["abricate", "--check"]
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if quiet:
+        cmd.append("--quiet")
+    if debug:
+        cmd.append("--debug")
+
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate database check failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_setup_databases(
+    datadir: Optional[Path] = None,
+    threads: int = 1,
+    quiet: bool = False,
+    debug: bool = False
+) -> Dict[str, Any]:
+    """Downloads and sets up all the abricate databases."""
+    if threads < 1:
+        raise ValueError(f"'threads' must be a positive integer, but got {threads}")
+
+    cmd = ["abricate", "--setupdb"]
+    if datadir:
+        cmd.extend(["--datadir", str(datadir)])
+    if threads > 1:
+        cmd.extend(["--threads", str(threads)])
+    if quiet:
+        cmd.append("--quiet")
+    if debug:
+        cmd.append("--debug")
+
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate database setup failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_get_version() -> Dict[str, Any]:
+    """Prints the abricate version."""
+    cmd = ["abricate", "--version"]
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate version check failed: {e.stderr}")
+
+
+@mcp.tool()
+def abricate_get_citation() -> Dict[str, Any]:
+    """Prints the citation for abricate."""
+    cmd = ["abricate", "--citation"]
+    command_executed = " ".join(cmd)
+    log.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        raise RuntimeError("abricate command not found. Please ensure it is in your PATH.")
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Abricate citation check failed: {e.stderr}")

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abricate/app/abricate_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_help_txt/mcp_abricate/app/abricate_server.py')
+SERVER_NAME = 'biosci_abricate'
+
+
+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_help_txt/mcp_abricate/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abricate/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abricate/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abyss/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 abyss via conda (e.g., from bioconda)
+RUN conda install -c bioconda abyss -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 abyss_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/abyss_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/abyss_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abyss/app/abyss_server.py

@@ -0,0 +1,211 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# from mcp import tool as mcp_tool
+# Note: The 'mcp' import is commented out as per the instructions.
+# In a real MCP environment, you would uncomment the line above.
+
+def mcp_tool(func):
+    """A placeholder decorator to mimic @mcp.tool()."""
+    return func
+
+@mcp_tool
+def run_perl(
+    programfile: Optional[Path] = None,
+    program_string: Optional[str] = None,
+    arguments: Optional[List[str]] = None,
+    include_dirs: Optional[List[Path]] = None,
+    use_modules: Optional[List[str]] = None,
+    no_modules: Optional[List[str]] = None,
+    warnings: str = "normal",
+    check_syntax_only: bool = False,
+    enable_all_features: bool = False,
+) -> Dict[str, Any]:
+    """
+    Executes a Perl script or a one-liner command with specified options.
+
+    This tool serves as a wrapper around the Perl interpreter, allowing for the execution
+    of scripts from files or direct command-line strings. It provides options for
+    managing modules, include paths, and warning levels.
+
+    Args:
+        programfile: Path to the Perl program file to execute.
+        program_string: A string containing a one-liner Perl program to execute.
+        arguments: A list of arguments to pass to the program file or one-liner.
+        include_dirs: A list of directories to add to Perl's @INC path for finding modules.
+        use_modules: A list of modules to 'use' before executing the program.
+        no_modules: A list of modules to 'no' (disable) before executing the program.
+        warnings: Set the warning level. Can be 'normal' (-w), 'all' (-W), or 'none' (-X).
+        check_syntax_only: If True, checks the syntax of the program without executing it (-c).
+        enable_all_features: If True and using program_string, enables all optional features (-E).
+    """
+    # 1. Input Validation
+    if not (programfile or program_string):
+        raise ValueError("Either 'programfile' or 'program_string' must be provided.")
+    if programfile and program_string:
+        raise ValueError("Cannot provide both 'programfile' and 'program_string'.")
+
+    if programfile and not programfile.is_file():
+        raise FileNotFoundError(f"Program file not found: {programfile}")
+
+    if include_dirs:
+        for d in include_dirs:
+            if not d.is_dir():
+                raise NotADirectoryError(f"Include directory not found: {d}")
+
+    allowed_warnings = ["normal", "all", "none"]
+    if warnings not in allowed_warnings:
+        raise ValueError(f"Invalid 'warnings' value '{warnings}'. Must be one of {allowed_warnings}.")
+
+    # 2. Command Construction
+    cmd = ["perl"]
+
+    # Handle warnings
+    if warnings == "normal":
+        cmd.append("-w")
+    elif warnings == "all":
+        cmd.append("-W")
+    elif warnings == "none":
+        cmd.append("-X")
+
+    # Handle syntax check
+    if check_syntax_only:
+        cmd.append("-c")
+
+    # Handle include directories
+    if include_dirs:
+        for d in include_dirs:
+            cmd.extend(["-I", str(d)])
+
+    # Handle modules
+    if use_modules:
+        for module in use_modules:
+            cmd.extend(["-M", module])
+    if no_modules:
+        for module in no_modules:
+            cmd.extend(["-m", module])
+
+    # Handle program source (file or string)
+    if program_string:
+        if enable_all_features:
+            cmd.append("-E")
+        else:
+            cmd.append("-e")
+        cmd.append(program_string)
+    elif programfile:
+        cmd.append(str(programfile))
+
+    # Handle arguments to the script
+    if arguments:
+        cmd.extend(arguments)
+
+    command_executed = " ".join(map(str, cmd))
+
+    # 3. Subprocess Execution
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=False, # Check manually to provide better error context
+        )
+        if result.returncode != 0:
+            raise subprocess.CalledProcessError(
+                result.returncode, cmd, output=result.stdout, stderr=result.stderr
+            )
+    except FileNotFoundError:
+        raise RuntimeError("Perl executable not found. Please ensure it is in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Perl execution failed.",
+            "return_code": e.returncode,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": command_executed,
+        }
+
+    # 4. Structured Result Return
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": []  # The wrapper itself doesn't create files
+    }
+
+@mcp_tool
+def perl_version() -> Dict[str, Any]:
+    """
+    Retrieves the version, patchlevel, and license of the Perl interpreter.
+
+    This corresponds to the `perl -v` command.
+    """
+    cmd = ["perl", "-v"]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except FileNotFoundError:
+        raise RuntimeError("Perl executable not found. Please ensure it is in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Failed to get Perl version.",
+            "return_code": e.returncode,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": command_executed,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+    }
+
+@mcp_tool
+def perl_config(variable: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Prints the configuration summary for the Perl installation.
+
+    This corresponds to the `perl -V` command. If a variable name is provided,
+    it prints the value of that specific configuration variable.
+
+    Args:
+        variable: A specific Config.pm variable to query.
+    """
+    cmd = ["perl"]
+    if variable:
+        cmd.append(f"-V:{variable}")
+    else:
+        cmd.append("-V")
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except FileNotFoundError:
+        raise RuntimeError("Perl executable not found. Please ensure it is in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Failed to get Perl configuration.",
+            "return_code": e.returncode,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": command_executed,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abyss/app/abyss_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_help_txt/mcp_abyss/app/abyss_server.py')
+SERVER_NAME = 'biosci_abyss'
+
+
+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_help_txt/mcp_abyss/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_abyss/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_aragorn/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 aragorn via conda (e.g., from bioconda)
+RUN conda install -c bioconda aragorn -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/aragorn_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/aragorn_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/aragorn_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_aragorn/app/aragorn_server.py

@@ -0,0 +1,217 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, List
+
+# This is a placeholder for the MCP environment's decorator.
+# In a real MCP environment, this would be provided.
+class mcp:
+    @staticmethod
+    def tool():
+        def decorator(f):
+            return f
+        return decorator
+
+@mcp.tool()
+def aragorn(
+    sequence_file: Path,
+    output_file: Optional[Path] = None,
+    search_mode: str = "both",
+    batch_output: bool = False,
+    fasta_output_all: bool = False,
+    fasta_output_all_seq_only: bool = False,
+    fasta_output_mature: bool = False,
+    fasta_output_mature_seq_only: bool = False,
+    fasta_output_all_no_spaces: bool = False,
+    fasta_output_mature_no_spaces: bool = False,
+    output_format: str = "normal",
+    verbose: bool = False,
+    verbose_trna_structure: bool = False,
+    verbose_tmrna_structure: bool = False,
+    genetic_code: str = "standard",
+    genetic_code_table_id: Optional[int] = None,
+    allow_introns: bool = False,
+    topology: str = "circular",
+    post_process_cutoff: Optional[float] = None,
+    no_post_process: bool = False,
+    ecoli_tloop: bool = False,
+    permuted_exons: bool = False,
+    input_format: Optional[int] = None,
+    strand: str = "both"
+):
+    """
+    Finds tRNA and tmRNA genes in nucleotide sequences using ARAGORN.
+
+    ARAGORN is a tool for finding transfer RNA (tRNA) and transfer-messenger RNA (tmRNA)
+    genes in nucleotide sequences. It uses homology search algorithms to identify
+    these genes with high accuracy.
+
+    Args:
+        sequence_file: Input FASTA file containing nucleotide sequences.
+        output_file: Specify the output file path. If not provided, output is sent to stdout.
+        search_mode: Type of genes to search for. One of 'both', 'trna', 'tmrna'.
+        batch_output: Use batch output in a readable format (-w).
+        fasta_output_all: Fasta output of all genes (-fo).
+        fasta_output_all_seq_only: Fasta output of all genes, sequence only (-fos).
+        fasta_output_mature: Fasta output of mature tRNAs (-fr).
+        fasta_output_mature_seq_only: Fasta output of mature tRNAs, sequence only (-frs).
+        fasta_output_all_no_spaces: Fasta output of all genes, no spaces in header (-fons).
+        fasta_output_mature_no_spaces: Fasta output of mature tRNAs, no spaces in header (-frns).
+        output_format: Specify the main output format. One of 'normal', 'fasta', 'raw', 'brackets'.
+        verbose: Enable verbose output (-v).
+        verbose_trna_structure: Print tRNA secondary structure with verbose output (-tv).
+        verbose_tmrna_structure: Print tmRNA secondary structure with verbose output (-mv).
+        genetic_code: Genetic code to use for tRNA search. One of 'standard', 'chloroplast', 'mitochondrial',
+                      'vertebrate_mitochondrial', 'invertebrate_mitochondrial', 'yeast_mitochondrial',
+                      'protozoan', 'mycoplasma'.
+        genetic_code_table_id: Specify genetic code by its table number (-gcode <n>).
+        allow_introns: Allow introns in tRNAs (-i).
+        topology: Assume sequence topology. One of 'circular' (default) or 'linear' (-l).
+        post_process_cutoff: Post-process with profile search, using a cutoff in bits (-ps <n>).
+        no_post_process: Do not post-process with profile search (-d).
+        ecoli_tloop: Use E. coli tRNA T-loop consensus T-Psi-C-R-A (-a).
+        permuted_exons: Search for tRNA genes with permuted exons (-rp).
+        input_format: Specify input format code (1=fasta, 2=plain, 3=embl, 4=genbank).
+        strand: Strand to search. One of 'both' (default), 'sense', 'complementary'.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not sequence_file.is_file():
+        raise FileNotFoundError(f"Input sequence file not found: {sequence_file}")
+
+    valid_search_modes = ["both", "trna", "tmrna"]
+    if search_mode not in valid_search_modes:
+        raise ValueError(f"Invalid search_mode '{search_mode}'. Must be one of {valid_search_modes}")
+
+    valid_output_formats = ["normal", "fasta", "raw", "brackets"]
+    if output_format not in valid_output_formats:
+        raise ValueError(f"Invalid output_format '{output_format}'. Must be one of {valid_output_formats}")
+
+    valid_genetic_codes = [
+        "standard", "chloroplast", "mitochondrial", "vertebrate_mitochondrial",
+        "invertebrate_mitochondrial", "yeast_mitochondrial", "protozoan", "mycoplasma"
+    ]
+    if genetic_code not in valid_genetic_codes:
+        raise ValueError(f"Invalid genetic_code '{genetic_code}'. Must be one of {valid_genetic_codes}")
+
+    if genetic_code != "standard" and genetic_code_table_id is not None:
+        raise ValueError("Cannot specify both a named genetic_code and a genetic_code_table_id.")
+
+    valid_topologies = ["circular", "linear"]
+    if topology not in valid_topologies:
+        raise ValueError(f"Invalid topology '{topology}'. Must be one of {valid_topologies}")
+
+    if post_process_cutoff is not None and no_post_process:
+        raise ValueError("Cannot specify both post_process_cutoff and no_post_process.")
+
+    if input_format is not None and input_format not in [1, 2, 3, 4]:
+        raise ValueError(f"Invalid input_format '{input_format}'. Must be one of 1, 2, 3, or 4.")
+
+    valid_strands = ["both", "sense", "complementary"]
+    if strand not in valid_strands:
+        raise ValueError(f"Invalid strand '{strand}'. Must be one of {valid_strands}")
+
+    # --- Command Construction ---
+    cmd = ["aragorn"]
+
+    if search_mode == "trna":
+        cmd.append("-t")
+    elif search_mode == "tmrna":
+        cmd.append("-m")
+
+    if output_file:
+        cmd.extend(["-o", str(output_file)])
+    if batch_output:
+        cmd.append("-w")
+    if fasta_output_all:
+        cmd.append("-fo")
+    if fasta_output_all_seq_only:
+        cmd.append("-fos")
+    if fasta_output_mature:
+        cmd.append("-fr")
+    if fasta_output_mature_seq_only:
+        cmd.append("-frs")
+    if fasta_output_all_no_spaces:
+        cmd.append("-fons")
+    if fasta_output_mature_no_spaces:
+        cmd.append("-frns")
+
+    if output_format == "fasta":
+        cmd.append("-fasta")
+    elif output_format == "raw":
+        cmd.append("-raw")
+    elif output_format == "brackets":
+        cmd.append("-br")
+
+    if verbose:
+        cmd.append("-v")
+    if verbose_trna_structure:
+        cmd.append("-tv")
+    if verbose_tmrna_structure:
+        cmd.append("-mv")
+
+    if genetic_code_table_id is not None:
+        cmd.extend(["-gcode", str(genetic_code_table_id)])
+    else:
+        code_map = {
+            "standard": "-gcstd", "chloroplast": "-c", "mitochondrial": "-mt",
+            "vertebrate_mitochondrial": "-gcvert", "invertebrate_mitochondrial": "-gcinvert",
+            "yeast_mitochondrial": "-gcyeast", "protozoan": "-gcprot", "mycoplasma": "-gcmyco"
+        }
+        if genetic_code != "standard":
+             cmd.append(code_map[genetic_code])
+
+    if allow_introns:
+        cmd.append("-i")
+    if topology == "linear":
+        cmd.append("-l")
+    if post_process_cutoff is not None:
+        cmd.extend(["-ps", str(post_process_cutoff)])
+    if no_post_process:
+        cmd.append("-d")
+    if ecoli_tloop:
+        cmd.append("-a")
+    if permuted_exons:
+        cmd.append("-rp")
+
+    if input_format is not None:
+        cmd.extend(["-if", str(input_format)])
+
+    if strand == "sense":
+        cmd.append("-sense")
+    elif strand == "complementary":
+        cmd.append("-sc")
+
+    cmd.append(str(sequence_file))
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+    except FileNotFoundError:
+        raise RuntimeError("aragorn executable not found. Please ensure it is in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        logging.error(f"ARAGORN execution failed with return code {e.returncode}")
+        logging.error(f"Stderr: {e.stderr}")
+        # Re-raise as a more informative exception for the MCP environment
+        raise RuntimeError(f"ARAGORN execution failed. Stderr: {e.stderr}")
+
+    # --- Structured Result Return ---
+    output_files_list = [str(output_file)] if output_file else []
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": output_files_list
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_aragorn/app/aragorn_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_help_txt/mcp_aragorn/app/aragorn_server.py')
+SERVER_NAME = 'biosci_aragorn'
+
+
+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_help_txt/mcp_aragorn/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_aragorn/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_aragorn/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_barrnap/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 barrnap via conda (e.g., from bioconda)
+RUN conda install -c bioconda barrnap -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/barrnap_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/barrnap_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/barrnap_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_barrnap/app/barrnap_server.py

@@ -0,0 +1,238 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Union
+
+# Assume mcp is imported and available in the actual runtime environment
+# from mcp import tool
+
+@mcp.tool()
+def perl(
+    program_file: Optional[Path] = None,
+    program_arguments: Optional[List[str]] = None,
+    zero_record_separator: Optional[str] = None,
+    autosplit_mode: bool = False,
+    unicode_features: Optional[str] = None,
+    check_syntax_only: bool = False,
+    debugger: Optional[str] = None,
+    debug_flags: Optional[str] = None,
+    execute_program_line: Optional[List[str]] = None,
+    execute_program_line_extended: Optional[List[str]] = None,
+    no_sitecustomize: bool = False,
+    split_pattern: Optional[str] = None,
+    in_place_edit_extension: Optional[str] = None,
+    include_directories: Optional[List[Path]] = None,
+    line_ending_processing: Optional[str] = None,
+    use_modules: Optional[List[str]] = None,
+    no_modules: Optional[List[str]] = None,
+    loop_around_program: bool = False,
+    loop_and_print: bool = False,
+    rudimentary_switches: bool = False,
+    search_path_for_program: bool = False,
+    tainting_warnings: bool = False,
+    tainting_checks: bool = False,
+    dump_core_after_parsing: bool = False,
+    allow_unsafe_operations: bool = False,
+    print_version: bool = False,
+    print_config_summary: Optional[str] = None,
+    enable_warnings: bool = False,
+    enable_all_warnings: bool = False,
+    ignore_text_before_shebang: Optional[Path] = None,
+    disable_all_warnings: bool = False,
+) -> dict:
+    """
+    Executes Perl programs with various command-line switches.
+
+    This tool provides an interface to the Perl interpreter, allowing users to
+    run Perl scripts, execute one-liners, and control various aspects of Perl's
+    behavior, including debugging, warnings, Unicode features, and module loading.
+
+    Args:
+        program_file: Path to the Perl program file to execute.
+                      If -e or -E is used, this should typically be omitted.
+        program_arguments: List of arguments to pass to the Perl program.
+        zero_record_separator: Specify record separator. If an empty string, uses '\0'.
+                               Otherwise, specifies an octal value. (e.g., "0" for -0, "0777" for -0777)
+        autosplit_mode: Enable autosplit mode with -n or -p (splits $_ into @F).
+        unicode_features: Enables the listed Unicode features (e.g., "all", "io").
+        check_syntax_only: Check syntax only (runs BEGIN and CHECK blocks).
+        debugger: Run program under debugger. If an empty string, uses default debugger (-d).
+                  Otherwise, specifies a debugger (e.g., ":MyDebugger").
+        debug_flags: Set debugging flags (argument is a bit mask or alphabets).
+        execute_program_line: One line of program to execute. Can be specified multiple times.
+                              If used, program_file should typically be omitted.
+        execute_program_line_extended: Like -e, but enables all optional features.
+                                       Can be specified multiple times.
+                                       If used, program_file should typically be omitted.
+        no_sitecustomize: Don't do $sitelib/sitecustomize.pl at startup.
+        split_pattern: split() pattern for -a switch (e.g., "/\t/").
+        in_place_edit_extension: Edit <> files in place. If an empty string, no backup is made (-i).
+                                 If an extension is supplied (e.g., ".bak"), a backup is made.
+        include_directories: Specify @INC/#include directory. Can be specified multiple times.
+        line_ending_processing: Enable line ending processing. If an empty string, enables default (-l).
+                                Otherwise, specifies line terminator (e.g., "012").
+        use_modules: Execute "use module..." before executing program. Can be specified multiple times.
+                     Corresponds to -m or -M.
+        no_modules: Execute "no module..." before executing program. Can be specified multiple times.
+                    Corresponds to -m- or -M-.
+        loop_around_program: Assume "while (<>) { ... }" loop around program (-n).
+        loop_and_print: Assume loop like -n but print line also, like sed (-p).
+        rudimentary_switches: Enable rudimentary parsing for switches after programfile (-s).
+        search_path_for_program: Look for programfile using PATH environment variable (-S).
+        tainting_warnings: Enable tainting warnings (-t).
+        tainting_checks: Enable tainting checks (-T).
+        dump_core_after_parsing: Dump core after parsing program (-u).
+        allow_unsafe_operations: Allow unsafe operations (-U).
+        print_version: Print version, patchlevel and license (-v).
+        print_config_summary: Print configuration summary. If an empty string, prints full summary (-V).
+                              Otherwise, prints a single Config.pm variable (e.g., ":archname").
+        enable_warnings: Enable many useful warnings (-w).
+        enable_all_warnings: Enable all warnings (-W).
+        ignore_text_before_shebang: Ignore text before #!perl line. If None, just ignores (-x).
+                                    Optionally change to directory (e.g., Path("/tmp")).
+        disable_all_warnings: Disable all warnings (-X).
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+    """
+    cmd = ["perl"]
+    output_files = []
+
+    # Input validation
+    if program_file and not program_file.is_file():
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": f"Error: Program file '{program_file}' not found.",
+            "output_files": [],
+        }
+
+    if (execute_program_line or execute_program_line_extended) and program_file:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: Cannot use -e/-E with a program file. Please omit program_file.",
+            "output_files": [],
+        }
+
+    # Add switches
+    if zero_record_separator is not None:
+        cmd.append(f"-0{zero_record_separator}")
+    if autosplit_mode:
+        cmd.append("-a")
+    if unicode_features:
+        cmd.append(f"-C{unicode_features}")
+    if check_syntax_only:
+        cmd.append("-c")
+    if debugger is not None:
+        cmd.append(f"-d{':' if debugger else ''}{debugger}")
+    if debug_flags:
+        cmd.append(f"-D{debug_flags}")
+    if execute_program_line:
+        for line in execute_program_line:
+            cmd.append("-e")
+            cmd.append(line)
+    if execute_program_line_extended:
+        for line in execute_program_line_extended:
+            cmd.append("-E")
+            cmd.append(line)
+    if no_sitecustomize:
+        cmd.append("-f")
+    if split_pattern:
+        cmd.append(f"-F{split_pattern}")
+    if in_place_edit_extension is not None:
+        cmd.append(f"-i{in_place_edit_extension}")
+    if include_directories:
+        for directory in include_directories:
+            if not directory.is_dir():
+                return {
+                    "command_executed": " ".join(cmd),
+                    "stdout": "",
+                    "stderr": f"Error: Include directory '{directory}' not found.",
+                    "output_files": [],
+                }
+            cmd.append("-I")
+            cmd.append(str(directory))
+    if line_ending_processing is not None:
+        cmd.append(f"-l{line_ending_processing}")
+    if use_modules:
+        for module in use_modules:
+            # The help document shows -[mM][-]module.
+            # Assuming -M for 'use' and -m- for 'no'.
+            # For simplicity, we'll use -M for 'use' as it's more common for explicit module loading.
+            cmd.append(f"-M{module}")
+    if no_modules:
+        for module in no_modules:
+            cmd.append(f"-M-{module}") # Using -M- for 'no module'
+    if loop_around_program:
+        cmd.append("-n")
+    if loop_and_print:
+        cmd.append("-p")
+    if rudimentary_switches:
+        cmd.append("-s")
+    if search_path_for_program:
+        cmd.append("-S")
+    if tainting_warnings:
+        cmd.append("-t")
+    if tainting_checks:
+        cmd.append("-T")
+    if dump_core_after_parsing:
+        cmd.append("-u")
+    if allow_unsafe_operations:
+        cmd.append("-U")
+    if print_version:
+        cmd.append("-v")
+    if print_config_summary is not None:
+        cmd.append(f"-V{':' if print_config_summary else ''}{print_config_summary}")
+    if enable_warnings:
+        cmd.append("-w")
+    if enable_all_warnings:
+        cmd.append("-W")
+    if ignore_text_before_shebang is not None:
+        if ignore_text_before_shebang and not ignore_text_before_shebang.is_dir():
+            return {
+                "command_executed": " ".join(cmd),
+                "stdout": "",
+                "stderr": f"Error: Directory for -x '{ignore_text_before_shebang}' not found.",
+                "output_files": [],
+            }
+        cmd.append(f"-x{str(ignore_text_before_shebang) if ignore_text_before_shebang else ''}")
+    if disable_all_warnings:
+        cmd.append("-X")
+
+    # Add program file and its arguments
+    if program_file:
+        cmd.append(str(program_file))
+    if program_arguments:
+        cmd.extend(program_arguments)
+
+    try:
+        process = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(e.cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'perl' command not found. Ensure Perl is installed and in your PATH.",
+            "output_files": [],
+        }
+
+    return {
+        "command_executed": " ".join(cmd),
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files,
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_barrnap/app/barrnap_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_help_txt/mcp_barrnap/app/barrnap_server.py')
+SERVER_NAME = 'biosci_barrnap'
+
+
+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_help_txt/mcp_barrnap/app/requirements.txt

@@ -0,0 +1 @@
+

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_barrnap/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_barrnap/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bedops/requirements.txt

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bedtools/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 bedtools via conda (e.g., from bioconda)
+RUN conda install -c bioconda bedtools -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 bedtools_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/bedtools_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/bedtools_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bedtools/app/bedtools_server.py

@@ -0,0 +1,700 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+def tool(func):
+    """A dummy decorator to stand in for @mcp.tool()."""
+    return func
+
+mcp = type("mcp", (), {"tool": tool})
+
+
+@mcp.tool()
+def intersect(
+    a: Path,
+    b: List[Path],
+    output: Optional[Path] = None,
+    wa: bool = False,
+    wb: bool = False,
+    loj: bool = False,
+    wo: bool = False,
+    wao: bool = False,
+    u: bool = False,
+    c: bool = False,
+    v: bool = False,
+    ubam: bool = False,
+    s: bool = False,
+    S: bool = False,
+    f: float = 1e-9,
+    F: float = 1e-9,
+    r: bool = False,
+    e: bool = False,
+    split: bool = False,
+    g: Optional[Path] = None,
+    header: bool = False,
+    bed: bool = False,
+    sorted: bool = False,
+    names: Optional[str] = None,
+    filenames: bool = False,
+    nonamecheck: bool = False,
+):
+    """
+    Find overlapping intervals in two or more BED/GFF/VCF/BAM files.
+
+    This tool allows one to screen for overlaps between two sets of genomic features.
+    """
+    # Input validation
+    if not a.exists():
+        raise FileNotFoundError(f"Input file -a does not exist: {a}")
+    for b_file in b:
+        if not b_file.exists():
+            raise FileNotFoundError(f"Input file in -b list does not exist: {b_file}")
+    if g and not g.exists():
+        raise FileNotFoundError(f"Genome file -g does not exist: {g}")
+
+    exclusive_flags = [u, c, v, wo, wao]
+    if sum(exclusive_flags) > 1:
+        raise ValueError("Options -u, -c, -v, -wo, -wao are mutually exclusive.")
+    if s and S:
+        raise ValueError("Options -s and -S are mutually exclusive.")
+    if f < 0.0 or f > 1.0:
+        raise ValueError("-f (fraction) must be between 0.0 and 1.0.")
+    if F < 0.0 or F > 1.0:
+        raise ValueError("-F (fraction) must be between 0.0 and 1.0.")
+    if sorted and not g:
+        raise ValueError("The -sorted option requires a genome file (-g).")
+
+    # Command construction
+    cmd = ["bedtools", "intersect", "-a", str(a), "-b"]
+    cmd.extend([str(p) for p in b])
+
+    if wa: cmd.append("-wa")
+    if wb: cmd.append("-wb")
+    if loj: cmd.append("-loj")
+    if wo: cmd.append("-wo")
+    if wao: cmd.append("-wao")
+    if u: cmd.append("-u")
+    if c: cmd.append("-c")
+    if v: cmd.append("-v")
+    if ubam: cmd.append("-ubam")
+    if s: cmd.append("-s")
+    if S: cmd.append("-S")
+    if f != 1e-9: cmd.extend(["-f", str(f)])
+    if F != 1e-9: cmd.extend(["-F", str(F)])
+    if r: cmd.append("-r")
+    if e: cmd.append("-e")
+    if split: cmd.append("-split")
+    if g: cmd.extend(["-g", str(g)])
+    if header: cmd.append("-header")
+    if bed: cmd.append("-bed")
+    if sorted: cmd.append("-sorted")
+    if names: cmd.extend(["-names", names])
+    if filenames: cmd.append("-filenames")
+    if nonamecheck: cmd.append("-nonamecheck")
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def merge(
+    i: Path,
+    output: Optional[Path] = None,
+    s: bool = False,
+    S: Optional[str] = None,
+    d: int = 0,
+    c: Optional[str] = None,
+    o: Optional[str] = None,
+    header: bool = False,
+    delim: str = ";",
+    n: bool = False,
+    nms: bool = False,
+    scores: Optional[str] = None,
+    bed: bool = False,
+    prec: int = 5,
+):
+    """
+    Merge overlapping features in a BED/GFF/VCF file.
+
+    This tool combines overlapping or "book-ended" features into a single feature.
+    """
+    # Input validation
+    if not i.exists():
+        raise FileNotFoundError(f"Input file -i does not exist: {i}")
+    if S and S not in ["+", "-"]:
+        raise ValueError("Option -S must be either '+' or '-'.")
+    if s and S:
+        raise ValueError("Options -s and -S are mutually exclusive.")
+    if d < 0:
+        raise ValueError("Option -d (distance) must be a non-negative integer.")
+    if (c and not o) or (o and not c):
+        raise ValueError("Options -c and -o must be used together.")
+    if c and o:
+        if len(c.split(',')) != len(o.split(',')):
+            raise ValueError("The number of columns in -c must match the number of operations in -o.")
+
+    # Command construction
+    cmd = ["bedtools", "merge", "-i", str(i)]
+
+    if s: cmd.append("-s")
+    if S: cmd.extend(["-S", S])
+    if d > 0: cmd.extend(["-d", str(d)])
+    if c: cmd.extend(["-c", c])
+    if o: cmd.extend(["-o", o])
+    if header: cmd.append("-header")
+    if delim != ";": cmd.extend(["-delim", delim])
+    if n: cmd.append("-n")
+    if nms: cmd.append("-nms")
+    if scores: cmd.extend(["-scores", scores])
+    if bed: cmd.append("-bed")
+    if prec != 5: cmd.extend(["-prec", str(prec)])
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def subtract(
+    a: Path,
+    b: List[Path],
+    output: Optional[Path] = None,
+    f: float = 1e-9,
+    F: float = 1e-9,
+    r: bool = False,
+    e: bool = False,
+    s: bool = False,
+    S: bool = False,
+    A: bool = False,
+    B: bool = False,
+    N: bool = False,
+    header: bool = False,
+    g: Optional[Path] = None,
+):
+    """
+    Remove overlapping intervals from a BED/GFF/VCF file.
+
+    This tool removes portions of features in file A that are overlapped by features in file(s) B.
+    """
+    # Input validation
+    if not a.exists():
+        raise FileNotFoundError(f"Input file -a does not exist: {a}")
+    for b_file in b:
+        if not b_file.exists():
+            raise FileNotFoundError(f"Input file in -b list does not exist: {b_file}")
+    if g and not g.exists():
+        raise FileNotFoundError(f"Genome file -g does not exist: {g}")
+    if A and B:
+        raise ValueError("Options -A and -B are mutually exclusive.")
+    if s and S:
+        raise ValueError("Options -s and -S are mutually exclusive.")
+
+    # Command construction
+    cmd = ["bedtools", "subtract", "-a", str(a), "-b"]
+    cmd.extend([str(p) for p in b])
+
+    if f != 1e-9: cmd.extend(["-f", str(f)])
+    if F != 1e-9: cmd.extend(["-F", str(F)])
+    if r: cmd.append("-r")
+    if e: cmd.append("-e")
+    if s: cmd.append("-s")
+    if S: cmd.append("-S")
+    if A: cmd.append("-A")
+    if B: cmd.append("-B")
+    if N: cmd.append("-N")
+    if header: cmd.append("-header")
+    if g: cmd.extend(["-g", str(g)])
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def slop(
+    i: Path,
+    g: Path,
+    output: Optional[Path] = None,
+    b: int = 0,
+    l: int = 0,
+    r: int = 0,
+    s: bool = False,
+    pct: bool = False,
+    header: bool = False,
+):
+    """
+    Increase the size of features in a BED/GFF/VCF file.
+
+    This tool will increase the size of each feature in a feature file by a user-defined number of bases.
+    """
+    # Input validation
+    if not i.exists():
+        raise FileNotFoundError(f"Input file -i does not exist: {i}")
+    if not g.exists():
+        raise FileNotFoundError(f"Genome file -g does not exist: {g}")
+    if b != 0 and (l != 0 or r != 0):
+        raise ValueError("Option -b cannot be used with -l or -r.")
+
+    # Command construction
+    cmd = ["bedtools", "slop", "-i", str(i), "-g", str(g)]
+
+    if b != 0: cmd.extend(["-b", str(b)])
+    if l != 0: cmd.extend(["-l", str(l)])
+    if r != 0: cmd.extend(["-r", str(r)])
+    if s: cmd.append("-s")
+    if pct: cmd.append("-pct")
+    if header: cmd.append("-header")
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def getfasta(
+    fi: Path,
+    bed: Path,
+    fo: Optional[Path] = None,
+    s: bool = False,
+    split: bool = False,
+    name: bool = False,
+    name_plus: bool = False,
+    tab: bool = False,
+    full_header: bool = False,
+):
+    """
+    Extract DNA sequences from a FASTA file based on BED/GFF/VCF coordinates.
+    """
+    # Input validation
+    if not fi.exists():
+        raise FileNotFoundError(f"FASTA input file -fi does not exist: {fi}")
+    if not bed.exists():
+        raise FileNotFoundError(f"BED/GFF/VCF file -bed does not exist: {bed}")
+    if name and name_plus:
+        raise ValueError("Options -name and -name+ are mutually exclusive.")
+
+    # Command construction
+    cmd = ["bedtools", "getfasta", "-fi", str(fi), "-bed", str(bed)]
+
+    if s: cmd.append("-s")
+    if split: cmd.append("-split")
+    if name: cmd.append("-name")
+    if name_plus: cmd.append("-name+")
+    if tab: cmd.append("-tab")
+    if full_header: cmd.append("-fullHeader")
+    if fo: cmd.extend(["-fo", str(fo)])
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        # getfasta is unique in that it has a dedicated -fo parameter
+        # and doesn't typically write to stdout if -fo is used.
+        result = subprocess.run(
+            cmd, check=True, text=True, capture_output=True
+        )
+        stdout_capture = result.stdout
+        stderr_capture = result.stderr
+        if fo:
+            output_files.append(str(fo))
+
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def sort(
+    i: Path,
+    output: Optional[Path] = None,
+    header: bool = False,
+    g: Optional[Path] = None,
+    faidx: Optional[Path] = None,
+    sizeA: bool = False,
+    sizeD: bool = False,
+    chrThenSizeA: bool = False,
+    chrThenSizeD: bool = False,
+    chrThenScoreA: bool = False,
+    chrThenScoreD: bool = False,
+):
+    """
+    Sort a BED/GFF/VCF file by chromosome and then by start position.
+    """
+    # Input validation
+    if not i.exists():
+        raise FileNotFoundError(f"Input file -i does not exist: {i}")
+    if g and not g.exists():
+        raise FileNotFoundError(f"Genome file -g does not exist: {g}")
+    if faidx and not faidx.exists():
+        raise FileNotFoundError(f"FASTA index file -faidx does not exist: {faidx}")
+
+    sort_flags = [sizeA, sizeD, chrThenSizeA, chrThenSizeD, chrThenScoreA, chrThenScoreD]
+    if sum(sort_flags) > 1:
+        raise ValueError("Multiple sorting order flags were provided, but only one is allowed.")
+
+    # Command construction
+    cmd = ["bedtools", "sort", "-i", str(i)]
+
+    if header: cmd.append("-header")
+    if g: cmd.extend(["-g", str(g)])
+    if faidx: cmd.extend(["-faidx", str(faidx)])
+    if sizeA: cmd.append("-sizeA")
+    if sizeD: cmd.append("-sizeD")
+    if chrThenSizeA: cmd.append("-chrThenSizeA")
+    if chrThenSizeD: cmd.append("-chrThenSizeD")
+    if chrThenScoreA: cmd.append("-chrThenScoreA")
+    if chrThenScoreD: cmd.append("-chrThenScoreD")
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def coverage(
+    a: Path,
+    b: List[Path],
+    output: Optional[Path] = None,
+    s: bool = False,
+    S: bool = False,
+    f: float = 1e-9,
+    F: float = 1e-9,
+    r: bool = False,
+    e: bool = False,
+    split: bool = False,
+    d: bool = False,
+    counts: bool = False,
+    hist: bool = False,
+    mean: bool = False,
+    g: Optional[Path] = None,
+    header: bool = False,
+    sorted: bool = False,
+):
+    """
+    Compute the coverage of features in file A on features in file(s) B.
+    """
+    # Input validation
+    if not a.exists():
+        raise FileNotFoundError(f"Input file -a does not exist: {a}")
+    for b_file in b:
+        if not b_file.exists():
+            raise FileNotFoundError(f"Input file in -b list does not exist: {b_file}")
+    if g and not g.exists():
+        raise FileNotFoundError(f"Genome file -g does not exist: {g}")
+    if s and S:
+        raise ValueError("Options -s and -S are mutually exclusive.")
+    if sorted and not g:
+        raise ValueError("The -sorted option requires a genome file (-g).")
+
+    # Command construction
+    cmd = ["bedtools", "coverage", "-a", str(a), "-b"]
+    cmd.extend([str(p) for p in b])
+
+    if s: cmd.append("-s")
+    if S: cmd.append("-S")
+    if f != 1e-9: cmd.extend(["-f", str(f)])
+    if F != 1e-9: cmd.extend(["-F", str(F)])
+    if r: cmd.append("-r")
+    if e: cmd.append("-e")
+    if split: cmd.append("-split")
+    if d: cmd.append("-d")
+    if counts: cmd.append("-counts")
+    if hist: cmd.append("-hist")
+    if mean: cmd.append("-mean")
+    if g: cmd.extend(["-g", str(g)])
+    if header: cmd.append("-header")
+    if sorted: cmd.append("-sorted")
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }
+
+
+@mcp.tool()
+def genomecov(
+    i: Path,
+    g: Path,
+    output: Optional[Path] = None,
+    d: bool = False,
+    dz: bool = False,
+    bga: bool = False,
+    bg: bool = False,
+    scale: float = 1.0,
+    pc: bool = False,
+    fs: bool = False,
+    split: bool = False,
+    strand: Optional[str] = None,
+    max: int = 0,
+    trackline: bool = False,
+    trackopts: Optional[str] = None,
+):
+    """
+    Compute genome-wide coverage of a feature file.
+    """
+    # Input validation
+    if not i.exists():
+        raise FileNotFoundError(f"Input file -i does not exist: {i}")
+    if not g.exists():
+        raise FileNotFoundError(f"Genome file -g does not exist: {g}")
+    if strand and strand not in ["+", "-"]:
+        raise ValueError("Option -strand must be either '+' or '-'.")
+    if max < 0:
+        raise ValueError("Option -max must be a non-negative integer.")
+    output_modes = [d, dz, bga, bg]
+    if sum(output_modes) > 1:
+        raise ValueError("Output format flags (-d, -dz, -bga, -bg) are mutually exclusive.")
+
+    # Command construction
+    cmd = ["bedtools", "genomecov", "-i", str(i), "-g", str(g)]
+
+    if d: cmd.append("-d")
+    if dz: cmd.append("-dz")
+    if bga: cmd.append("-bga")
+    if bg: cmd.append("-bg")
+    if scale != 1.0: cmd.extend(["-scale", str(scale)])
+    if pc: cmd.append("-pc")
+    if fs: cmd.append("-fs")
+    if split: cmd.append("-split")
+    if strand: cmd.extend(["-strand", strand])
+    if max > 0: cmd.extend(["-max", str(max)])
+    if trackline: cmd.append("-trackline")
+    if trackopts: cmd.extend(["-trackopts", trackopts])
+
+    # Subprocess execution
+    command_executed = " ".join(cmd)
+    output_files = []
+    stdout_capture, stderr_capture = "", ""
+
+    try:
+        if output:
+            output_files.append(str(output))
+            with open(output, "w") as f_out:
+                result = subprocess.run(
+                    cmd, check=True, text=True, stdout=f_out, stderr=subprocess.PIPE
+                )
+            stderr_capture = result.stderr
+        else:
+            result = subprocess.run(
+                cmd, check=True, text=True, capture_output=True
+            )
+            stdout_capture = result.stdout
+            stderr_capture = result.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout or "",
+            "stderr": e.stderr or "CalledProcessError with no stderr.",
+            "output_files": [],
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files,
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bedtools/app/bedtools_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_help_txt/mcp_bedtools/app/bedtools_server.py')
+SERVER_NAME = 'biosci_bedtools'
+
+
+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_help_txt/mcp_bedtools/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bedtools/requirements.txt

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-apeglm/app/bioconductor-apeglm_server.py

@@ -0,0 +1,125 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+@mcp.tool()
+def run_r_script(
+    r_script_file: Optional[Path] = None,
+    r_expressions: Optional[List[str]] = None,
+    script_args: Optional[List[str]] = None,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+    save_workspace: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    restore_workspace: bool = False,
+    vanilla: bool = False,
+) -> Dict[str, Any]:
+    """
+    Executes an R script file or R expressions using the Rscript command.
+
+    This tool provides a wrapper for the Rscript command, allowing users to run
+    R code with various configuration options. It supports executing a specified
+    R script file or a list of R expressions directly. It also allows passing
+    arguments to the R script itself and configuring R's startup behavior.
+
+    Args:
+        r_script_file: Path to an R script file to execute. Mutually exclusive with `r_expressions`.
+        r_expressions: A list of R expressions (strings) to execute. Mutually exclusive with `r_script_file`.
+        script_args: A list of arguments to be passed to the R script or expressions.
+        verbose: If True, print information on progress (corresponds to Rscript's --verbose).
+        default_packages: A comma-separated list of package names, or 'NULL',
+                          to set the default packages loaded (corresponds to --default-packages).
+        save_workspace: If True, save the workspace at the end of the session (corresponds to R's --save).
+                        Ignored if `vanilla` is True.
+        no_environ: If True, don't read the site and user environment files (corresponds to R's --no-environ).
+                    Ignored if `vanilla` is True.
+        no_site_file: If True, don't read the site-wide Rprofile (corresponds to R's --no-site-file).
+                      Ignored if `vanilla` is True.
+        no_init_file: If True, don't read the user R profile (corresponds to R's --no-init-file).
+                      Ignored if `vanilla` is True.
+        restore_workspace: If True, restore previously saved objects at startup (corresponds to R's --restore).
+                           Ignored if `vanilla` is True.
+        vanilla: If True, combine --no-save, --no-restore, --no-site-file, --no-init-file, and --no-environ.
+                 This option overrides individual settings for these flags.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and any output files.
+        In case of an error, it includes error details and the return code.
+
+    Raises:
+        ValueError: If neither `r_script_file` nor `r_expressions` is provided, or if both are provided.
+        FileNotFoundError: If `r_script_file` is provided but does not exist.
+    """
+    command: List[str] = ["Rscript"]
+    output_files: List[Path] = []
+
+    # Input validation for script source
+    if r_script_file is None and r_expressions is None:
+        raise ValueError("Either 'r_script_file' or 'r_expressions' must be provided.")
+    if r_script_file is not None and r_expressions is not None:
+        raise ValueError("Cannot provide both 'r_script_file' and 'r_expressions'. Choose one.")
+
+    if r_script_file:
+        if not r_script_file.is_file():
+            raise FileNotFoundError(f"R script file not found: {r_script_file}")
+
+    # Add Rscript specific options
+    if verbose:
+        command.append("--verbose")
+    if default_packages is not None:
+        command.append(f"--default-packages={default_packages}")
+
+    # Add R options (passed to R, in addition to --no-echo --no-restore by Rscript)
+    if vanilla:
+        command.append("--vanilla")
+    else:
+        # Only add these if --vanilla is not set, as --vanilla implies them
+        if save_workspace:
+            command.append("--save")
+        if no_environ:
+            command.append("--no-environ")
+        if no_site_file:
+            command.append("--no-site-file")
+        if no_init_file:
+            command.append("--no-init-file")
+        if restore_workspace:
+            command.append("--restore")
+
+    # Add the script source (file or expressions)
+    if r_script_file:
+        command.append(str(r_script_file))
+    elif r_expressions:
+        for expr in r_expressions:
+            command.extend(["-e", expr])
+
+    # Add arguments to the R script
+    if script_args:
+        command.extend(script_args)
+
+    try:
+        process = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(command),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "returncode": e.returncode,
+            "output_files": output_files,
+        }
+
+    return {
+        "command_executed": " ".join(command),
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files,
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-apeglm/app/bioconductor-apeglm_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_help_txt/mcp_bioconductor-apeglm/app/bioconductor-apeglm_server.py')
+SERVER_NAME = 'biosci_bioconductor_apeglm'
+
+
+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_help_txt/mcp_bioconductor-apeglm/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-apeglm/requirements.txt

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-beachmat/app/bioconductor-beachmat_server.py

@@ -0,0 +1,218 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+@mcp.tool()
+def rscript_run_script(
+    script_path: str,
+    args: List[str] = [],
+    vanilla: bool = True,
+    save: bool = False,
+    restore: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Execute an R script file using Rscript, typically used for Bioconductor/beachmat workflows.
+    
+    Args:
+        script_path: Path to the R script file (.R).
+        args: Additional command line arguments passed to the script.
+        vanilla: Combine --no-save, --no-restore, --no-site-file, --no-init-file and --no-environ.
+        save: Do save workspace at the end of the session.
+        restore: Do restore previously saved objects at startup.
+        no_environ: Don't read the site and user environment files.
+        no_site_file: Don't read the site-wide Rprofile.
+        no_init_file: Don't read the user R profile.
+        verbose: Print information on progress.
+        default_packages: Comma-separated set of package names, or 'NULL'.
+    """
+    script_file = Path(script_path)
+    if not script_file.exists():
+        return {"error": f"Script file not found: {script_path}"}
+
+    cmd = ["Rscript"]
+
+    # Add options
+    if vanilla:
+        cmd.append("--vanilla")
+    if save:
+        cmd.append("--save")
+    if restore:
+        cmd.append("--restore")
+    if no_environ:
+        cmd.append("--no-environ")
+    if no_site_file:
+        cmd.append("--no-site-file")
+    if no_init_file:
+        cmd.append("--no-init-file")
+    if verbose:
+        cmd.append("--verbose")
+    if default_packages:
+        cmd.append(f"--default-packages={default_packages}")
+
+    cmd.append(str(script_file))
+    
+    if args:
+        cmd.extend(args)
+
+    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 rscript_run_expression(
+    expressions: List[str],
+    vanilla: bool = True,
+    save: bool = False,
+    restore: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Execute one or more R expressions directly from the command line.
+    Useful for quick beachmat matrix manipulations or checks.
+    
+    Args:
+        expressions: A list of R code strings to execute (each corresponds to a -e flag).
+        vanilla: Combine --no-save, --no-restore, --no-site-file, --no-init-file and --no-environ.
+        save: Do save workspace at the end of the session.
+        restore: Do restore previously saved objects at startup.
+        no_environ: Don't read the site and user environment files.
+        no_site_file: Don't read the site-wide Rprofile.
+        no_init_file: Don't read the user R profile.
+        verbose: Print information on progress.
+        default_packages: Comma-separated set of package names, or 'NULL'.
+    """
+    if not expressions:
+        return {"error": "No expressions provided."}
+
+    cmd = ["Rscript"]
+
+    # Add options
+    if vanilla:
+        cmd.append("--vanilla")
+    if save:
+        cmd.append("--save")
+    if restore:
+        cmd.append("--restore")
+    if no_environ:
+        cmd.append("--no-environ")
+    if no_site_file:
+        cmd.append("--no-site-file")
+    if no_init_file:
+        cmd.append("--no-init-file")
+    if verbose:
+        cmd.append("--verbose")
+    if default_packages:
+        cmd.append(f"--default-packages={default_packages}")
+
+    for expr in expressions:
+        cmd.extend(["-e", expr])
+
+    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 beachmat_inspect_matrix(
+    rds_path: str,
+) -> Dict[str, Any]:
+    """
+    Specific utility to inspect an R matrix object (RDS file) using the beachmat package logic.
+    Identifies matrix class, dimensions, and storage mode.
+    
+    Args:
+        rds_path: Path to an RDS file containing a matrix-like object.
+    """
+    input_path = Path(rds_path)
+    if not input_path.exists():
+        return {"error": f"RDS file not found: {rds_path}"}
+
+    # R code to inspect the matrix using beachmat-compatible logic
+    r_code = (
+        "suppressPackageStartupMessages(library(beachmat)); "
+        f"mat <- readRDS('{str(input_path)}'); "
+        "cat('--- Matrix Metadata ---\\n'); "
+        "cat('Class:', paste(class(mat), collapse=', '), '\\n'); "
+        "cat('Dimensions:', paste(dim(mat), collapse=' x '), '\\n'); "
+        "if(is(mat, 'dgCMatrix')) { cat('Type: Sparse (dgCMatrix)\\n') } "
+        "else if(is(mat, 'HDF5Matrix')) { cat('Type: HDF5-backed\\n') } "
+        "else { cat('Type: Dense/Other\\n') }; "
+        "cat('Storage Mode:', storage.mode(mat), '\\n')"
+    )
+
+    cmd = ["Rscript", "--vanilla", "-e", r_code]
+
+    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": "Ensure 'beachmat' and 'DelayedArray' are installed in the R environment.",
+            "status": "error"
+        }
+
+@mcp.tool()
+def rscript_get_version() -> Dict[str, Any]:
+    """
+    Get the version information for Rscript and the R environment.
+    """
+    cmd = ["Rscript", "--version"]
+    try:
+        # Rscript --version often outputs to stderr
+        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_help_txt/mcp_bioconductor-beachmat/app/bioconductor-beachmat_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_help_txt/mcp_bioconductor-beachmat/app/bioconductor-beachmat_server.py')
+SERVER_NAME = 'biosci_bioconductor_beachmat'
+
+
+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_help_txt/mcp_bioconductor-beachmat/docker-compose.yml

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-beachmat/requirements.txt

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-biobase/app/bioconductor-biobase_server.py

@@ -0,0 +1,159 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# MCP decorator is assumed to be available in the execution environment.
+# No need to define or import it.
+
+@mcp.tool
+def rscript_run(
+    script_file: Optional[Path] = None,
+    expressions: Optional[List[str]] = None,
+    script_args: Optional[List[str]] = None,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+    save: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    restore: bool = False,
+    vanilla: bool = False,
+) -> dict:
+    """
+    Executes an R script or R expressions using the Rscript command-line tool.
+
+    This tool is a wrapper for Rscript, allowing the execution of R code from a
+    file or directly as string expressions. It is commonly used for running
+    bioinformatics scripts that rely on R and Bioconductor packages.
+
+    Args:
+        script_file: Path to the R script file to be executed.
+        expressions: A list of R expressions to execute. Use this or script_file, not both.
+        script_args: A list of arguments to be passed to the R script itself.
+        verbose: If True, enables verbose output, printing progress information.
+        default_packages: A comma-separated string of package names to be loaded by default.
+        save: If True, the R workspace is saved at the end of the session (--save).
+        no_environ: If True, site and user environment files are not read (--no-environ).
+        no_site_file: If True, the site-wide Rprofile is not read (--no-site-file).
+        no_init_file: If True, the user's R profile is not read (--no-init-file).
+        restore: If True, previously saved objects are restored at startup (--restore).
+        vanilla: If True, combines --no-save, --no-restore, --no-site-file,
+                 --no-init-file, and --no-environ. Overrides the individual flags.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of output files.
+    """
+    # 1. Input Validation
+    if (script_file is None and not expressions) or (script_file is not None and expressions):
+        raise ValueError("You must provide either 'script_file' or 'expressions', but not both.")
+
+    if script_file and not script_file.is_file():
+        raise FileNotFoundError(f"The specified script file does not exist: {script_file}")
+
+    # 2. Command Construction
+    cmd = ["Rscript"]
+
+    if vanilla:
+        cmd.append("--vanilla")
+    else:
+        if save:
+            cmd.append("--save")
+        if no_environ:
+            cmd.append("--no-environ")
+        if no_site_file:
+            cmd.append("--no-site-file")
+        if no_init_file:
+            cmd.append("--no-init-file")
+        if restore:
+            cmd.append("--restore")
+
+    if verbose:
+        cmd.append("--verbose")
+
+    if default_packages:
+        cmd.append(f"--default-packages={default_packages}")
+
+    if expressions:
+        for expr in expressions:
+            cmd.extend(["-e", expr])
+    
+    if script_file:
+        cmd.append(str(script_file))
+
+    if script_args:
+        cmd.extend(script_args)
+
+    command_executed = " ".join(cmd)
+    logger.info(f"Executing command: {command_executed}")
+
+    # 3. Subprocess Execution
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": []
+        }
+    except FileNotFoundError:
+        logger.error("Rscript not found. Please ensure R is installed and in your PATH.")
+        raise
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Rscript execution failed with return code {e.returncode}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Rscript execution failed.",
+            "return_code": e.returncode,
+            "output_files": []
+        }
+
+@mcp.tool
+def rscript_version() -> dict:
+    """
+    Retrieves the version of the Rscript interpreter.
+
+    Returns:
+        A dictionary containing the executed command and the version information.
+    """
+    cmd = ["Rscript", "--version"]
+    command_executed = " ".join(cmd)
+    logger.info(f"Executing command: {command_executed}")
+
+    try:
+        # Rscript --version prints to stderr and exits with code 0.
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except FileNotFoundError:
+        logger.error("Rscript not found. Please ensure R is installed and in your PATH.")
+        raise
+    except subprocess.CalledProcessError as e:
+        # This case is unlikely for Rscript --version but is good practice.
+        logger.error(f"Failed to get Rscript version. Return code: {e.returncode}")
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Failed to retrieve Rscript version.",
+            "return_code": e.returncode,
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_help_txt/mcp_bioconductor-biobase/app/bioconductor-biobase_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_help_txt/mcp_bioconductor-biobase/app/bioconductor-biobase_server.py')
+SERVER_NAME = 'biosci_bioconductor_biobase'
+
+
+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_help_txt/mcp_bioconductor-biobase/docker-compose.yml

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