Add files using upload-large-folder tool

Biomni/mcp_generated/mcp_abnumber/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 abnumber via conda (e.g., from bioconda)
+RUN conda install -c bioconda abnumber -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/abnumber_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/abnumber_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/abnumber_server.py"]
+        

Biomni/mcp_generated/mcp_abnumber/docker-compose.yml

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

Biomni/mcp_generated/mcp_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,
+    }

Biomni/mcp_generated/mcp_abyss/requirements.txt

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

Biomni/mcp_generated/mcp_arvados-cwl-runner/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 arvados-cwl-runner via conda (e.g., from bioconda)
+RUN conda install -c bioconda arvados-cwl-runner -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/arvados-cwl-runner_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/arvados-cwl-runner_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/arvados-cwl-runner_server.py"]
+        

Biomni/mcp_generated/mcp_arvados-cwl-runner/app/arvados-cwl-runner_server.py

@@ -0,0 +1,278 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List, Union
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_arvados_cwl_runner'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def arvados_cwl_runner(
+    workflow: str,
+    job_order: Optional[str] = None,
+    project_uuid: Optional[str] = None,
+    name: Optional[str] = None,
+    output_name: Optional[str] = None,
+    local: bool = False,
+    api: str = "containers",
+    eval_timeout: float = 20.0,
+    log_level: str = "INFO",
+    enable_reuse: bool = True,
+    submit: bool = True,
+    wait: bool = True,
+    priority: int = 1,
+    cluster_id: Optional[str] = None,
+    storage_classes: str = "default",
+    tmpdir_prefix: Optional[str] = None,
+    debug: bool = False,
+):
+    """
+    Run a CWL workflow on Arvados or locally.
+    
+    Args:
+        workflow: Path to the CWL workflow file (.cwl).
+        job_order: Path to the input parameters file (YAML or JSON).
+        project_uuid: Arvados project UUID where the workflow should run.
+        name: Name for the pipeline instance or container request.
+        output_name: Name for the output collection.
+        local: Run the workflow locally instead of on the Arvados cluster.
+        api: Arvados API to use (containers or jobs). Default is containers.
+        eval_timeout: Time to wait for CWL expression evaluation (seconds).
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR).
+        enable_reuse: Enable job/container reuse.
+        submit: Submit the workflow to Arvados (True) or run it in the foreground (False).
+        wait: Wait for the workflow to complete before exiting.
+        priority: Workflow priority (1-1000).
+        cluster_id: Specific Arvados cluster ID to submit to.
+        storage_classes: Comma-separated list of storage classes for outputs.
+        tmpdir_prefix: Path prefix for temporary directories.
+        debug: Enable debug logging and keep temporary files.
+    """
+    
+    # Input validation
+    workflow_path = Path(workflow)
+    if not workflow_path.exists():
+        return {"error": f"Workflow file not found: {workflow}"}
+    
+    cmd = ["arvados-cwl-runner"]
+    
+    # Boolean flags
+    if local:
+        cmd.append("--local")
+    if not enable_reuse:
+        cmd.append("--disable-reuse")
+    if not submit:
+        cmd.append("--no-submit")
+    if not wait:
+        cmd.append("--no-wait")
+    if debug:
+        cmd.append("--debug")
+        
+    # String/Value parameters
+    cmd.extend(["--api", api])
+    cmd.extend(["--eval-timeout", str(eval_timeout)])
+    cmd.extend(["--log-level", log_level])
+    cmd.extend(["--priority", str(priority)])
+    cmd.extend(["--collection-storage-classes", storage_classes])
+    
+    if project_uuid:
+        cmd.extend(["--project-uuid", project_uuid])
+    if name:
+        cmd.extend(["--name", name])
+    if output_name:
+        cmd.extend(["--output-name", output_name])
+    if cluster_id:
+        cmd.extend(["--cluster-id", cluster_id])
+    if tmpdir_prefix:
+        cmd.extend(["--tmpdir-prefix", tmpdir_prefix])
+        
+    # Positional arguments
+    cmd.append(str(workflow_path))
+    
+    if job_order:
+        job_order_path = Path(job_order)
+        if not job_order_path.exists():
+            return {"error": f"Job order file not found: {job_order}"}
+        cmd.append(str(job_order_path))
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+
+@mcp.tool()
+def arvados_cwl_validate(
+    workflow: str,
+):
+    """
+    Validate a CWL workflow file for syntax and Arvados compatibility.
+    
+    Args:
+        workflow: Path to the CWL workflow file.
+    """
+    workflow_path = Path(workflow)
+    if not workflow_path.exists():
+        return {"error": f"Workflow file not found: {workflow}"}
+        
+    cmd = ["arvados-cwl-runner", "--validate", str(workflow_path)]
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "valid"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Validation failed",
+            "status": "invalid"
+        }
+
+@mcp.tool()
+def arvados_cwl_create_workflow(
+    workflow: str,
+    project_uuid: Optional[str] = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+):
+    """
+    Register a CWL workflow in Arvados as a reusable Workflow object.
+    
+    Args:
+        workflow: Path to the CWL workflow file.
+        project_uuid: Arvados project UUID where the workflow should be stored.
+        name: Name for the workflow object in Arvados.
+        description: Description for the workflow.
+    """
+    workflow_path = Path(workflow)
+    if not workflow_path.exists():
+        return {"error": f"Workflow file not found: {workflow}"}
+        
+    cmd = ["arvados-cwl-runner", "--create-workflow"]
+    
+    if project_uuid:
+        cmd.extend(["--project-uuid", project_uuid])
+    if name:
+        cmd.extend(["--name", name])
+    if description:
+        cmd.extend(["--description", description])
+        
+    cmd.append(str(workflow_path))
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+
+@mcp.tool()
+def arvados_cwl_update_workflow(
+    workflow_uuid: str,
+    workflow: str,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+):
+    """
+    Update an existing Arvados Workflow object with a new CWL definition.
+    
+    Args:
+        workflow_uuid: The UUID of the Arvados Workflow object to update.
+        workflow: Path to the new CWL workflow file.
+        name: New name for the workflow object.
+        description: New description for the workflow.
+    """
+    workflow_path = Path(workflow)
+    if not workflow_path.exists():
+        return {"error": f"Workflow file not found: {workflow}"}
+        
+    cmd = ["arvados-cwl-runner", "--update-workflow", workflow_uuid]
+    
+    if name:
+        cmd.extend(["--name", name])
+    if description:
+        cmd.extend(["--description", description])
+        
+    cmd.append(str(workflow_path))
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+
+@mcp.tool()
+def arvados_cwl_create_template(
+    workflow: str,
+):
+    """
+    Create an Arvados Pipeline Template from a CWL workflow (legacy API).
+    
+    Args:
+        workflow: Path to the CWL workflow file.
+    """
+    workflow_path = Path(workflow)
+    if not workflow_path.exists():
+        return {"error": f"Workflow file not found: {workflow}"}
+        
+    cmd = ["arvados-cwl-runner", "--create-template", str(workflow_path)]
+    
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "status": "success"
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "status": "failed"
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_arvados-cwl-runner/app/arvados-cwl-runner_shim_server.py

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

