Add files using upload-large-folder tool

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_arvados-cwl-runner/app/arvados-cwl-runner_server.py

@@ -0,0 +1,270 @@
+import subprocess
+import os
+from pathlib import Path
+from typing import Optional, List, Union
+
+@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"
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_arvados-cwl-runner/app/arvados-cwl-runner_shim_server.py

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_arvados-cwl-runner/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_arvados-cwl-runner/requirements.txt

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_auspice/app/auspice_server.py

@@ -0,0 +1,398 @@
+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})()
+
+
+@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": "",
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_auspice/app/auspice_shim_server.py

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

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

@@ -0,0 +1 @@
+

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_barrnap/Dockerfile

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

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

@@ -0,0 +1,336 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List
+
+# Helper function to execute barrnap commands and handle output.
+# This function is internal and not exposed as an MCP tool.
+def _run_barrnap_command(
+    command_args: List[str],
+    output_gff_path: Optional[Path] = None,
+    debug: bool = False,
+    quiet: bool = False,
+) -> dict:
+    """
+    Internal helper to execute barrnap commands.
+    Captures stdout, stderr, and handles CalledProcessError.
+    If output_gff_path is provided, stdout is written to that file.
+    """
+    cmd = ["barrnap"] + command_args
+
+    if debug:
+        cmd.append("--debug")
+    if quiet:
+        cmd.append("--quiet")
+
+    stdout_capture = ""
+    stderr_capture = ""
+    output_files_generated = []
+
+    try:
+        # barrnap writes GFF to stdout by default.
+        # If output_gff_path is provided, we capture stdout and write it to the file.
+        process = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        stdout_capture = process.stdout
+        stderr_capture = process.stderr
+
+        if output_gff_path:
+            output_gff_path.write_text(stdout_capture)
+            output_files_generated.append(str(output_gff_path))
+            stdout_capture = f"GFF output written to {output_gff_path}"
+
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(e.cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": str(e),
+            "returncode": e.returncode,
+            "output_files": [],
+        }
+    except FileNotFoundError:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": "",
+            "stderr": "barrnap command not found. Please ensure barrnap is installed and in your PATH.",
+            "error": "barrnap not found",
+            "returncode": 127,
+            "output_files": [],
+        }
+
+    return {
+        "command_executed": " ".join(cmd),
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "output_files": output_files_generated,
+    }
+
+@mcp.tool()
+def barrnap_annotate(
+    fasta_file: Path,
+    output_gff_file: Path,
+    kingdom: Optional[str] = "bac",
+    enable_all_rna: bool = False,
+    disable_rrna: bool = False,
+    enable_trna: bool = False,
+    enable_ncrna: bool = False,
+    enable_mrna: bool = False,
+    threads: int = 1,
+    fast: bool = False,
+    evalue: Optional[float] = None,
+    incseq: bool = False,
+    incseqreg: bool = False,
+    outseq_file: Optional[Path] = None,
+    add_ids: bool = False,
+    db_directory: Optional[Path] = None,
+    debug: bool = False,
+    quiet: bool = False,
+) -> dict:
+    """
+    Annotates RNA features (rRNA, tRNA, tmRNA, ncRNA, mRNA) in microbial genomes
+    (bacteria, archaea, fungi) from an input FASTA file.
+    Outputs results in GFF3 format to the specified output file.
+
+    Args:
+        fasta_file: Path to the input FASTA file containing genomic sequences.
+        output_gff_file: Path to the output GFF3 file where annotations will be written.
+        kingdom: The database to use for annotation. Choices: "bac" (Bacteria),
+                 "arc" (Archaea), "fun" (Fungi). Defaults to "bac".
+        enable_all_rna: If True, enables scanning for all RNA types (rRNA, tRNA, tmRNA, ncRNA, mRNA).
+                        This is equivalent to `--all`.
+        disable_rrna: If True, disables rRNA scanning. This is equivalent to `--no-rrna`.
+        enable_trna: If True, enables tRNA scanning. This is equivalent to `--trna`.
+        enable_ncrna: If True, enables ncRNA scanning. This is equivalent to `--ncrna`.
+        enable_mrna: If True, enables mRNA scanning (including CDS, RBS, sig_pep, terminator).
+                     This is equivalent to `--mrna`.
+        threads: Number of CPUs to use for the search. Must be at least 1. Defaults to 1.
+        fast: If True, uses simpler HMMs instead of CMs, which is faster but less accurate.
+              This is equivalent to `--fast`.
+        evalue: E-value cutoff for hits to keep. Must be greater than 0 if provided.
+                This is equivalent to `--evalue`.
+        incseq: If True, includes the full input sequences in the output GFF.
+                This is equivalent to `--incseq`.
+        incseqreg: If True, includes `##sequence-region` headers in the GFF.
+                   This is equivalent to `--incseqreg`.
+        outseq_file: Path to a FASTA file where hit sequences will be written.
+                     This is equivalent to `--outseq`.
+        add_ids: If True, adds unique ID= tags to each GFF3 feature.
+                 This is equivalent to `--addids`.
+        db_directory: Path to a different database folder to use.
+                      This is equivalent to `--dbdir`.
+        debug: If True, writes all temporary files to '.' and prints debug information.
+               This is equivalent to `--debug`.
+        quiet: If True, suppresses all messages to stderr. This is equivalent to `--quiet`.
+
+    Returns:
+        A dictionary containing:
+        - "command_executed": The full command string executed.
+        - "stdout": Standard output from the tool.
+        - "stderr": Standard error from the tool.
+        - "output_files": A list of paths to generated output files (GFF3 and optional FASTA).
+    """
+    # Input validation
+    if not fasta_file.is_file():
+        raise ValueError(f"Input FASTA file not found: {fasta_file}")
+    if not output_gff_file.parent.is_dir():
+        raise ValueError(f"Output GFF directory does not exist: {output_gff_file.parent}")
+
+    valid_kingdoms = {"bac", "arc", "fun"}
+    if kingdom is not None and kingdom not in valid_kingdoms:
+        raise ValueError(f"Invalid kingdom: '{kingdom}'. Must be one of {', '.join(valid_kingdoms)}.")
+
+    if threads < 1:
+        raise ValueError(f"Number of threads must be at least 1, got {threads}.")
+
+    if evalue is not None and evalue <= 0:
+        raise ValueError(f"E-value cutoff must be greater than 0, got {evalue}.")
+
+    if outseq_file and not outseq_file.parent.is_dir():
+        raise ValueError(f"Output FASTA directory for hit sequences does not exist: {outseq_file.parent}")
+
+    if db_directory and not db_directory.is_dir():
+        raise ValueError(f"Database directory not found: {db_directory}")
+
+    command_args = [str(fasta_file)]
+
+    # Database management
+    if db_directory:
+        command_args.extend(["--dbdir", str(db_directory)])
+
+    # Search options
+    if kingdom:
+        command_args.extend(["--kingdom", kingdom])
+    if enable_all_rna:
+        command_args.append("--all")
+    if disable_rrna:
+        command_args.append("--no-rrna")
+    if enable_trna:
+        command_args.append("--trna")
+    if enable_ncrna:
+        command_args.append("--ncrna")
+    if enable_mrna:
+        command_args.append("--mrna")
+
+    # Speed options
+    if threads > 1: # barrnap default is 1 thread, so only add if > 1
+        command_args.extend(["--threads", str(threads)])
+    if fast:
+        command_args.append("--fast")
+
+    # Filtering options
+    if evalue is not None:
+        command_args.extend(["--evalue", str(evalue)])
+
+    # Output options
+    if incseq:
+        command_args.append("--incseq")
+    if incseqreg:
+        command_args.append("--incseqreg")
+    if outseq_file:
+        command_args.extend(["--outseq", str(outseq_file)])
+    if add_ids:
+        command_args.append("--addids")
+
+    result = _run_barrnap_command(
+        command_args=command_args,
+        output_gff_path=output_gff_file,
+        debug=debug,
+        quiet=quiet,
+    )
+
+    # Add outseq_file to output_files if it was generated by barrnap
+    if outseq_file and outseq_file.exists() and str(outseq_file) not in result["output_files"]:
+        result["output_files"].append(str(outseq_file))
+
+    return result
+
+@mcp.tool()
+def barrnap_list_databases(
+    db_directory: Optional[Path] = None,
+    debug: bool = False,
+    quiet: bool = False,
+) -> dict:
+    """
+    Lists the installed barrnap databases and their contents.
+
+    Args:
+        db_directory: Path to a different database folder to use.
+                      This is equivalent to `--dbdir`.
+        debug: If True, writes all temporary files to '.' and prints debug information.
+               This is equivalent to `--debug`.
+        quiet: If True, suppresses all messages to stderr. This is equivalent to `--quiet`.
+
+    Returns:
+        A dictionary containing:
+        - "command_executed": The full command string executed.
+        - "stdout": Standard output from the tool, listing databases.
+        - "stderr": Standard error from the tool.
+        - "output_files": An empty list, as no files are generated.
+    """
+    command_args = ["--listdb"]
+
+    if db_directory:
+        if not db_directory.is_dir():
+            raise ValueError(f"Database directory not found: {db_directory}")
+        command_args.extend(["--dbdir", str(db_directory)])
+
+    return _run_barrnap_command(
+        command_args=command_args,
+        debug=debug,
+        quiet=quiet,
+    )
+
+@mcp.tool()
+def barrnap_update_databases(
+    db_directory: Optional[Path] = None,
+    debug: bool = False,
+    quiet: bool = False,
+) -> dict:
+    """
+    Updates barrnap databases from the internet.
+
+    Args:
+        db_directory: Path to a different database folder to use.
+                      This is equivalent to `--dbdir`.
+        debug: If True, writes all temporary files to '.' and prints debug information.
+               This is equivalent to `--debug`.
+        quiet: If True, suppresses all messages to stderr. This is equivalent to `--quiet`.
+
+    Returns:
+        A dictionary containing:
+        - "command_executed": The full command string executed.
+        - "stdout": Standard output from the tool, typically update messages.
+        - "stderr": Standard error from the tool.
+        - "output_files": An empty list, as no files are generated.
+    """
+    command_args = ["--updatedb"]
+
+    if db_directory:
+        if not db_directory.is_dir():
+            raise ValueError(f"Database directory not found: {db_directory}")
+        command_args.extend(["--dbdir", str(db_directory)])
+
+    return _run_barrnap_command(
+        command_args=command_args,
+        debug=debug,
+        quiet=quiet,
+    )
+
+@mcp.tool()
+def barrnap_get_version(
+    debug: bool = False,
+    quiet: bool = False,
+) -> dict:
+    """
+    Prints the barrnap version in the format 'barrnap X.Y'.
+
+    Args:
+        debug: If True, writes all temporary files to '.' and prints debug information.
+               This is equivalent to `--debug`.
+        quiet: If True, suppresses all messages to stderr. This is equivalent to `--quiet`.
+
+    Returns:
+        A dictionary containing:
+        - "command_executed": The full command string executed.
+        - "stdout": Standard output from the tool, containing the version string.
+        - "stderr": Standard error from the tool.
+        - "output_files": An empty list, as no files are generated.
+    """
+    command_args = ["--version"]
+    return _run_barrnap_command(
+        command_args=command_args,
+        debug=debug,
+        quiet=quiet,
+    )
+
+@mcp.tool()
+def barrnap_get_citation(
+    debug: bool = False,
+    quiet: bool = False,
+) -> dict:
+    """
+    Prints the barrnap citation information.
+
+    Args:
+        debug: If True, writes all temporary files to '.' and prints debug information.
+               This is equivalent to `--debug`.
+        quiet: If True, suppresses all messages to stderr. This is equivalent to `--quiet`.
+
+    Returns:
+        A dictionary containing:
+        - "command_executed": The full command string executed.
+        - "stdout": Standard output from the tool, containing the citation.
+        - "stderr": Standard error from the tool.
+        - "output_files": An empty list, as no files are generated.
+    """
+    command_args = ["--citation"]
+    return _run_barrnap_command(
+        command_args=command_args,
+        debug=debug,
+        quiet=quiet,
+    )

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_barrnap/app/barrnap_shim_server.py

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

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

