Add files using upload-large-folder tool

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioawk/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 bioawk via conda (e.g., from bioconda)
+RUN conda install -c bioconda bioawk -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/bioawk_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/bioawk_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/bioawk_server.py"]
+        

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioawk/app/bioawk_server.py

@@ -0,0 +1,120 @@
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# @mcp.tool() is a placeholder for the actual decorator.
+# The user prompt says "NO NEED to import mcp".
+def tool(*args, **kwargs):
+    def decorator(f):
+        return f
+    return decorator
+
+mcp = type("mcp", (), {"tool": tool})
+
+
+@mcp.tool()
+def bioawk(
+    program: Optional[str] = None,
+    program_file: Optional[Path] = None,
+    input_files: Optional[List[Path]] = None,
+    format: Optional[str] = None,
+    tab_separator: bool = False,
+    retain_header: bool = False,
+    variables: Optional[List[str]] = None,
+    field_separator: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Executes the bioawk tool, a variant of awk for processing biological data formats.
+
+    bioawk extends awk by understanding common bioinformatics formats, making it easy
+    to parse and manipulate files like FASTA, FASTQ, SAM, VCF, etc.
+
+    Args:
+        program: The awk program script to execute, provided as a string.
+        program_file: A file containing the awk program script.
+                      Exactly one of 'program' or 'program_file' must be provided.
+        input_files: A list of input files to process. If not provided,
+                     bioawk will read from standard input.
+        format: The format of the input data. Supported formats include:
+                fasta, fastq, sam, vcf, bed, gff, gtf, psl, blast, hmmer, cigar.
+                If not specified, bioawk defaults to 'fasta'.
+        tab_separator: Use tab as the input and output field separator (-t).
+        retain_header: Retain the header in the output (-H).
+        variables: A list of variable assignments in 'var=value' format (-v).
+        field_separator: The input field separator, equivalent to awk's -F option.
+
+    Returns:
+        A dictionary containing the executed command, stdout, and stderr.
+    """
+    # 1. Input Validation
+    if not (program or program_file) or (program and program_file):
+        raise ValueError("Exactly one of 'program' or 'program_file' must be provided.")
+
+    if program_file and not program_file.is_file():
+        raise FileNotFoundError(f"Program file not found: {program_file}")
+
+    if input_files:
+        for file_path in input_files:
+            if not file_path.is_file():
+                raise FileNotFoundError(f"Input file not found: {file_path}")
+
+    VALID_FORMATS = {
+        "fasta", "fastq", "sam", "vcf", "bed", "gff",
+        "gtf", "psl", "blast", "hmmer", "cigar"
+    }
+    if format and format.lower() not in VALID_FORMATS:
+        raise ValueError(f"Invalid format '{format}'. Must be one of {VALID_FORMATS}")
+
+    if variables:
+        for var in variables:
+            if "=" not in var:
+                raise ValueError(f"Invalid variable assignment '{var}'. Must be in 'var=value' format.")
+
+    # 2. Command Construction
+    cmd = ["bioawk"]
+
+    if format:
+        cmd.extend(["-c", format])
+    if tab_separator:
+        cmd.append("-t")
+    if retain_header:
+        cmd.append("-H")
+    if field_separator:
+        cmd.extend(["-F", field_separator])
+    if variables:
+        for var in variables:
+            cmd.extend(["-v", var])
+
+    if program_file:
+        cmd.extend(["-f", str(program_file)])
+    elif program:
+        cmd.append(program)
+
+    if input_files:
+        cmd.extend([str(p) for p in input_files])
+
+    # 3. Subprocess Execution
+    command_executed = " ".join(cmd)
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+        }
+    except FileNotFoundError:
+        # This error is raised if the 'bioawk' command itself is not found.
+        raise RuntimeError("bioawk command not found. Please ensure it is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        # This error is raised if bioawk returns a non-zero exit code.
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "error": f"bioawk failed with exit code {e.returncode}"
+        }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioawk/app/bioawk_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_bioawk/app/bioawk_server.py')
+SERVER_NAME = 'biosci_bioawk'
+
+
+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_bioawk/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ancombc/app/bioconductor-ancombc_server.py

@@ -0,0 +1,251 @@
+import subprocess
+import tempfile
+import textwrap
+from pathlib import Path
+from typing import Dict, List, Optional
+
+# @mcp.tool() is a placeholder for the actual decorator.
+# The function is written to be compatible with the MCP server environment.
+def mcp_tool_placeholder(*args, **kwargs):
+    def decorator(func):
+        return func
+    return decorator
+
+@mcp_tool_placeholder()
+def ancombc2(
+    otu_table: Path,
+    sample_metadata: Path,
+    formula: str,
+    output_dir: Path,
+    taxonomy_table: Optional[Path] = None,
+    p_adj_method: str = "holm",
+    zero_cut: float = 0.9,
+    lib_cut: int = 1000,
+    struc_zero: bool = False,
+    neg_lb: bool = False,
+    tol: float = 1e-05,
+    max_iter: int = 100,
+    conserve: bool = False,
+    alpha: float = 0.05,
+    global_test: bool = False,
+    group: Optional[str] = None,
+    mdfdr_dist: str = "normal",
+    n_cl: int = 1,
+    verbose: bool = False,
+    output_prefix: str = "ancombc2_results",
+) -> Dict:
+    """
+    Performs differential abundance analysis on microbiome data using ANCOM-BC2.
+
+    ANCOM-BC2 (Analysis of Compositions of Microbiomes with Bias Correction 2) is a
+    method for identifying differentially abundant taxa between groups while correcting
+    for sample-specific and taxon-specific biases.
+
+    Args:
+        otu_table: Path to the feature/OTU count table (CSV format). Rows should be taxa
+                   and columns should be samples. The first column should be taxon IDs.
+        sample_metadata: Path to the sample metadata file (CSV format). Rows should be
+                         samples and columns should be metadata variables. The first
+                         column should be sample IDs.
+        formula: An R-style formula string specifying the model, e.g., "age + sex + diagnosis".
+                 Variables must correspond to columns in the sample_metadata file.
+        output_dir: Path to the directory where output files will be saved.
+        taxonomy_table: Optional path to the taxonomy table (CSV format). Rows should be
+                        taxa, columns should be taxonomic ranks. The first column must
+                        be taxon IDs matching the OTU table.
+        p_adj_method: Method for p-value adjustment.
+                      Options: "holm", "hochberg", "hommel", "bonferroni", "BH", "BY", "fdr", "none".
+        zero_cut: A numerical value between 0 and 1. Taxa with a proportion of zeros greater
+                  than this value will be excluded from the analysis.
+        lib_cut: A numerical value. Samples with library sizes less than this value will be
+                 excluded from the analysis.
+        struc_zero: Whether to detect structural zeros.
+        neg_lb: Whether to use the negative binomial distribution for modeling sampling fractions.
+                If FALSE, a log-linear model is used.
+        tol: Convergence tolerance for the optimization algorithm.
+        max_iter: Maximum number of iterations for the optimization algorithm.
+        conserve: Whether to use a conservative variance estimate for the test statistic.
+        alpha: Significance level for identifying differentially abundant taxa.
+        global_test: Whether to perform a global test for the specified group variable.
+        group: The name of the group variable for the global test. Required if `global_test` is True.
+               Must be a column name in the sample_metadata file.
+        mdfdr_dist: The assumed distribution of the E-values in m-DFDR.
+                    Options: "normal", "t".
+        n_cl: Number of CPU cores to use for parallel computation.
+        verbose: Whether to display progress messages during execution.
+        output_prefix: Prefix for the output result files.
+
+    Returns:
+        A dictionary containing the executed command, stdout, stderr, and a list of
+        paths to the generated output files.
+    """
+    # --- 1. Input Validation ---
+    if not otu_table.is_file():
+        raise FileNotFoundError(f"OTU table not found at: {otu_table}")
+    if not sample_metadata.is_file():
+        raise FileNotFoundError(f"Sample metadata not found at: {sample_metadata}")
+    if taxonomy_table and not taxonomy_table.is_file():
+        raise FileNotFoundError(f"Taxonomy table not found at: {taxonomy_table}")
+
+    p_adj_methods = ["holm", "hochberg", "hommel", "bonferroni", "BH", "BY", "fdr", "none"]
+    if p_adj_method not in p_adj_methods:
+        raise ValueError(f"Invalid p_adj_method '{p_adj_method}'. Must be one of {p_adj_methods}")
+
+    mdfdr_dists = ["normal", "t"]
+    if mdfdr_dist not in mdfdr_dists:
+        raise ValueError(f"Invalid mdfdr_dist '{mdfdr_dist}'. Must be one of {mdfdr_dists}")
+
+    if not 0 <= zero_cut <= 1:
+        raise ValueError("zero_cut must be between 0 and 1.")
+    if not 0 < alpha < 1:
+        raise ValueError("alpha must be between 0 and 1.")
+    if lib_cut < 0:
+        raise ValueError("lib_cut must be a non-negative integer.")
+    if max_iter <= 0:
+        raise ValueError("max_iter must be a positive integer.")
+    if n_cl <= 0:
+        raise ValueError("n_cl must be a positive integer.")
+    if tol <= 0:
+        raise ValueError("tol must be a positive float.")
+
+    if global_test and not group:
+        raise ValueError("The 'group' parameter is required when 'global_test' is True.")
+
+    # --- 2. Prepare for Execution ---
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    output_res_path = output_dir / f"{output_prefix}_DA.csv"
+    output_files = [str(output_res_path)]
+    
+    output_global_res_path = output_dir / f"{output_prefix}_global.csv"
+    if global_test:
+        output_files.append(str(output_global_res_path))
+
+    # Convert Python types to R-compatible strings
+    r_tax_file = f"'{taxonomy_table.resolve()}'" if taxonomy_table else "NULL"
+    r_group = f"'{group}'" if group else "NULL"
+    r_struc_zero = "TRUE" if struc_zero else "FALSE"
+    r_neg_lb = "TRUE" if neg_lb else "FALSE"
+    r_conserve = "TRUE" if conserve else "FALSE"
+    r_global_test = "TRUE" if global_test else "FALSE"
+    r_verbose = "TRUE" if verbose else "FALSE"
+
+    # --- 3. Generate R Script ---
+    r_script_content = textwrap.dedent(f"""
+    # Load required libraries
+    library(ANCOMBC)
+    library(phyloseq)
+
+    # --- Parameters ---
+    otu_file <- '{otu_table.resolve()}'
+    meta_file <- '{sample_metadata.resolve()}'
+    tax_file <- {r_tax_file}
+    output_res_path <- '{output_res_path.resolve()}'
+    output_global_res_path <- '{output_global_res_path.resolve()}'
+
+    # --- Load and prepare data ---
+    # read.csv with row.names = 1 assumes first column is the index
+    otu_mat <- as.matrix(read.csv(otu_file, row.names = 1, check.names = FALSE))
+    meta_data <- read.csv(meta_file, row.names = 1, check.names = FALSE)
+
+    # Ensure sample names match and are in the same order
+    samples_in_common <- intersect(rownames(meta_data), colnames(otu_mat))
+    if (length(samples_in_common) == 0) {{
+        stop("No common sample IDs found between OTU table and metadata.")
+    }}
+    otu_mat <- otu_mat[, samples_in_common, drop = FALSE]
+    meta_data <- meta_data[samples_in_common, , drop = FALSE]
+
+    OTU <- otu_table(otu_mat, taxa_are_rows = TRUE)
+    META <- sample_data(meta_data)
+
+    # Load taxonomy if provided
+    if (!is.null(tax_file)) {{
+        tax_mat <- as.matrix(read.csv(tax_file, row.names = 1, check.names = FALSE))
+        # Ensure taxon names match
+        taxa_in_common <- intersect(rownames(tax_mat), rownames(otu_mat))
+        if (length(taxa_in_common) == 0) {{
+            warning("No common taxon IDs found between OTU table and taxonomy table. Proceeding without taxonomy.")
+            pseq <- phyloseq(OTU, META)
+        }} else {{
+            tax_mat_filtered <- tax_mat[taxa_in_common, , drop = FALSE]
+            TAX <- tax_table(tax_mat_filtered)
+            pseq <- phyloseq(OTU, META, TAX)
+        }}
+    }} else {{
+        pseq <- phyloseq(OTU, META)
+    }}
+
+    # --- Run ANCOM-BC2 ---
+    output <- ancombc2(
+        data = pseq,
+        formula = "{formula}",
+        p_adj_method = "{p_adj_method}",
+        zero_cut = {zero_cut},
+        lib_cut = {lib_cut},
+        struc_zero = {r_struc_zero},
+        neg_lb = {r_neg_lb},
+        tol = {tol},
+        max_iter = {max_iter},
+        conserve = {r_conserve},
+        alpha = {alpha},
+        global = {r_global_test},
+        group = {r_group},
+        mdfdr_dist = "{mdfdr_dist}",
+        n_cl = {n_cl},
+        verbose = {r_verbose}
+    )
+
+    # --- Save results ---
+    # Save differential abundance results
+    res_df <- data.frame(output$res)
+    write.csv(res_df, file = output_res_path, row.names = TRUE)
+
+    # Save global test results if applicable
+    if ({r_global_test} && !is.null(output$res_global)) {{
+        res_global_df <- data.frame(output$res_global)
+        write.csv(res_global_df, file = output_global_res_path, row.names = TRUE)
+    }}
+    
+    print("ANCOM-BC2 analysis completed successfully.")
+    """)
+
+    # --- 4. Execute ---
+    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
+
+    command = ["Rscript", r_script_path]
+    command_executed = " ".join(command)
+    
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = result.stdout
+        stderr = result.stderr
+    except subprocess.CalledProcessError as e:
+        # Clean up the temporary script file on error
+        Path(r_script_path).unlink()
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "return_code": e.returncode,
+            "output_files": []
+        }
+    finally:
+        # Ensure temporary script is always cleaned up
+        if Path(r_script_path).exists():
+            Path(r_script_path).unlink()
+
+    # --- 5. Return results ---
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": output_files
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ancombc/app/bioconductor-ancombc_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-ancombc/app/bioconductor-ancombc_server.py')
+SERVER_NAME = 'biosci_bioconductor_ancombc'
+
+
+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-ancombc/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-concordexr/app/bioconductor-concordexr_server.py

@@ -0,0 +1,221 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional, List
+
+# Mock the decorator for standalone execution
+class mcp:
+    @staticmethod
+    def tool(func):
+        return func
+
+@mcp.tool
+def compute_concordex(
+    data_file: Path,
+    ranks_file: Path,
+    indices_file: Path,
+    output_dir: Path,
+    data_type: str = "counts",
+    abundance_min: float = 1.0,
+    abundance_max: Optional[float] = None,
+    sample_min: float = 0.0,
+    sample_max: Optional[float] = None,
+    filter_perc: float = 0.0,
+    filter_count: int = 0,
+    plot: bool = True,
+    plot_format: str = "png",
+    plot_width: int = 10,
+    plot_height: int = 10,
+    export: bool = True,
+    export_rds: bool = True,
+):
+    """
+    Computes the Concordance Index (Concordex) using the concordexR package.
+
+    This tool wraps the `computeConcordex` function. It takes expression/count data,
+    pre-computed ranks, and sample indices to calculate concordex scores. It can
+    filter data, generate plots, and export results to files.
+
+    Args:
+        data_file: Path to the input data file (e.g., counts matrix). Assumed to be a tab-separated file with a header and row names in the first column.
+        ranks_file: Path to the ranks file. Assumed to be a tab-separated file with a header and row names in the first column.
+        indices_file: Path to the indices file. Assumed to be a single-column, tab-separated file without a header.
+        output_dir: Path to the directory where output files will be saved.
+        data_type: The type of data in `data_file`. Must be either 'counts' or 'ranks'.
+        abundance_min: The minimum abundance of a feature to be included in the analysis.
+        abundance_max: The maximum abundance of a feature. If None, no upper limit is applied.
+        sample_min: The minimum value of a sample to be included.
+        sample_max: The maximum value of a sample. If None, no upper limit is applied.
+        filter_perc: The percentage of samples a feature must be present in to be retained. Value must be between 0.0 and 1.0.
+        filter_count: The minimum number of counts a feature must have across all samples to be retained.
+        plot: If True, generate concordex plots.
+        plot_format: The format for the output plots (e.g., 'png', 'pdf', 'svg').
+        plot_width: The width of the output plots in inches.
+        plot_height: The height of the output plots in inches.
+        export: If True, export the concordex results to text files.
+        export_rds: If True, save the final concordex R object to an .rds file for later use (e.g., with plot_concordex).
+    """
+    # Input validation
+    if not data_file.is_file():
+        raise FileNotFoundError(f"Input data file not found: {data_file}")
+    if not ranks_file.is_file():
+        raise FileNotFoundError(f"Ranks file not found: {ranks_file}")
+    if not indices_file.is_file():
+        raise FileNotFoundError(f"Indices file not found: {indices_file}")
+
+    if data_type not in ["counts", "ranks"]:
+        raise ValueError("data_type must be either 'counts' or 'ranks'.")
+    if not (0.0 <= filter_perc <= 1.0):
+        raise ValueError("filter_perc must be between 0.0 and 1.0.")
+    if filter_count < 0:
+        raise ValueError("filter_count must be a non-negative integer.")
+    if plot_format not in ["png", "pdf", "svg", "jpeg", "tiff"]:
+        raise ValueError(f"Unsupported plot format: {plot_format}")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Build the R script
+    r_script_lines = [
+        "library(concordexR)",
+        f'data <- read.table("{data_file.resolve()}", header=TRUE, sep="\\t", row.names=1, check.names=FALSE)',
+        f'ranks <- read.table("{ranks_file.resolve()}", header=TRUE, sep="\\t", row.names=1, check.names=FALSE)',
+        f'indices_df <- read.table("{indices_file.resolve()}", header=FALSE, sep="\\t")',
+        "indices <- as.list(indices_df$V1)",
+        "concordex_result <- computeConcordex(",
+        "    data = data,",
+        "    ranks = ranks,",
+        "    indices = indices,",
+        f'    type = "{data_type}",',
+        f"    abundance.min = {abundance_min},",
+        f"    abundance.max = {abundance_max if abundance_max is not None else 'Inf'},",
+        f"    sample.min = {sample_min},",
+        f"    sample.max = {sample_max if sample_max is not None else 'Inf'},",
+        f"    filter.perc = {filter_perc},",
+        f"    filter.count = {filter_count},",
+        f'    output.dir = "{output_dir.resolve()}",',
+        f"    plot = {'TRUE' if plot else 'FALSE'},",
+        f'    plot.format = "{plot_format}",',
+        f"    plot.width = {plot_width},",
+        f"    plot.height = {plot_height},",
+        f"    export = {'TRUE' if export else 'FALSE'}",
+        ")",
+    ]
+
+    if export_rds:
+        rds_path = output_dir.resolve() / "concordex_object.rds"
+        r_script_lines.append(f'saveRDS(concordex_result, file = "{rds_path}")')
+
+    r_script = "\n".join(r_script_lines)
+
+    # Use a temporary file for the R script
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as f:
+        f.write(r_script)
+        r_script_path = Path(f.name)
+
+    cmd = ["Rscript", str(r_script_path)]
+    command_executed = " ".join(cmd)
+    
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        
+        output_files = [str(p) for p in output_dir.glob("**/*") if p.is_file()]
+
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with return code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+    finally:
+        r_script_path.unlink()
+
+@mcp.tool
+def plot_concordex(
+    concordex_object_file: Path,
+    output_dir: Path,
+    plot_format: str = "png",
+    plot_width: int = 10,
+    plot_height: int = 10,
+):
+    """
+    Generates plots from a pre-computed concordex object.
+
+    This tool wraps the `plotConcordex` function from the concordexR package.
+    It takes an .rds file containing a concordex object (generated by the
+    compute_concordex tool) and creates visualization plots.
+
+    Args:
+        concordex_object_file: Path to the .rds file containing the concordex object.
+        output_dir: Path to the directory where output plots will be saved.
+        plot_format: The format for the output plots (e.g., 'png', 'pdf', 'svg').
+        plot_width: The width of the output plots in inches.
+        plot_height: The height of the output plots in inches.
+    """
+    # Input validation
+    if not concordex_object_file.is_file():
+        raise FileNotFoundError(f"Concordex object file not found: {concordex_object_file}")
+    if concordex_object_file.suffix != ".rds":
+        raise ValueError("concordex_object_file must be an .rds file.")
+    if plot_format not in ["png", "pdf", "svg", "jpeg", "tiff"]:
+        raise ValueError(f"Unsupported plot format: {plot_format}")
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Build the R script
+    r_script_lines = [
+        "library(concordexR)",
+        f'concordex_obj <- readRDS("{concordex_object_file.resolve()}")',
+        "plotConcordex(",
+        "    concordex.object = concordex_obj,",
+        f'    output.dir = "{output_dir.resolve()}",',
+        f'    plot.format = "{plot_format}",',
+        f"    plot.width = {plot_width},",
+        f"    plot.height = {plot_height}",
+        ")",
+    ]
+    r_script = "\n".join(r_script_lines)
+
+    with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False) as f:
+        f.write(r_script)
+        r_script_path = Path(f.name)
+
+    cmd = ["Rscript", str(r_script_path)]
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        
+        output_files = [str(p) for p in output_dir.glob("**/*") if p.is_file()]
+
+        return {
+            "command_executed": command_executed,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "output_files": output_files,
+        }
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(
+            f"R script execution failed with return code {e.returncode}.\n"
+            f"Command: {command_executed}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        ) from e
+    finally:
+        r_script_path.unlink()

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-concordexr/app/bioconductor-concordexr_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-concordexr/app/bioconductor-concordexr_server.py')
+SERVER_NAME = 'biosci_bioconductor_concordexr'
+
+
+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-concordexr/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-decipher/app/bioconductor-decipher_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-decipher/app/bioconductor-decipher_server.py')
+SERVER_NAME = 'biosci_bioconductor_decipher'
+
+
+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-decipher/docker-compose.yml

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ensembldb/app/bioconductor-ensembldb_server.py

@@ -0,0 +1,433 @@
+import subprocess
+import tempfile
+import textwrap
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# Assume mcp.tool is imported from a framework library
+class mcp:
+    def tool(func):
+        return func
+
+def _run_r_script(r_script_content: str, args: List[str]) -> Dict[str, Any]:
+    """
+    A helper function to execute an R script using Rscript, handling errors.
+
+    This function requires that R and the required Bioconductor packages
+    (e.g., ensembldb, AnnotationFilter) are installed in the execution environment.
+
+    Args:
+        r_script_content: A string containing the R code to execute.
+        args: A list of command-line arguments for the R script.
+
+    Returns:
+        A dictionary containing the executed command, stdout, and stderr.
+
+    Raises:
+        RuntimeError: If Rscript is not found in the system's PATH.
+        subprocess.CalledProcessError: If the R script execution fails.
+    """
+    try:
+        with tempfile.NamedTemporaryFile(mode='w', suffix=".R", delete=False, encoding='utf-8') as tmp_script:
+            script_path = Path(tmp_script.name)
+            tmp_script.write(r_script_content)
+
+        command = ["Rscript", str(script_path)] + args
+        
+        process = subprocess.run(
+            command,
+            check=True,
+            capture_output=True,
+            text=True,
+            encoding='utf-8'
+        )
+        return {
+            "command_executed": " ".join(command),
+            "stdout": process.stdout,
+            "stderr": process.stderr
+        }
+    except FileNotFoundError:
+        raise RuntimeError("Rscript not found. Please ensure R is installed and in your PATH.")
+    except subprocess.CalledProcessError as e:
+        error_message = (
+            f"R script execution failed with exit code {e.returncode}.\n"
+            f"Command: {' '.join(e.cmd)}\n"
+            f"Stdout: {e.stdout}\n"
+            f"Stderr: {e.stderr}"
+        )
+        # Re-raise with a more informative stderr
+        raise subprocess.CalledProcessError(e.returncode, e.cmd, output=e.stdout, stderr=error_message)
+    finally:
+        if 'script_path' in locals() and script_path.exists():
+            script_path.unlink()
+
+@mcp.tool
+def create_ensdb_from_gtf(
+    gtf_file: Path,
+    output_db: Path,
+    organism: str,
+    genome_version: str,
+    ensembl_version: str,
+) -> Dict[str, Any]:
+    """
+    Creates an EnsemblDB SQLite database from a GTF file.
+
+    This tool wraps the `ensDbFromGtf` function from the R/Bioconductor
+    package 'ensembldb'. It requires R and the 'ensembldb' package to be
+    installed in the environment.
+
+    Args:
+        gtf_file: Path to the input GTF file.
+        output_db: Path for the output SQLite database file.
+        organism: Name of the organism (e.g., 'Homo_sapiens').
+        genome_version: Genome build version (e.g., 'GRCh38').
+        ensembl_version: Ensembl release version (e.g., '104').
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr,
+        and a list of output files.
+    """
+    # Input validation
+    if not gtf_file.is_file():
+        raise FileNotFoundError(f"Input GTF file not found: {gtf_file}")
+    if not output_db.parent.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_db.parent}")
+    if not all([organism, genome_version, ensembl_version]):
+        raise ValueError("organism, genome_version, and ensembl_version must be non-empty strings.")
+
+    r_script = textwrap.dedent("""
+    library("ensembldb")
+    args <- commandArgs(trailingOnly = TRUE)
+    ensDbFromGtf(
+        gtf = args[1],
+        outfile = args[2],
+        organism = args[3],
+        genomeVersion = args[4],
+        version = args[5]
+    )
+    """)
+    
+    args = [
+        str(gtf_file),
+        str(output_db),
+        organism,
+        genome_version,
+        ensembl_version
+    ]
+
+    result = _run_r_script(r_script, args)
+    result["output_files"] = [str(output_db)]
+    return result
+
+@mcp.tool
+def create_ensdb_from_gff(
+    gff_file: Path,
+    output_db: Path,
+    organism: str,
+    genome_version: str,
+    ensembl_version: str,
+) -> Dict[str, Any]:
+    """
+    Creates an EnsemblDB SQLite database from a GFF3 file.
+
+    This tool wraps the `ensDbFromGff` function from the R/Bioconductor
+    package 'ensembldb'. It requires R and the 'ensembldb' package to be
+    installed in the environment.
+
+    Args:
+        gff_file: Path to the input GFF3 file.
+        output_db: Path for the output SQLite database file.
+        organism: Name of the organism (e.g., 'Homo_sapiens').
+        genome_version: Genome build version (e.g., 'GRCh38').
+        ensembl_version: Ensembl release version (e.g., '104').
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr,
+        and a list of output files.
+    """
+    # Input validation
+    if not gff_file.is_file():
+        raise FileNotFoundError(f"Input GFF file not found: {gff_file}")
+    if not output_db.parent.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_db.parent}")
+    if not all([organism, genome_version, ensembl_version]):
+        raise ValueError("organism, genome_version, and ensembl_version must be non-empty strings.")
+
+    r_script = textwrap.dedent("""
+    library("ensembldb")
+    args <- commandArgs(trailingOnly = TRUE)
+    ensDbFromGff(
+        gff = args[1],
+        outfile = args[2],
+        organism = args[3],
+        genomeVersion = args[4],
+        version = args[5]
+    )
+    """)
+    
+    args = [
+        str(gff_file),
+        str(output_db),
+        organism,
+        genome_version,
+        ensembl_version
+    ]
+
+    result = _run_r_script(r_script, args)
+    result["output_files"] = [str(output_db)]
+    return result
+
+def _build_query_script(query_function: str, extra_r_code: str = "") -> str:
+    """Helper to generate the R script for various query types."""
+    return textwrap.dedent(f"""
+    library("ensembldb")
+    library("AnnotationFilter")
+
+    args <- commandArgs(trailingOnly = TRUE)
+    
+    parse_args <- function(args) {{
+      params <- list()
+      for (arg in args) {{
+        if (startsWith(arg, "--")) {{
+          parts <- strsplit(substring(arg, 3), "=", fixed = TRUE)[[1]]
+          key <- parts[1]
+          value <- if (length(parts) > 1) parts[2] else TRUE
+          params[[key]] <- value
+        }}
+      }}
+      return(params)
+    }}
+    
+    params <- parse_args(args)
+    
+    if (is.null(params$db) || is.null(params$outfile)) {{
+      stop("Both --db and --outfile arguments are required.")
+    }}
+    
+    edb <- EnsDb(params$db)
+    
+    filter_list <- list()
+    if (!is.null(params$filter_gene_id)) {{
+      filter_list <- c(filter_list, GeneIdFilter(params$filter_gene_id))
+    }}
+    if (!is.null(params$filter_gene_biotype)) {{
+      filter_list <- c(filter_list, GeneBiotypeFilter(params$filter_gene_biotype))
+    }}
+    if (!is.null(params$filter_seq_name)) {{
+      filter_list <- c(filter_list, SeqNameFilter(params$filter_seq_name))
+    }}
+    if (!is.null(params$filter_tx_id)) {{
+      filter_list <- c(filter_list, TxIdFilter(params$filter_tx_id))
+    }}
+    if (!is.null(params$filter_tx_biotype)) {{
+      filter_list <- c(filter_list, TxBiotypeFilter(params$filter_tx_biotype))
+    }}
+    if (!is.null(params$filter_exon_id)) {{
+      filter_list <- c(filter_list, ExonIdFilter(params$filter_exon_id))
+    }}
+
+    final_filter <- NULL
+    if (length(filter_list) > 0) {{
+      final_filter <- AnnotationFilterList(filter_list, logicOp = "&")
+    }}
+    
+    {extra_r_code}
+
+    results <- {query_function}(edb, filter = final_filter)
+    
+    write.table(as.data.frame(results), file = params$outfile, sep = "\t", row.names = FALSE, quote = FALSE)
+    
+    cat("Successfully wrote query results to:", params$outfile, "\n")
+    """)
+
+@mcp.tool
+def query_genes(
+    db_file: Path,
+    output_tsv: Path,
+    filter_gene_id: Optional[str] = None,
+    filter_gene_biotype: Optional[str] = None,
+    filter_seq_name: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Queries gene information from an EnsemblDB SQLite database.
+
+    This tool wraps the `genes` function from 'ensembldb'. It requires R,
+    'ensembldb', and 'AnnotationFilter' packages.
+
+    Args:
+        db_file: Path to the input EnsemblDB SQLite file.
+        output_tsv: Path for the output TSV file.
+        filter_gene_id: Optional filter by Ensembl gene ID.
+        filter_gene_biotype: Optional filter by gene biotype (e.g., 'protein_coding').
+        filter_seq_name: Optional filter by sequence/chromosome name (e.g., 'X').
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr,
+        and a list of output files.
+    """
+    if not db_file.is_file():
+        raise FileNotFoundError(f"Input database file not found: {db_file}")
+    if not output_tsv.parent.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_tsv.parent}")
+
+    r_script = _build_query_script("genes")
+    
+    args = [f"--db={db_file}", f"--outfile={output_tsv}"]
+    if filter_gene_id:
+        args.append(f"--filter_gene_id={filter_gene_id}")
+    if filter_gene_biotype:
+        args.append(f"--filter_gene_biotype={filter_gene_biotype}")
+    if filter_seq_name:
+        args.append(f"--filter_seq_name={filter_seq_name}")
+
+    result = _run_r_script(r_script, args)
+    result["output_files"] = [str(output_tsv)]
+    return result
+
+@mcp.tool
+def query_transcripts(
+    db_file: Path,
+    output_tsv: Path,
+    filter_gene_id: Optional[str] = None,
+    filter_tx_id: Optional[str] = None,
+    filter_tx_biotype: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Queries transcript information from an EnsemblDB SQLite database.
+
+    This tool wraps the `transcripts` function from 'ensembldb'. It requires R,
+    'ensembldb', and 'AnnotationFilter' packages.
+
+    Args:
+        db_file: Path to the input EnsemblDB SQLite file.
+        output_tsv: Path for the output TSV file.
+        filter_gene_id: Optional filter by Ensembl gene ID.
+        filter_tx_id: Optional filter by Ensembl transcript ID.
+        filter_tx_biotype: Optional filter by transcript biotype (e.g., 'protein_coding').
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr,
+        and a list of output files.
+    """
+    if not db_file.is_file():
+        raise FileNotFoundError(f"Input database file not found: {db_file}")
+    if not output_tsv.parent.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_tsv.parent}")
+
+    r_script = _build_query_script("transcripts")
+    
+    args = [f"--db={db_file}", f"--outfile={output_tsv}"]
+    if filter_gene_id:
+        args.append(f"--filter_gene_id={filter_gene_id}")
+    if filter_tx_id:
+        args.append(f"--filter_tx_id={filter_tx_id}")
+    if filter_tx_biotype:
+        args.append(f"--filter_tx_biotype={filter_tx_biotype}")
+
+    result = _run_r_script(r_script, args)
+    result["output_files"] = [str(output_tsv)]
+    return result
+
+@mcp.tool
+def query_exons(
+    db_file: Path,
+    output_tsv: Path,
+    filter_gene_id: Optional[str] = None,
+    filter_tx_id: Optional[str] = None,
+    filter_exon_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Queries exon information from an EnsemblDB SQLite database.
+
+    This tool wraps the `exons` function from 'ensembldb'. It requires R,
+    'ensembldb', and 'AnnotationFilter' packages.
+
+    Args:
+        db_file: Path to the input EnsemblDB SQLite file.
+        output_tsv: Path for the output TSV file.
+        filter_gene_id: Optional filter by Ensembl gene ID.
+        filter_tx_id: Optional filter by Ensembl transcript ID.
+        filter_exon_id: Optional filter by Ensembl exon ID.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr,
+        and a list of output files.
+    """
+    if not db_file.is_file():
+        raise FileNotFoundError(f"Input database file not found: {db_file}")
+    if not output_tsv.parent.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_tsv.parent}")
+
+    r_script = _build_query_script("exons")
+    
+    args = [f"--db={db_file}", f"--outfile={output_tsv}"]
+    if filter_gene_id:
+        args.append(f"--filter_gene_id={filter_gene_id}")
+    if filter_tx_id:
+        args.append(f"--filter_tx_id={filter_tx_id}")
+    if filter_exon_id:
+        args.append(f"--filter_exon_id={filter_exon_id}")
+
+    result = _run_r_script(r_script, args)
+    result["output_files"] = [str(output_tsv)]
+    return result
+
+@mcp.tool
+def query_promoters(
+    db_file: Path,
+    output_tsv: Path,
+    upstream: int = 2000,
+    downstream: int = 200,
+    filter_gene_id: Optional[str] = None,
+    filter_tx_id: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Extracts promoter regions for transcripts from an EnsemblDB.
+
+    This tool wraps the `promoters` function from 'ensembldb'. It requires R,
+    'ensembldb', and 'AnnotationFilter' packages.
+
+    Args:
+        db_file: Path to the input EnsemblDB SQLite file.
+        output_tsv: Path for the output TSV file.
+        upstream: The number of bases upstream of the TSS to include.
+        downstream: The number of bases downstream of the TSS to include.
+        filter_gene_id: Optional filter by Ensembl gene ID.
+        filter_tx_id: Optional filter by Ensembl transcript ID.
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr,
+        and a list of output files.
+    """
+    if not db_file.is_file():
+        raise FileNotFoundError(f"Input database file not found: {db_file}")
+    if not output_tsv.parent.is_dir():
+        raise NotADirectoryError(f"Output directory does not exist: {output_tsv.parent}")
+    if upstream < 0 or downstream < 0:
+        raise ValueError("upstream and downstream values must be non-negative.")
+
+    # The 'promoters' function takes upstream/downstream as direct arguments,
+    # so we modify the R script generation slightly.
+    extra_r_code = textwrap.dedent(f"""
+    up <- as.numeric(params$upstream)
+    down <- as.numeric(params$downstream)
+    results <- promoters(edb, upstream = up, downstream = down, filter = final_filter)
+    """)
+    
+    # We remove the final `results <- ...` line from the base template
+    base_script = _build_query_script("", extra_r_code)
+
+    args = [
+        f"--db={db_file}",
+        f"--outfile={output_tsv}",
+        f"--upstream={upstream}",
+        f"--downstream={downstream}"
+    ]
+    if filter_gene_id:
+        args.append(f"--filter_gene_id={filter_gene_id}")
+    if filter_tx_id:
+        args.append(f"--filter_tx_id={filter_tx_id}")
+
+    result = _run_r_script(base_script, args)
+    result["output_files"] = [str(output_tsv)]
+    return result

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-ensembldb/app/bioconductor-ensembldb_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-ensembldb/app/bioconductor-ensembldb_server.py')
+SERVER_NAME = 'biosci_bioconductor_ensembldb'
+
+
+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-ensembldb/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-escher/app/bioconductor-escher_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-escher/app/bioconductor-escher_server.py')
+SERVER_NAME = 'biosci_bioconductor_escher'
+
+
+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-escher/environment.yaml

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

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

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

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

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-genomeinfodbdata/app/bioconductor-genomeinfodbdata_server.py

@@ -0,0 +1,130 @@
+import subprocess
+from pathlib import Path
+from typing import List, Optional, Dict, Any
+
+# MCP decorator placeholder
+def tool(*args, **kwargs):
+    def decorator(f):
+        return f
+    return decorator
+
+# In a real MCP environment, the 'mcp' object would be imported.
+# For this standalone script, we define a placeholder.
+class mcp:
+    tool = tool
+
+@mcp.tool()
+def run_rscript(
+    script_file: Optional[Path] = None,
+    expressions: Optional[List[str]] = None,
+    args: Optional[List[str]] = None,
+    verbose: bool = False,
+    default_packages: Optional[str] = None,
+    save: bool = False,
+    no_environ: bool = False,
+    no_site_file: bool = False,
+    no_init_file: bool = False,
+    restore: bool = False,
+    vanilla: bool = False,
+) -> Dict[str, Any]:
+    """
+    Executes an R script using the Rscript interpreter.
+
+    This tool is a general-purpose wrapper for the Rscript command-line utility.
+    The 'bioconductor-genomeinfodbdata' package is a data-only package and does not
+    have its own executable. It is intended to be used within R scripts, which can
+    be run with this tool.
+
+    Args:
+        script_file: Path to the R script file to be executed.
+        expressions: A list of R expressions to be executed. Use this or script_file, not both.
+        args: A list of arguments to be passed to the R script.
+        verbose: Print information on progress (--verbose).
+        default_packages: A comma-separated list of package names to be loaded by default (--default-packages).
+        save: Save the workspace at the end of the session (--save).
+        no_environ: Don't read the site and user environment files (--no-environ).
+        no_site_file: Don't read the site-wide Rprofile (--no-site-file).
+        no_init_file: Don't read the user R profile (--no-init-file).
+        restore: Restore previously saved objects at startup (--restore).
+        vanilla: Combine --no-save, --no-restore, --no-site-file, --no-init-file, and --no-environ (--vanilla).
+
+    Returns:
+        A dictionary containing the command executed, stdout, stderr, and a list of output files.
+    """
+    # Input validation
+    if script_file and expressions:
+        raise ValueError("Provide either 'script_file' or 'expressions', not both.")
+    if not script_file and not expressions:
+        raise ValueError("Either 'script_file' or 'expressions' must be provided.")
+
+    if script_file:
+        if not script_file.is_file():
+            raise FileNotFoundError(f"The script file does not exist: {script_file}")
+
+    cmd = ["Rscript"]
+
+    # Add R-specific options
+    if vanilla:
+        cmd.append("--vanilla")
+    else:
+        if save:
+            cmd.append("--save")
+        if no_environ:
+            cmd.append("--no-environ")
+        if no_site_file:
+            cmd.append("--no-site-file")
+        if no_init_file:
+            cmd.append("--no-init-file")
+        if restore:
+            cmd.append("--restore")
+
+    if verbose:
+        cmd.append("--verbose")
+    if default_packages:
+        cmd.extend(["--default-packages", default_packages])
+
+    # Add script file or expressions
+    if script_file:
+        cmd.append(str(script_file))
+    elif expressions:
+        for expr in expressions:
+            cmd.extend(["-e", expr])
+
+    # Add script arguments
+    if args:
+        cmd.extend(args)
+
+    command_executed = " ".join(cmd)
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        stdout = result.stdout
+        stderr = result.stderr
+    except FileNotFoundError:
+        return {
+            "command_executed": command_executed,
+            "stdout": "",
+            "stderr": "Error: Rscript not found. Is R installed and in your PATH?",
+            "output_files": []
+        }
+    except subprocess.CalledProcessError as e:
+        return {
+            "command_executed": command_executed,
+            "stdout": e.stdout,
+            "stderr": e.stderr,
+            "output_files": []
+        }
+
+    # Since the script's output files are unknown, we return an empty list.
+    # The user's R script is responsible for managing its own outputs.
+    return {
+        "command_executed": command_executed,
+        "stdout": stdout,
+        "stderr": stderr,
+        "output_files": [],
+    }

BioScientist/agent_system/toolbase/mcp_batch_from_manual_txt/mcp_bioconductor-genomeinfodbdata/app/bioconductor-genomeinfodbdata_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-genomeinfodbdata/app/bioconductor-genomeinfodbdata_server.py')
+SERVER_NAME = 'biosci_bioconductor_genomeinfodbdata'
+
+
+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-genomeinfodbdata/app/requirements.txt

@@ -0,0 +1 @@
+

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

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

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

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

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

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