Biomni/mcp_generated/mcp_arvados-cwl-runner/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_arvados-cwl-runner/docker-compose.yml

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

Biomni/mcp_generated/mcp_arvados-cwl-runner/environment.yaml

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

Biomni/mcp_generated/mcp_arvados-cwl-runner/requirements.txt

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

Biomni/mcp_generated/mcp_auspice/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 auspice via conda (e.g., from bioconda)
+RUN conda install -c bioconda auspice -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/auspice_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/auspice_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/auspice_server.py"]
+        

Biomni/mcp_generated/mcp_auspice/app/auspice_server.py

@@ -0,0 +1,406 @@
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+def tool():
+    def decorator(f):
+        return f
+    return decorator
+
+mcp = type("mcp", (), {"tool": tool})()
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_auspice'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def view(
+    dataset_dir: Optional[List[Path]] = None,
+    host: str = "localhost",
+    port: int = 4000,
+    verbose: bool = False,
+    allow_remote_access: bool = False,
+    handlers: Optional[Path] = None,
+    config: Optional[Path] = None,
+    extend: Optional[Path] = None,
+) -> Dict[str, str]:
+    """
+    Starts the Auspice server to view and explore phylogenomic data.
+    Note: This command starts a long-running server process and may not be suitable
+    for automated workflows that expect a command to terminate.
+
+    Args:
+        dataset_dir: Directory of datasets to serve. Can be specified multiple times.
+        host: Host IP address to listen on.
+        port: Port to listen on.
+        verbose: Print more information to the console.
+        allow_remote_access: Allow remote connections to the server.
+        handlers: Path to a Javascript file with custom API handlers.
+        config: Path to a custom config JSON file.
+        extend: Path to a directory containing custom client code.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    cmd = ["auspice", "view"]
+
+    if dataset_dir:
+        for d in dataset_dir:
+            if not d.is_dir():
+                raise ValueError(f"Dataset directory not found: {d}")
+            cmd.extend(["--datasetDir", str(d)])
+
+    cmd.extend(["--host", host])
+    cmd.extend(["--port", str(port)])
+
+    if verbose:
+        cmd.append("--verbose")
+    if allow_remote_access:
+        cmd.append("--allow-remote-access")
+
+    if handlers:
+        if not handlers.is_file():
+            raise FileNotFoundError(f"Handlers file not found: {handlers}")
+        cmd.extend(["--handlers", str(handlers)])
+
+    if config:
+        if not config.is_file():
+            raise FileNotFoundError(f"Config file not found: {config}")
+        cmd.extend(["--config", str(config)])
+
+    if extend:
+        if not extend.is_dir():
+            raise ValueError(f"Extend directory not found: {extend}")
+        cmd.extend(["--extend", str(extend)])
+
+    try:
+        # This will block until the server is manually stopped.
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, check=True
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'auspice' command not found. Please ensure it is installed and in your PATH.",
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+        }
+
+
+@mcp.tool()
+def build(
+    verbose: bool = False,
+    extend: Optional[Path] = None,
+    deploy_path: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Creates a production bundle of the Auspice client-side app.
+    The output is typically created in a './dist' directory.
+
+    Args:
+        verbose: Print more information to the console.
+        extend: Path to a directory containing custom client code.
+        deploy_path: Path to deploy the app to (e.g., for GitHub pages).
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output files.
+    """
+    cmd = ["auspice", "build"]
+
+    if verbose:
+        cmd.append("--verbose")
+
+    if extend:
+        if not extend.is_dir():
+            raise ValueError(f"Extend directory not found: {extend}")
+        cmd.extend(["--extend", str(extend)])
+
+    if deploy_path:
+        cmd.extend(["--deploy-path", deploy_path])
+
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, check=True
+        )
+        output_dir = Path("./dist")
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {
+                "build_directory": str(output_dir) if output_dir.exists() else "Not created"
+            }
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'auspice' command not found. Please ensure it is installed and in your PATH.",
+            "output_files": {}
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": {}
+        }
+
+
+@mcp.tool()
+def export_v1(
+    dataset_dir: Path,
+    output_dir: Path,
+    verbose: bool = False,
+) -> Dict[str, Any]:
+    """
+    Exports auspice v1 JSONs to create a static site.
+    This is a deprecated command and will be removed in a future version.
+
+    Args:
+        dataset_dir: Directory of datasets to export.
+        output_dir: Directory to export the auspice client and datasets to.
+        verbose: Print more information to the console.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output directory.
+    """
+    cmd = ["auspice", "export", "v1"]
+
+    if not dataset_dir.is_dir():
+        raise ValueError(f"Dataset directory not found: {dataset_dir}")
+    cmd.extend(["--dataset-dir", str(dataset_dir)])
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    cmd.extend(["--output-dir", str(output_dir)])
+
+    if verbose:
+        cmd.append("--verbose")
+
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, check=True
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {
+                "export_directory": str(output_dir)
+            }
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'auspice' command not found. Please ensure it is installed and in your PATH.",
+            "output_files": {}
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": {}
+        }
+
+
+@mcp.tool()
+def export_v2(
+    dataset_dir: Path,
+    output_dir: Path,
+    verbose: bool = False,
+    config: Optional[Path] = None,
+    extend: Optional[Path] = None,
+    deploy_path: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Exports auspice v2 JSONs to create a static site.
+
+    Args:
+        dataset_dir: Directory of datasets to export.
+        output_dir: Directory to export the auspice client and datasets to.
+        verbose: Print more information to the console.
+        config: Path to a custom config JSON file.
+        extend: Path to a directory containing custom client code.
+        deploy_path: Path to deploy the app to (e.g., for GitHub pages).
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and output directory.
+    """
+    cmd = ["auspice", "export", "v2"]
+
+    if not dataset_dir.is_dir():
+        raise ValueError(f"Dataset directory not found: {dataset_dir}")
+    cmd.extend(["--dataset-dir", str(dataset_dir)])
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    cmd.extend(["--output-dir", str(output_dir)])
+
+    if verbose:
+        cmd.append("--verbose")
+
+    if config:
+        if not config.is_file():
+            raise FileNotFoundError(f"Config file not found: {config}")
+        cmd.extend(["--config", str(config)])
+
+    if extend:
+        if not extend.is_dir():
+            raise ValueError(f"Extend directory not found: {extend}")
+        cmd.extend(["--extend", str(extend)])
+
+    if deploy_path:
+        cmd.extend(["--deploy-path", deploy_path])
+
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, check=True
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": {
+                "export_directory": str(output_dir)
+            }
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'auspice' command not found. Please ensure it is installed and in your PATH.",
+            "output_files": {}
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": {}
+        }
+
+
+@mcp.tool()
+def develop(
+    verbose: bool = False,
+    extend: Optional[Path] = None,
+    config: Optional[Path] = None,
+    dataset_dir: Optional[List[Path]] = None,
+    port: int = 4000,
+    host: str = "localhost",
+) -> Dict[str, str]:
+    """
+    Starts the Auspice development server with hot-reloading.
+    Note: This command starts a long-running server process and may not be suitable
+    for automated workflows that expect a command to terminate.
+
+    Args:
+        verbose: Print more information to the console.
+        extend: Path to a directory containing custom client code.
+        config: Path to a custom config JSON file.
+        dataset_dir: Directory of datasets to serve. Can be specified multiple times.
+        port: Port to listen on.
+        host: Host IP address to listen on.
+
+    Returns:
+        A dictionary containing the command executed, stdout, and stderr.
+    """
+    cmd = ["auspice", "develop"]
+
+    if verbose:
+        cmd.append("--verbose")
+
+    if extend:
+        if not extend.is_dir():
+            raise ValueError(f"Extend directory not found: {extend}")
+        cmd.extend(["--extend", str(extend)])
+
+    if config:
+        if not config.is_file():
+            raise FileNotFoundError(f"Config file not found: {config}")
+        cmd.extend(["--config", str(config)])
+
+    if dataset_dir:
+        for d in dataset_dir:
+            if not d.is_dir():
+                raise ValueError(f"Dataset directory not found: {d}")
+            cmd.extend(["--datasetDir", str(d)])
+
+    cmd.extend(["--port", str(port)])
+    cmd.extend(["--host", host])
+
+    try:
+        # This will block until the server is manually stopped.
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, check=True
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'auspice' command not found. Please ensure it is installed and in your PATH.",
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+        }
+
+
+@mcp.tool()
+def version() -> Dict[str, str]:
+    """
+    Prints the version number of auspice and exits.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and parsed version.
+    """
+    cmd = ["auspice", "version"]
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, check=True
+        )
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "version": result.stdout.strip(),
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "Error: 'auspice' command not found. Please ensure it is installed and in your PATH.",
+            "version": "",
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "version": "",
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_auspice/app/auspice_shim_server.py

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

Biomni/mcp_generated/mcp_auspice/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_auspice/docker-compose.yml

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

Biomni/mcp_generated/mcp_auspice/environment.yaml

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

Biomni/mcp_generated/mcp_auspice/requirements.txt

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

Biomni/mcp_generated/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"]
+        

Biomni/mcp_generated/mcp_barrnap/app/barrnap_server.py

@@ -0,0 +1,246 @@
+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
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_barrnap'
+mcp = FastMCP(SERVER_NAME)
+
+@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,
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_barrnap/app/barrnap_shim_server.py

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

Biomni/mcp_generated/mcp_barrnap/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/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
+    

Biomni/mcp_generated/mcp_barrnap/environment.yaml

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

Biomni/mcp_generated/mcp_barrnap/requirements.txt

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

Biomni/mcp_generated/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"]
+        

Biomni/mcp_generated/mcp_bedtools/app/bedtools_server.py

@@ -0,0 +1,708 @@
+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})
+
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bedtools'
+mcp = FastMCP(SERVER_NAME)
+
+@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,
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bedtools/app/bedtools_shim_server.py

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

Biomni/mcp_generated/mcp_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
+    

Biomni/mcp_generated/mcp_bedtools/environment.yaml

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

Biomni/mcp_generated/mcp_bedtools/requirements.txt

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

Biomni/mcp_generated/mcp_bin2cell/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 bin2cell via conda (e.g., from bioconda)
+RUN conda install -c bioconda bin2cell -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/bin2cell_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/bin2cell_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/bin2cell_server.py"]
+        

Biomni/mcp_generated/mcp_bin2cell/app/bin2cell_server.py

@@ -0,0 +1,286 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bin2cell'
+mcp = FastMCP(SERVER_NAME)
+
+@mcp.tool()
+def bin2cell_prepare_bins(
+    input_dir: str,
+    output_h5ad: str,
+    bin_size: int = 2,
+    destripe: bool = True,
+):
+    """
+    Reads Visium HD data from a SpaceRanger output directory and optionally performs destriping 
+    to correct for technical effects in 2um bin data.
+
+    Args:
+        input_dir: Path to the SpaceRanger output directory (containing 'outs' folder).
+        output_h5ad: Path where the processed bin-level AnnData object will be saved.
+        bin_size: Resolution of bins to load (default is 2um).
+        destripe: Whether to apply the destriping correction for variable bin dimensions.
+    """
+    # Input validation
+    input_path = Path(input_dir)
+    if not input_path.exists():
+        return {"error": f"Input directory {input_dir} does not exist."}
+    
+    output_path = Path(output_h5ad)
+    if not output_path.parent.exists():
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if bin_size <= 0:
+        return {"error": "bin_size must be a positive integer."}
+
+    # Construct Python command
+    # We use a python script string to execute the library functions
+    destripe_cmd = "b2c.pp.destripe(adata)" if destripe else "pass"
+    python_script = f"""
+import bin2cell as b2c
+import scanpy as sc
+import os
+
+try:
+    # Load Visium HD data
+    adata = b2c.pp.read_visium_hd_folder('{input_dir}', bin_size={bin_size})
+    
+    # Perform destriping if requested
+    if {destripe}:
+        b2c.pp.destripe(adata)
+    
+    # Save the result
+    adata.write('{output_h5ad}')
+    print("Successfully prepared bin data.")
+except Exception as e:
+    print(f"Error: {{str(e)}}")
+    exit(1)
+"""
+
+    try:
+        result = subprocess.run(
+            ["python", "-c", python_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"bin2cell.pp.read_visium_hd_folder and destripe={destripe}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_h5ad]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Failed to prepare bin data",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+@mcp.tool()
+def bin2cell_run_stardist(
+    image_path: str,
+    output_mask_path: str,
+    model_name: str = "2D_versatile_he",
+    prob_thresh: float = 0.5,
+    nms_thresh: float = 0.3,
+):
+    """
+    Performs cell segmentation on a morphology image using StarDist.
+
+    Args:
+        image_path: Path to the high-resolution morphology image (e.g., tissue_hires_image.png).
+        output_mask_path: Path where the resulting segmentation mask (.tif) will be saved.
+        model_name: StarDist model to use (default: '2D_versatile_he').
+        prob_thresh: Probability threshold for StarDist detection.
+        nms_thresh: Non-maximum suppression threshold for StarDist.
+    """
+    # Input validation
+    img_path = Path(image_path)
+    if not img_path.exists():
+        return {"error": f"Image file {image_path} does not exist."}
+    
+    out_mask = Path(output_mask_path)
+    if not out_mask.parent.exists():
+        out_mask.parent.mkdir(parents=True, exist_ok=True)
+
+    python_script = f"""
+import bin2cell as b2c
+import cv2
+import numpy as np
+
+try:
+    # Run StarDist segmentation via bin2cell wrapper
+    # Note: bin2cell.tl.stardist handles the model loading and prediction
+    b2c.tl.stardist(
+        '{image_path}', 
+        '{output_mask_path}', 
+        model='{model_name}', 
+        prob_thresh={prob_thresh}, 
+        nms_thresh={nms_thresh}
+    )
+    print("Successfully generated segmentation mask.")
+except Exception as e:
+    print(f"Error: {{str(e)}}")
+    exit(1)
+"""
+
+    try:
+        result = subprocess.run(
+            ["python", "-c", python_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"bin2cell.tl.stardist on {image_path}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_mask_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "StarDist segmentation failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+@mcp.tool()
+def bin2cell_extract_cells(
+    bin_h5ad_path: str,
+    mask_path: str,
+    output_cell_h5ad_path: str,
+    qc_metrics: bool = True,
+):
+    """
+    Groups subcellular bins into cells based on a segmentation mask and generates a cell-level AnnData object.
+
+    Args:
+        bin_h5ad_path: Path to the bin-level AnnData object (output from bin2cell_prepare_bins).
+        mask_path: Path to the segmentation mask file (output from bin2cell_run_stardist).
+        output_cell_h5ad_path: Path where the final cell-level AnnData object will be saved.
+        qc_metrics: Whether to calculate standard scanpy QC metrics for the new cell object.
+    """
+    # Input validation
+    bin_path = Path(bin_h5ad_path)
+    if not bin_path.exists():
+        return {"error": f"Bin h5ad file {bin_h5ad_path} does not exist."}
+    
+    m_path = Path(mask_path)
+    if not m_path.exists():
+        return {"error": f"Mask file {mask_path} does not exist."}
+
+    out_cell_path = Path(output_cell_h5ad_path)
+    if not out_cell_path.parent.exists():
+        out_cell_path.parent.mkdir(parents=True, exist_ok=True)
+
+    python_script = f"""
+import bin2cell as b2c
+import scanpy as sc
+
+try:
+    # Load the bin-level data
+    adata_bins = sc.read_h5ad('{bin_h5ad_path}')
+    
+    # Extract cells based on the mask
+    adata_cells = b2c.tl.extract_cells(adata_bins, '{mask_path}')
+    
+    # Calculate QC metrics if requested
+    if {qc_metrics}:
+        sc.pp.calculate_qc_metrics(adata_cells, inplace=True)
+    
+    # Save the cell-level object
+    adata_cells.write('{output_cell_h5ad_path}')
+    print("Successfully extracted cells from bins.")
+except Exception as e:
+    print(f"Error: {{str(e)}}")
+    exit(1)
+"""
+
+    try:
+        result = subprocess.run(
+            ["python", "-c", python_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"bin2cell.tl.extract_cells using mask {mask_path}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_cell_h5ad_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Cell extraction failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+@mcp.tool()
+def bin2cell_visualize_segmentation(
+    bin_h5ad_path: str,
+    output_image_path: str,
+    basis: str = "spatial",
+):
+    """
+    Generates a visualization of the bin-to-cell assignments.
+
+    Args:
+        bin_h5ad_path: Path to the bin-level AnnData object containing cell assignments.
+        output_image_path: Path to save the visualization plot (e.g., .png or .pdf).
+        basis: The coordinate system to use for plotting (default: 'spatial').
+    """
+    bin_path = Path(bin_h5ad_path)
+    if not bin_path.exists():
+        return {"error": f"Bin h5ad file {bin_h5ad_path} does not exist."}
+
+    python_script = f"""
+import scanpy as sc
+import matplotlib.pyplot as plt
+import bin2cell as b2c
+
+try:
+    adata = sc.read_h5ad('{bin_h5ad_path}')
+    if 'cell_id' not in adata.obs.columns:
+        print("Error: cell_id not found in adata.obs. Run extract_cells first.")
+        exit(1)
+        
+    # Plotting logic
+    sc.pl.embedding(adata, basis='{basis}', color='cell_id', show=False)
+    plt.savefig('{output_image_path}')
+    print("Successfully saved visualization.")
+except Exception as e:
+    print(f"Error: {{str(e)}}")
+    exit(1)
+"""
+
+    try:
+        result = subprocess.run(
+            ["python", "-c", python_script],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        return {
+            "command_executed": f"Visualization of cell_id on {basis}",
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [output_image_path]
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "error": "Visualization failed",
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "command_executed": e.cmd
+        }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bin2cell/app/bin2cell_shim_server.py

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

Biomni/mcp_generated/mcp_bin2cell/app/requirements.txt

@@ -0,0 +1 @@
+

Biomni/mcp_generated/mcp_bin2cell/docker-compose.yml

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

Biomni/mcp_generated/mcp_bin2cell/environment.yaml

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

Biomni/mcp_generated/mcp_bin2cell/requirements.txt

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

Biomni/mcp_generated/mcp_bioconductor-alabaster/Dockerfile

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

Biomni/mcp_generated/mcp_bioconductor-alabaster/app/bioconductor-alabaster_server.py

@@ -0,0 +1,66 @@
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional, List
+import tempfile
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+# Mock mcp.tool decorator for standalone execution
+class mcp:
+    def tool(func):
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        return wrapper
+
+@mcp.tool
+def alabaster_check():
+    """
+    Verifies the installation of the bioconductor-alabaster umbrella package.
+
+    This tool does not perform any data analysis. Instead, it attempts to load
+    the 'alabaster' library within an R session to confirm that the Alabaster
+    framework and all its components are correctly installed and accessible.
+    A successful execution indicates the environment is ready for tools that
+    depend on the Alabaster suite.
+    """
+    command = ["Rscript", "-e", "library(alabaster)"]
+    command_str = " ".join(command)
+    logging.info(f"Executing command: {command_str}")
+
+    try:
+        process = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        stdout = process.stdout
+        stderr = process.stderr
+        logging.info("bioconductor-alabaster package loaded successfully.")
+
+    except FileNotFoundError:
+        logging.error("Rscript not found. Please ensure R is installed and in your PATH.")
+        # Re-raise with a more informative message for the MCP context
+        raise RuntimeError("Rscript executable not found. R installation is required.") from None
+
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Error loading bioconductor-alabaster package.")
+        logging.error(f"Stderr: {e.stderr}")
+        logging.error(f"Stdout: {e.stdout}")
+        return {
+            "command_executed": command_str,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "Failed to load the 'alabaster' R library. It may not be installed correctly.",
+            "return_code": e.returncode,
+        }
+
+    return {
+        "command_executed": command_str,
+        "stdout": stdout,
+        "stderr": stderr,
+        "status": "success"
+    }

Biomni/mcp_generated/mcp_bioconductor-alabaster/app/bioconductor-alabaster_shim_server.py

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

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

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

Biomni/mcp_generated/mcp_bioconductor-alabaster/environment.yaml

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

Biomni/mcp_generated/mcp_bioconductor-alabaster/requirements.txt

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

Biomni/mcp_generated/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"]
+        

Biomni/mcp_generated/mcp_bioconductor-apeglm/app/bioconductor-apeglm_server.py

@@ -0,0 +1,133 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+from mcp.server.fastmcp import FastMCP
+
+SERVER_NAME = 'local_bioconductor_apeglm'
+mcp = FastMCP(SERVER_NAME)
+
+@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,
+    }
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

Biomni/mcp_generated/mcp_bioconductor-apeglm/app/bioconductor-apeglm_shim_server.py

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

Biomni/mcp_generated/mcp_bioconductor-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
+