@@ -0,0 +1 @@
+

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

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bin2cell/app/bin2cell_server.py

@@ -0,0 +1,278 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List
+
+@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
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bin2cell/app/bin2cell_shim_server.py

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

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

@@ -0,0 +1 @@
+

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

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

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

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-curatedatlasqueryr/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-curatedatlasqueryr via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-curatedatlasqueryr -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-curatedatlasqueryr_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-curatedatlasqueryr_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-curatedatlasqueryr_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-curatedatlasqueryr/app/bioconductor-curatedatlasqueryr_shim_server.py

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

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

@@ -0,0 +1 @@
+

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

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

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-experimentsubset/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-experimentsubset via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-experimentsubset -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-experimentsubset_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-experimentsubset_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-experimentsubset_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-experimentsubset/app/bioconductor-experimentsubset_server.py

@@ -0,0 +1,178 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, Dict, List
+
+# This is a placeholder for the MCP decorator.
+# In a real MCP environment, this would be provided by the MCP framework.
+def mcp_tool_placeholder(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+mcp = type('mcp', (), {'tool': mcp_tool_placeholder})
+
+
+@mcp.tool()
+def manage_experiment_subset(
+    input_rds: Path,
+    output_rds: Path,
+    subset_name: str = "mcp_subset",
+    row_subset: Optional[str] = None,
+    col_subset: Optional[str] = None,
+    row_subset_file: Optional[Path] = None,
+    col_subset_file: Optional[Path] = None,
+) -> Dict[str, any]:
+    """
+    Provides a command-line interface to the R/Bioconductor 'ExperimentSubset' package.
+    
+    This tool subsets a Bioconductor experiment object (e.g., SummarizedExperiment,
+    SingleCellExperiment) stored in an RDS file based on provided row (e.g., genes)
+    or column (e.g., cells) identifiers.
+
+    Args:
+        input_rds: Path to the input RDS file containing a Bioconductor experiment object.
+        output_rds: Path to save the output subsetted RDS file.
+        subset_name: A name to assign to the created subset.
+        row_subset: A comma-separated string of row names to include in the subset.
+        col_subset: A comma-separated string of column names to include in the subset.
+        row_subset_file: Path to a file containing row names to include (one per line).
+        col_subset_file: Path to a file containing column names to include (one per line).
+
+    Returns:
+        A dictionary containing the execution command, stdout, stderr, and a list of output files.
+    """
+    # --- Input Validation ---
+    if not input_rds.exists():
+        raise FileNotFoundError(f"Input file not found: {input_rds}")
+
+    if row_subset and row_subset_file:
+        raise ValueError("Cannot specify both 'row_subset' and 'row_subset_file'.")
+    
+    if col_subset and col_subset_file:
+        raise ValueError("Cannot specify both 'col_subset' and 'col_subset_file'.")
+
+    if not any([row_subset, col_subset, row_subset_file, col_subset_file]):
+        raise ValueError("At least one subsetting criterion must be provided "
+                         "('row_subset', 'col_subset', 'row_subset_file', or 'col_subset_file').")
+
+    if not output_rds.parent.exists():
+        output_rds.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- R Script Generation ---
+    r_script_content = f"""
+    # Load required libraries
+    if (!require("optparse", quietly = TRUE)) install.packages("optparse", repos = "http://cran.us.r-project.org")
+    if (!require("ExperimentSubset", quietly = TRUE)) {{
+        if (!require("BiocManager", quietly = TRUE)) install.packages("BiocManager", repos = "http://cran.us.r-project.org")
+        BiocManager::install("ExperimentSubset", update=FALSE)
+    }}
+    library(optparse)
+    library(ExperimentSubset)
+
+    # Define and parse command-line options
+    option_list <- list(
+      make_option(c("-i", "--input"), type="character", help="Input RDS file path"),
+      make_option(c("-o", "--output"), type="character", help="Output RDS file path"),
+      make_option(c("-n", "--name"), type="character", default="mcp_subset", help="Name for the subset"),
+      make_option(c("-r", "--rows"), type="character", default=NULL, help="Comma-separated row names"),
+      make_option(c("-c", "--cols"), type="character", default=NULL, help="Comma-separated column names"),
+      make_option(c("--row_file"), type="character", default=NULL, help="File with row names"),
+      make_option(c("--col_file"), type="character", default=NULL, help="File with column names")
+    )
+
+    opt_parser <- OptionParser(option_list=option_list)
+    opt <- parse_args(opt_parser)
+
+    if (is.null(opt$input) || is.null(opt$output)) {{
+      print_help(opt_parser)
+      stop("Input and output files must be supplied.", call.=FALSE)
+    }}
+
+    # Load the experiment object
+    cat("Loading input RDS file:", opt$input, "\\n")
+    exp_obj <- readRDS(opt$input)
+
+    # Create ExperimentSubset object
+    es <- ExperimentSubset(exp_obj)
+
+    # Determine row and column subsets
+    row_indices <- NULL
+    if (!is.null(opt$rows)) {{
+      row_indices <- trimws(strsplit(opt$rows, ",")[[1]])
+    }} else if (!is.null(opt$row_file)) {{
+      row_indices <- readLines(opt$row_file)
+    }}
+
+    col_indices <- NULL
+    if (!is.null(opt$cols)) {{
+      col_indices <- trimws(strsplit(opt$cols, ",")[[1]])
+    }} else if (!is.null(opt$col_file)) {{
+      col_indices <- readLines(opt$col_file)
+    }}
+
+    # Create the subset using the subsetData function
+    cat("Creating subset '", opt$name, "'...\\n", sep="")
+    es <- subsetData(es, subsetName = opt$name, rows = row_indices, cols = col_indices)
+
+    # Retrieve the actual subsetted object from the container
+    subset_obj <- getSubset(es, subsetName = opt$name)
+
+    # Save the subsetted object
+    cat("Saving subsetted object to:", opt$output, "\\n")
+    saveRDS(subset_obj, file = opt$output)
+
+    cat("Successfully created subset.\\n")
+    """
+
+    # --- Subprocess Execution ---
+    cmd: List[str] = []
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix=".R") as r_script_file:
+            r_script_file.write(r_script_content)
+            r_script_path = r_script_file.name
+
+        cmd = [
+            "Rscript", r_script_path,
+            "--input", str(input_rds),
+            "--output", str(output_rds),
+            "--name", subset_name
+        ]
+
+        if row_subset:
+            cmd.extend(["--rows", row_subset])
+        if col_subset:
+            cmd.extend(["--cols", col_subset])
+        if row_subset_file:
+            cmd.extend(["--row_file", str(row_subset_file)])
+        if col_subset_file:
+            cmd.extend(["--col_file", str(col_subset_file)])
+
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": [str(output_rds)]
+        }
+
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your system's PATH.")
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": " ".join(cmd),
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": "R script execution failed.",
+            "return_code": e.returncode
+        }
+    finally:
+        # Clean up the temporary R script
+        if 'r_script_path' in locals() and Path(r_script_path).exists():
+            Path(r_script_path).unlink()

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-experimentsubset/app/bioconductor-experimentsubset_shim_server.py

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

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

@@ -0,0 +1 @@
+

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ggsc/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-ggsc via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioconductor-ggsc -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-ggsc_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-ggsc_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-ggsc_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ggsc/app/bioconductor-ggsc_server.py

@@ -0,0 +1,360 @@
+import subprocess
+import logging
+from pathlib import Path
+from typing import Optional, List
+
+# This script assumes the presence of a companion R script (e.g., 'run_ggsc.R')
+# that acts as a command-line interface for the 'ggsc' R package.
+# The R environment must have 'ggsc', 'SingleCellExperiment', 'ggplot2',
+# and an argument parser like 'optparse' installed.
+R_SCRIPT_EXECUTABLE = "run_ggsc.R"
+
+# Per instructions, the @mcp.tool decorator is used.
+# A dummy decorator is defined here for syntax validity in a standalone context.
+# In a true MCP environment, this would be provided by the MCP framework.
+def tool(func):
+    """Dummy decorator to match the required syntax."""
+    return func
+
+class MCP:
+    """Dummy class to hold the tool decorator."""
+    tool = staticmethod(tool)
+
+mcp = MCP()
+
+
+@mcp.tool()
+def plot_reduced_dim(
+    input_rds: Path,
+    output_plot: Path,
+    dim_red: str,
+    color_by: str,
+    facet_by: Optional[str] = None,
+    plot_title: Optional[str] = None,
+    img_width: int = 7,
+    img_height: int = 7
+) -> dict:
+    """
+    Generates a reduced dimension plot (e.g., UMAP, t-SNE) from a SingleCellExperiment object.
+
+    This tool wraps the `plot_reduced_dim_sce` function from the R/Bioconductor package `ggsc`.
+    The input must be a .rds file containing a SingleCellExperiment object.
+
+    Args:
+        input_rds: Path to the input RDS file containing a SingleCellExperiment object.
+        output_plot: Path to save the output plot image (e.g., plot.png).
+        dim_red: Name of the dimension reduction to use (e.g., "UMAP", "TSNE").
+        color_by: Variable in colData to color the points by (e.g., "label", "cluster").
+        facet_by: Optional variable in colData to facet the plot by.
+        plot_title: Optional title for the plot.
+        img_width: Width of the output image in inches.
+        img_height: Height of the output image in inches.
+
+    Returns:
+        A dictionary containing the execution details and output file path.
+    """
+    # --- Input Validation ---
+    if not input_rds.is_file():
+        raise FileNotFoundError(f"Input RDS file not found: {input_rds}")
+    if img_width <= 0 or img_height <= 0:
+        raise ValueError("Image width and height must be positive integers.")
+
+    # Ensure output directory exists
+    output_plot.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- Command Construction ---
+    cmd = [
+        "Rscript",
+        R_SCRIPT_EXECUTABLE,
+        "reduced_dim",
+        "--input_rds", str(input_rds),
+        "--output_plot", str(output_plot),
+        "--dim_red", dim_red,
+        "--color_by", color_by,
+        "--img_width", str(img_width),
+        "--img_height", str(img_height)
+    ]
+
+    if facet_by:
+        cmd.extend(["--facet_by", facet_by])
+    if plot_title:
+        cmd.extend(["--plot_title", plot_title])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+    except FileNotFoundError:
+        raise RuntimeError("Rscript or the wrapper script not found. Please ensure R and the tool's R script are in the system's PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = f"ggsc R script failed for reduced_dim plot.\nSTDOUT: {e.stdout}\nSTDERR: {e.stderr}"
+        logging.error(error_message)
+        raise RuntimeError(error_message) from e
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": [str(output_plot)]
+    }
+
+
+@mcp.tool()
+def plot_gene_expression(
+    input_rds: Path,
+    output_plot: Path,
+    gene: str,
+    dim_red: str,
+    assay: str = "logcounts",
+    plot_title: Optional[str] = None,
+    img_width: int = 7,
+    img_height: int = 7
+) -> dict:
+    """
+    Plots the expression of a single gene on a reduced dimension plot.
+
+    This tool wraps the `plot_gene_sce` function from the R/Bioconductor package `ggsc`.
+    The input must be a .rds file containing a SingleCellExperiment object.
+
+    Args:
+        input_rds: Path to the input RDS file containing a SingleCellExperiment object.
+        output_plot: Path to save the output plot image.
+        gene: The name of the gene to plot.
+        dim_red: Name of the dimension reduction to use (e.g., "UMAP").
+        assay: The assay to use for expression values (default: "logcounts").
+        plot_title: Optional title for the plot.
+        img_width: Width of the output image in inches.
+        img_height: Height of the output image in inches.
+
+    Returns:
+        A dictionary containing the execution details and output file path.
+    """
+    # --- Input Validation ---
+    if not input_rds.is_file():
+        raise FileNotFoundError(f"Input RDS file not found: {input_rds}")
+    if not gene:
+        raise ValueError("A gene name must be provided.")
+    if img_width <= 0 or img_height <= 0:
+        raise ValueError("Image width and height must be positive integers.")
+
+    output_plot.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- Command Construction ---
+    cmd = [
+        "Rscript",
+        R_SCRIPT_EXECUTABLE,
+        "gene_plot",
+        "--input_rds", str(input_rds),
+        "--output_plot", str(output_plot),
+        "--gene", gene,
+        "--dim_red", dim_red,
+        "--assay", assay,
+        "--img_width", str(img_width),
+        "--img_height", str(img_height)
+    ]
+
+    if plot_title:
+        cmd.extend(["--plot_title", plot_title])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+    except FileNotFoundError:
+        raise RuntimeError("Rscript or the wrapper script not found. Please ensure R and the tool's R script are in the system's PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = f"ggsc R script failed for gene expression plot.\nSTDOUT: {e.stdout}\nSTDERR: {e.stderr}"
+        logging.error(error_message)
+        raise RuntimeError(error_message) from e
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": [str(output_plot)]
+    }
+
+
+@mcp.tool()
+def plot_expression_heatmap(
+    input_rds: Path,
+    output_plot: Path,
+    genes: List[str],
+    annotation_col: str,
+    assay: str = "logcounts",
+    plot_title: Optional[str] = None,
+    img_width: int = 7,
+    img_height: int = 10
+) -> dict:
+    """
+    Generates a heatmap of gene expression for a set of genes.
+
+    This tool wraps the `plot_heatmap_sce` function from the R/Bioconductor package `ggsc`.
+    The input must be a .rds file containing a SingleCellExperiment object.
+
+    Args:
+        input_rds: Path to the input RDS file containing a SingleCellExperiment object.
+        output_plot: Path to save the output plot image.
+        genes: A list of gene names to include in the heatmap.
+        annotation_col: Column in colData to use for cell annotation.
+        assay: The assay to use for expression values (default: "logcounts").
+        plot_title: Optional title for the plot.
+        img_width: Width of the output image in inches.
+        img_height: Height of the output image in inches.
+
+    Returns:
+        A dictionary containing the execution details and output file path.
+    """
+    # --- Input Validation ---
+    if not input_rds.is_file():
+        raise FileNotFoundError(f"Input RDS file not found: {input_rds}")
+    if not genes:
+        raise ValueError("At least one gene must be provided in the list.")
+    if img_width <= 0 or img_height <= 0:
+        raise ValueError("Image width and height must be positive integers.")
+
+    output_plot.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- Command Construction ---
+    genes_str = ",".join(genes)
+    cmd = [
+        "Rscript",
+        R_SCRIPT_EXECUTABLE,
+        "heatmap",
+        "--input_rds", str(input_rds),
+        "--output_plot", str(output_plot),
+        "--genes", genes_str,
+        "--annotation_col", annotation_col,
+        "--assay", assay,
+        "--img_width", str(img_width),
+        "--img_height", str(img_height)
+    ]
+
+    if plot_title:
+        cmd.extend(["--plot_title", plot_title])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+    except FileNotFoundError:
+        raise RuntimeError("Rscript or the wrapper script not found. Please ensure R and the tool's R script are in the system's PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = f"ggsc R script failed for expression heatmap.\nSTDOUT: {e.stdout}\nSTDERR: {e.stderr}"
+        logging.error(error_message)
+        raise RuntimeError(error_message) from e
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": [str(output_plot)]
+    }
+
+
+@mcp.tool()
+def plot_expression_violin(
+    input_rds: Path,
+    output_plot: Path,
+    gene: str,
+    group_by: str,
+    assay: str = "logcounts",
+    plot_title: Optional[str] = None,
+    img_width: int = 7,
+    img_height: int = 5
+) -> dict:
+    """
+    Generates a violin plot of gene expression across different groups.
+
+    This tool wraps the `plot_violin_sce` function from the R/Bioconductor package `ggsc`.
+    The input must be a .rds file containing a SingleCellExperiment object.
+
+    Args:
+        input_rds: Path to the input RDS file containing a SingleCellExperiment object.
+        output_plot: Path to save the output plot image.
+        gene: The name of the gene to plot.
+        group_by: Variable in colData to group the violins by (e.g., "cluster").
+        assay: The assay to use for expression values (default: "logcounts").
+        plot_title: Optional title for the plot.
+        img_width: Width of the output image in inches.
+        img_height: Height of the output image in inches.
+
+    Returns:
+        A dictionary containing the execution details and output file path.
+    """
+    # --- Input Validation ---
+    if not input_rds.is_file():
+        raise FileNotFoundError(f"Input RDS file not found: {input_rds}")
+    if not gene:
+        raise ValueError("A gene name must be provided.")
+    if img_width <= 0 or img_height <= 0:
+        raise ValueError("Image width and height must be positive integers.")
+
+    output_plot.parent.mkdir(parents=True, exist_ok=True)
+
+    # --- Command Construction ---
+    cmd = [
+        "Rscript",
+        R_SCRIPT_EXECUTABLE,
+        "violin",
+        "--input_rds", str(input_rds),
+        "--output_plot", str(output_plot),
+        "--gene", gene,
+        "--group_by", group_by,
+        "--assay", assay,
+        "--img_width", str(img_width),
+        "--img_height", str(img_height)
+    ]
+
+    if plot_title:
+        cmd.extend(["--plot_title", plot_title])
+
+    # --- Subprocess Execution ---
+    command_executed = " ".join(cmd)
+    logging.info(f"Executing command: {command_executed}")
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            encoding='utf-8'
+        )
+    except FileNotFoundError:
+        raise RuntimeError("Rscript or the wrapper script not found. Please ensure R and the tool's R script are in the system's PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = f"ggsc R script failed for expression violin plot.\nSTDOUT: {e.stdout}\nSTDERR: {e.stderr}"
+        logging.error(error_message)
+        raise RuntimeError(error_message) from e
+
+    return {
+        "command_executed": command_executed,
+        "stdout": result.stdout,
+        "stderr": result.stderr,
+        "output_files": [str(output_plot)]
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ggsc/app/bioconductor-ggsc_shim_server.py

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

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

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