Upload 14 files

Dockerfile

@@ -1,18 +1,23 @@
-FROM python:3.10
+FROM python:3.11-slim
 
-RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
 
 WORKDIR /app
 
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+RUN useradd -m -u 1000 appuser
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY deepTools /app/deepTools
+COPY app.py /app/app.py
 
-COPY --chown=user . /app
 ENV MCP_TRANSPORT=http
 ENV MCP_PORT=7860
 
 EXPOSE 7860
 
-CMD ["python", "deepTools/mcp_output/start_mcp.py"]
+USER appuser
+
+ENTRYPOINT ["python", "deepTools/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,72 @@
 ---
-title: DeepTools
-emoji: 🔥
-colorFrom: purple
-colorTo: pink
+title: deepTools MCP Service
+emoji: 🔧
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# deepTools MCP Service
+
+This deployment package exposes selected `deeptools` functionality through an MCP-compatible server built with `FastMCP`.
+
+## Available Tools
+
+- `health_check`
+- `list_modules`
+- `list_symbols`
+- `call_function`
+- `create_instance`
+- `compute_ratio`
+- `smart_label`
+- `convert_colormap`
+
+Detailed parameter docs and examples are available in `deepTools/mcp_output/README_MCP.md`.
+
+## Local stdio usage
+
+Use this mode for local MCP clients (for example Claude Desktop / CLI):
+
+```bash
+cd deepTools/mcp_output
+python start_mcp.py
+```
+
+Or:
+
+```bash
+python mcp_plugin/main.py
+```
+
+## HTTP usage (Docker / hosted)
+
+Run with HTTP transport:
+
+```bash
+cd deepTools/mcp_output
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+Client connection endpoint:
+
+`https://{host}/mcp`
+
+## Docker deployment
+
+Build and run:
+
+```bash
+./run_docker.sh
+```
+
+PowerShell:
+
+```powershell
+./run_docker.ps1
+```
+
+The Docker entry point is:
+
+`python deepTools/mcp_output/start_mcp.py`

app.py

@@ -1,45 +1,55 @@
-from fastapi import FastAPI
+from __future__ import annotations
+
 import os
 import sys
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+CURRENT_DIR = Path(__file__).resolve().parent
+PLUGIN_DIR = CURRENT_DIR / "deepTools" / "mcp_output" / "mcp_plugin"
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "deepTools", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+app = FastAPI(title="deepTools MCP Info App", version="1.0.0")
 
-app = FastAPI(
-    title="Deeptools MCP Service",
-    description="Auto-generated MCP service for deepTools",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def root() -> dict[str, Any]:
     return {
-        "service": "Deeptools MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "deepTools MCP Deployment",
+        "mcp_transport_default": "stdio",
+        "mcp_http_path": "/mcp",
+        "note": "This FastAPI app is supplementary and not the MCP runtime entry point.",
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "deepTools MCP"}
+def health() -> dict[str, str]:
+    return {"status": "healthy"}
+
 
 @app.get("/tools")
-def list_tools():
-    try:
-        from mcp_service import create_app
-        mcp_app = create_app()
-        tools = []
-        for tool_name, tool_func in mcp_app.tools.items():
-            tools.append({
-                "name": tool_name,
-                "description": tool_func.__doc__ or "No description available"
-            })
-        return {"tools": tools}
-    except Exception as e:
-        return {"error": f"Failed to load tools: {str(e)}"}
+def tools() -> dict[str, Any]:
+    from mcp_service import create_app
+
+    mcp = create_app()
+    tool_items = []
+    for tool in getattr(mcp, "tools", []):
+        tool_items.append(
+            {
+                "name": getattr(tool, "name", getattr(tool, "__name__", "unknown")),
+                "description": getattr(tool, "description", ""),
+            }
+        )
+    return {"count": len(tool_items), "tools": tool_items}
+
+
+PORT = int(os.getenv("PORT", "7860"))
+
 
 if __name__ == "__main__":
     import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+
+    uvicorn.run(app, host="0.0.0.0", port=PORT)

deepTools/mcp_output/README_MCP.md

@@ -1,131 +1,98 @@
-# deepTools MCP (Model Context Protocol) Service README
+# deepTools MCP Tools
 
-## 1) Project Introduction
+This MCP layer wraps selected `deeptools` capabilities with standardized responses:
 
-This MCP (Model Context Protocol) service wraps core **deepTools** genomics workflows so LLM clients or automation agents can run signal-processing and QC tasks in a consistent, tool-oriented interface.
+```json
+{"success": true|false, "result": <any|null>, "error": "<message|null>"}
+```
 
-It is designed for common NGS analysis tasks such as:
+## Exposed Tools
 
-- BAM → coverage track generation
-- Differential/comparative signal tracks
-- Matrix computation around genomic regions
-- Heatmap/profile plotting
-- Multi-sample correlation and PCA QC
-- GC bias estimation/correction
-- Read filtering and alignment post-processing
+1. `health_check()`
+   - Returns dependency availability and adapter/module loading status.
 
-Repository: https://github.com/deeptools/deepTools
+2. `list_modules(include_failed: bool = true)`
+   - Lists loaded `deeptools.*` modules and optional import failures.
 
----
-
-## 2) Installation Method
+3. `list_symbols(module_name: str, public_only: bool = true, limit: int = 100)`
+   - Lists symbols from one loaded module.
 
-### Requirements
+4. `call_function(module_name: str, function_name: str, args_json: str = "[]", kwargs_json: str = "{}")`
+   - Calls one module-level function using JSON-encoded args/kwargs.
 
-- Python 3.8+ (recommended: 3.9/3.10)
-- Core Python deps:
-  - numpy
-  - scipy
-  - matplotlib
-  - pysam
-  - pyBigWig
-- Optional (feature/environment dependent):
-  - deeptoolsintervals
-  - bx-python
-  - Galaxy runtime components (only for Galaxy wrapper usage)
+5. `create_instance(module_name: str, class_name: str, init_args_json: str = "[]", init_kwargs_json: str = "{}")`
+   - Creates one class instance and returns type/representation metadata.
 
-### Install with pip
+6. `compute_ratio(value1: float, value2: float, value_type: str = "ratio", scale_factor_1: float = 1.0, scale_factor_2: float = 1.0, pseudocount_1: float = 1.0, pseudocount_2: float = 1.0)`
+   - Computes bin values with `deeptools.getRatio.getRatio` semantics.
 
-- Install from PyPI:
-  pip install deeptools
+7. `smart_label(label: str)`
+   - Normalizes a label/path using `deeptools.utilities.smartLabel`.
 
-- Or install from source:
-  git clone https://github.com/deeptools/deepTools.git  
-  cd deepTools  
-  pip install -e .
+8. `convert_colormap(cmap_name: str = "viridis", vmin: float = 0.0, vmax: float = 1.0)`
+   - Converts a Matplotlib colormap into deepTools-compatible RGB stops.
 
-After install, verify:
-bamCoverage --help
+## Example Tool Calls
 
----
+### Health check
 
-## 3) Quick Start
+```json
+{
+  "tool": "health_check",
+  "arguments": {}
+}
+```
 
-### Typical MCP (Model Context Protocol) workflow
+### Compute ratio
 
-1. Create normalized tracks:
-- Run `bamCoverage` for each BAM.
-- Optionally run `bamCompare` for treatment/control ratio.
+```json
+{
+  "tool": "compute_ratio",
+  "arguments": {
+    "value1": 9.0,
+    "value2": 19.0,
+    "value_type": "ratio",
+    "scale_factor_1": 1.0,
+    "scale_factor_2": 1.0,
+    "pseudocount_1": 1.0,
+    "pseudocount_2": 1.0
+  }
+}
+```
 
-2. Build region-based matrix:
-- Run `computeMatrix` using bigWig signal + BED/GTF regions.
+### List symbols
 
-3. Visualize:
-- Run `plotHeatmap` and/or `plotProfile`.
+```json
+{
+  "tool": "list_symbols",
+  "arguments": {
+    "module_name": "deeptools.utilities",
+    "public_only": true,
+    "limit": 20
+  }
+}
+```
 
-4. Multi-sample QC:
-- Run `multiBamSummary` or `multiBigwigSummary`.
-- Then run `plotCorrelation` and `plotPCA`.
+## Local stdio run
 
-### Minimal command examples
+```bash
+cd deepTools/mcp_output
+python start_mcp.py
+```
 
-bamCoverage -b sample.bam -o sample.bw --normalizeUsing CPM  
-computeMatrix reference-point -S sample.bw -R genes.bed -o matrix.gz  
-plotHeatmap -m matrix.gz -out heatmap.png  
-plotProfile -m matrix.gz -out profile.png
+Or directly:
 
----
+```bash
+python mcp_plugin/main.py
+```
 
-## 4) Available Tools and Endpoints List
+## HTTP run
 
-Each MCP (Model Context Protocol) endpoint maps to one deepTools command:
+```bash
+cd deepTools/mcp_output
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
 
-- **bamCoverage**: Generate normalized coverage tracks from BAM.
-- **bamCompare**: Compare two BAMs (log2 ratio, subtraction, etc.).
-- **computeMatrix**: Build signal matrices around regions/reference points.
-- **computeMatrixOperations**: Filter/sort/subset/modify matrix files.
-- **plotHeatmap**: Render heatmaps from computed matrices.
-- **plotProfile**: Render aggregate profiles from matrices.
-- **multiBamSummary**: Summarize multiple BAMs into count matrices.
-- **multiBigwigSummary**: Summarize multiple bigWig files.
-- **plotCorrelation**: Correlation heatmap/scatter from summary matrices.
-- **plotPCA**: PCA visualization from summary outputs.
-- **plotCoverage**: Coverage QC summary plot across samples.
-- **plotFingerprint**: Enrichment/complexity QC fingerprint plot.
-- **plotEnrichment**: Feature-centric enrichment plotting.
-- **estimateReadFiltering**: Estimate effects of read filtering settings.
-- **alignmentSieve**: Filter/transform alignments by flags/fragment criteria.
-- **bigwigCompare**: Compare two bigWig tracks.
-- **bigwigAverage**: Average multiple bigWig tracks.
-- **computeGCBias**: Compute GC bias metrics.
-- **correctGCBias**: Apply GC bias correction.
-- **bamPEFragmentSize**: Estimate paired-end fragment size distributions.
-
----
-
-## 5) Common Issues and Notes
-
-- **Chromosome naming mismatch** (e.g., `chr1` vs `1`) is a frequent failure source.
-- **Input indexing required**:
-  - BAM files should be indexed (`.bai`).
-  - bigWig inputs must be valid and readable.
-- **Memory/CPU usage**:
-  - `computeMatrix`, summaries, and plotting can be heavy on large cohorts.
-  - Tune bin size, region count, and processor options for performance.
-- **Headless environments**:
-  - Ensure matplotlib backend works in server/CI contexts.
-- **Dependency issues**:
-  - `pysam`/`pyBigWig` build or binary compatibility may vary by OS.
-  - Prefer clean virtual environments.
-- **Output compatibility**:
-  - Keep deepTools versions consistent across matrix generation and plotting steps.
-
----
-
-## 6) Reference Links / Documentation
-
-- Main repository: https://github.com/deeptools/deepTools
-- Official docs: https://deeptools.readthedocs.io/
-- Package metadata/config: `pyproject.toml` in repo root
-- Changelog: `CHANGES.txt`
-- Contributing guide: `.github/CONTRIBUTING.md`
+The MCP HTTP endpoint is served at:
+
+`http://127.0.0.1:7860/mcp`

deepTools/mcp_output/mcp_plugin/adapter.py

@@ -1,280 +1,172 @@
-import os
-import sys
-import traceback
-import importlib
-import inspect
-from typing import Any, Dict, List, Optional, Tuple
-
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-sys.path.insert(0, source_path)
+from __future__ import annotations
 
+import importlib
+import pkgutil
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Any
 
-class Adapter:
-    """
-    Adapter for deepTools in import-first mode with graceful fallback to CLI execution.
+CURRENT_DIR = Path(__file__).resolve().parent
+SOURCE_DIR = CURRENT_DIR.parents[2] / "source"
+if str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
 
-    This adapter targets modules identified in the analysis:
-    - deeptools.bamCoverage
-    - deeptools.bamCompare
-    - deeptools.computeMatrix
-    - deeptools.computeMatrixOperations
-    - deeptools.plotHeatmap
-    - deeptools.plotProfile
-    - deeptools.multiBamSummary
-    - deeptools.multiBigwigSummary
-    - deeptools.plotCorrelation
-    - deeptools.plotPCA
-    - deeptools.plotCoverage
-    - deeptools.plotFingerprint
-    - deeptools.plotEnrichment
-    - deeptools.estimateReadFiltering
-    - deeptools.alignmentSieve
-    - deeptools.bigwigCompare
-    - deeptools.bigwigAverage
-    - deeptools.computeGCBias
-    - deeptools.correctGCBias
-    - deeptools.bamPEFragmentSize
-    """
+try:
+    import deeptools  # type: ignore
+except Exception:
+    deeptools = None
 
-    # -------------------------------------------------------------------------
-    # Initialization and module registry
-    # -------------------------------------------------------------------------
-    def __init__(self) -> None:
-        self.mode = "import"
-        self._modules: Dict[str, Dict[str, Any]] = {}
-        self._module_map: Dict[str, str] = {
-            "bamCoverage": "deeptools.bamCoverage",
-            "bamCompare": "deeptools.bamCompare",
-            "computeMatrix": "deeptools.computeMatrix",
-            "computeMatrixOperations": "deeptools.computeMatrixOperations",
-            "plotHeatmap": "deeptools.plotHeatmap",
-            "plotProfile": "deeptools.plotProfile",
-            "multiBamSummary": "deeptools.multiBamSummary",
-            "multiBigwigSummary": "deeptools.multiBigwigSummary",
-            "plotCorrelation": "deeptools.plotCorrelation",
-            "plotPCA": "deeptools.plotPCA",
-            "plotCoverage": "deeptools.plotCoverage",
-            "plotFingerprint": "deeptools.plotFingerprint",
-            "plotEnrichment": "deeptools.plotEnrichment",
-            "estimateReadFiltering": "deeptools.estimateReadFiltering",
-            "alignmentSieve": "deeptools.alignmentSieve",
-            "bigwigCompare": "deeptools.bigwigCompare",
-            "bigwigAverage": "deeptools.bigwigAverage",
-            "computeGCBias": "deeptools.computeGCBias",
-            "correctGCBias": "deeptools.correctGCBias",
-            "bamPEFragmentSize": "deeptools.bamPEFragmentSize",
-        }
-        self._load_all_modules()
 
-    def _result(
-        self,
-        status: str,
-        message: str,
-        data: Optional[Dict[str, Any]] = None,
-        error: Optional[str] = None,
-        guidance: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        return {
-            "status": status,
-            "mode": self.mode,
-            "message": message,
-            "data": data or {},
-            "error": error,
-            "guidance": guidance,
-        }
+class Adapter:
+    def __init__(self, package_name: str = "deeptools") -> None:
+        self.package_name = package_name
+        self.loaded_modules: dict[str, ModuleType] = {}
+        self.failed_modules: dict[str, str] = {}
+        self.mode = "normal"
+        self._load_modules()
+
+    def _result(self, status: str, **payload: Any) -> dict[str, Any]:
+        result: dict[str, Any] = {"status": status}
+        result.update(payload)
+        return result
+
+    def _load_modules(self) -> None:
+        self.loaded_modules.clear()
+        self.failed_modules.clear()
 
-    def _load_module(self, tool_name: str, module_path: str) -> None:
         try:
-            module = importlib.import_module(module_path)
-            self._modules[tool_name] = {
-                "imported": True,
-                "module": module,
-                "module_path": module_path,
-                "error": None,
-            }
-        except Exception as e:
-            self._modules[tool_name] = {
-                "imported": False,
-                "module": None,
-                "module_path": module_path,
-                "error": f"{type(e).__name__}: {e}",
-            }
-
-    def _load_all_modules(self) -> None:
-        for tool_name, module_path in self._module_map.items():
-            self._load_module(tool_name, module_path)
+            root_module = importlib.import_module(self.package_name)
+            self.loaded_modules[self.package_name] = root_module
+        except Exception as exc:
+            self.mode = "blackbox"
+            self.failed_modules[self.package_name] = f"{type(exc).__name__}: {exc}"
+            return
+
+        module_path = getattr(root_module, "__path__", None)
+        if not module_path:
+            self.mode = "normal"
+            return
+
+        for module_info in pkgutil.walk_packages(module_path, prefix=f"{self.package_name}."):
+            module_name = module_info.name
+            try:
+                mod = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = mod
+            except Exception as exc:
+                self.failed_modules[module_name] = f"{type(exc).__name__}: {exc}"
 
-    # -------------------------------------------------------------------------
-    # Introspection and health
-    # -------------------------------------------------------------------------
-    def health_check(self) -> Dict[str, Any]:
-        """
-        Report adapter and import readiness status.
+        self.mode = "normal" if self.loaded_modules else "blackbox"
 
-        Returns:
-            Unified status dictionary with per-module import state.
-        """
-        imported = {k: v["imported"] for k, v in self._modules.items()}
-        failed = {k: v["error"] for k, v in self._modules.items() if not v["imported"]}
-        status = "success" if all(imported.values()) else "partial_success"
-        message = (
-            "All modules imported successfully."
-            if status == "success"
-            else "Some modules failed to import. CLI fallback is available."
-        )
+    def health(self) -> dict[str, Any]:
+        if self.mode == "blackbox":
+            return self._result(
+                "fallback",
+                mode=self.mode,
+                package=self.package_name,
+                loaded_count=0,
+                failed_count=len(self.failed_modules),
+                message="No modules were loaded; adapter is in blackbox mode.",
+            )
         return self._result(
-            status=status,
-            message=message,
-            data={"imports": imported, "failed": failed},
-            guidance=(
-                "Verify local source tree under 'source/deeptools' and required dependencies "
-                "(numpy, scipy, matplotlib, pysam, pyBigWig)."
-                if failed
-                else None
-            ),
+            "ok",
+            mode=self.mode,
+            package=self.package_name,
+            loaded_count=len(self.loaded_modules),
+            failed_count=len(self.failed_modules),
         )
 
-    def list_tools(self) -> Dict[str, Any]:
-        """
-        List supported deepTools commands and their module paths.
-        """
-        data = []
-        for name, path in self._module_map.items():
-            meta = self._modules.get(name, {})
-            data.append(
-                {
-                    "tool": name,
-                    "module_path": path,
-                    "imported": meta.get("imported", False),
-                    "error": meta.get("error"),
-                }
+    def list_modules(self, include_failed: bool = True) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "mode": self.mode,
+            "loaded": sorted(self.loaded_modules.keys()),
+        }
+        if include_failed:
+            payload["failed"] = dict(sorted(self.failed_modules.items()))
+        status = "fallback" if self.mode == "blackbox" else "ok"
+        return self._result(status, **payload)
+
+    def list_symbols(self, module_name: str, public_only: bool = True, limit: int = 200) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return self._result("error", message=f"Module '{module_name}' is not loaded.")
+
+        symbols = dir(module)
+        if public_only:
+            symbols = [name for name in symbols if not name.startswith("_")]
+        return self._result("ok", module=module_name, symbols=sorted(symbols)[: max(1, limit)])
+
+    def call_function(
+        self,
+        module_name: str,
+        function_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return self._result("error", message=f"Module '{module_name}' is not loaded.")
+
+        target = getattr(module, function_name, None)
+        if target is None or not callable(target):
+            return self._result(
+                "error",
+                message=f"Function '{function_name}' not found in '{module_name}'.",
             )
-        return self._result(status="success", message="Supported tools listed.", data={"tools": data})
-
-    # -------------------------------------------------------------------------
-    # Core invocation helpers
-    # -------------------------------------------------------------------------
-    def _build_argv(self, kwargs: Dict[str, Any]) -> List[str]:
-        argv: List[str] = []
-        for key, value in kwargs.items():
-            if value is None:
-                continue
-            flag = f"--{key.replace('_', '-')}"
-            if isinstance(value, bool):
-                if value:
-                    argv.append(flag)
-            elif isinstance(value, (list, tuple)):
-                for item in value:
-                    argv.append(flag)
-                    argv.append(str(item))
-            else:
-                argv.append(flag)
-                argv.append(str(value))
-        return argv
 
-    def _find_callable(self, module: Any) -> Tuple[Optional[str], Optional[Any]]:
-        preferred = ["main", "run", "parseArguments", "process_args"]
-        for name in preferred:
-            fn = getattr(module, name, None)
-            if callable(fn):
-                return name, fn
-        for name, obj in inspect.getmembers(module):
-            if callable(obj) and name.lower() in {"main", "run"}:
-                return name, obj
-        return None, None
+        safe_args = args if args is not None else []
+        safe_kwargs = kwargs if kwargs is not None else {}
 
-    def _invoke_module(self, tool_name: str, **kwargs: Any) -> Dict[str, Any]:
-        meta = self._modules.get(tool_name)
-        if not meta:
+        try:
+            output = target(*safe_args, **safe_kwargs)
             return self._result(
-                status="error",
-                message=f"Unknown tool: {tool_name}.",
-                error="ToolNotRegistered",
-                guidance="Call list_tools() to view available tools.",
+                "ok",
+                module=module_name,
+                function=function_name,
+                result=output,
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                module=module_name,
+                function=function_name,
+                message=f"{type(exc).__name__}: {exc}",
             )
 
-        if meta["imported"] and meta["module"] is not None:
-            module = meta["module"]
-            fn_name, fn = self._find_callable(module)
-            if not fn:
-                return self._result(
-                    status="error",
-                    message=f"No callable entry point found for {tool_name}.",
-                    error="EntryPointNotFound",
-                    guidance="Inspect module for a callable main/run function or use CLI fallback.",
-                )
-            try:
-                argv = self._build_argv(kwargs)
-                try:
-                    result = fn(argv)
-                except TypeError:
-                    result = fn()
-                return self._result(
-                    status="success",
-                    message=f"{tool_name} executed via import mode.",
-                    data={
-                        "tool": tool_name,
-                        "module": meta["module_path"],
-                        "entry_point": fn_name,
-                        "argv": argv,
-                        "result": result,
-                    },
-                )
-            except SystemExit as e:
-                code = int(getattr(e, "code", 0) or 0)
-                if code == 0:
-                    return self._result(
-                        status="success",
-                        message=f"{tool_name} finished (SystemExit 0).",
-                        data={"tool": tool_name, "exit_code": code},
-                    )
-                return self._result(
-                    status="error",
-                    message=f"{tool_name} exited with non-zero status.",
-                    error=f"SystemExit({code})",
-                    guidance="Validate command arguments and input file paths.",
-                )
-            except Exception as e:
-                return self._result(
-                    status="error",
-                    message=f"{tool_name} failed during import-mode execution.",
-                    error=f"{type(e).__name__}: {e}",
-                    data={"traceback": traceback.format_exc()},
-                    guidance="Check argument names and values; verify required dependencies are installed.",
-                )
-
-        return self._result(
-            status="fallback",
-            message=f"{tool_name} import unavailable; CLI fallback suggested.",
-            error=meta.get("error"),
-            guidance=(
-                f"Run command-line tool '{tool_name}' directly in an environment where deepTools is installed, "
-                "or fix local imports under source/deeptools."
-            ),
-        )
-
-    # -------------------------------------------------------------------------
-    # Tool methods (one per identified command)
-    # -------------------------------------------------------------------------
-    def bamCoverage(self, **kwargs: Any) -> Dict[str, Any]:
-        """Execute deeptools.bamCoverage."""
-        return self._invoke_module("bamCoverage", **kwargs)
-
-    def bamCompare(self, **kwargs: Any) -> Dict[str, Any]:
-        """Execute deeptools.bamCompare."""
-        return self._invoke_module("bamCompare", **kwargs)
-
-    def computeMatrix(self, **kwargs: Any) -> Dict[str, Any]:
-        """Execute deeptools.computeMatrix."""
-        return self._invoke_module("computeMatrix", **kwargs)
+    def create_instance(
+        self,
+        module_name: str,
+        class_name: str,
+        init_args: list[Any] | None = None,
+        init_kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return self._result("error", message=f"Module '{module_name}' is not loaded.")
+
+        class_obj = getattr(module, class_name, None)
+        if class_obj is None:
+            return self._result(
+                "error",
+                message=f"Class '{class_name}' not found in '{module_name}'.",
+            )
 
-    def computeMatrixOperations(self, **kwargs: Any) -> Dict[str, Any]:
-        """Execute deeptools.computeMatrixOperations."""
-        return self._invoke_module("computeMatrixOperations", **kwargs)
+        safe_args = init_args if init_args is not None else []
+        safe_kwargs = init_kwargs if init_kwargs is not None else {}
 
-    def plotHeatmap(self, **kwargs: Any) -> Dict[str, Any]:
-        """Execute deeptools.plotHeatmap."""
-        return self._
+        try:
+            instance = class_obj(*safe_args, **safe_kwargs)
+            return self._result(
+                "ok",
+                module=module_name,
+                class_name=class_name,
+                instance_type=type(instance).__name__,
+                repr=repr(instance),
+            )
+        except Exception as exc:
+            return self._result(
+                "error",
+                module=module_name,
+                class_name=class_name,
+                message=f"{type(exc).__name__}: {exc}",
+            )

deepTools/mcp_output/mcp_plugin/main.py

@@ -1,13 +1,16 @@
-"""
-MCP Service Auto-Wrapper - Auto-generated
-"""
+from __future__ import annotations
+
 from mcp_service import create_app
 
-def main():
-    """Main entry point"""
+
+def main() -> None:
+    # Local stdio entry point only (Claude Desktop / CLI), not for web/Docker deployment.
     app = create_app()
-    return app
+    try:
+        app.run(transport="stdio")
+    except TypeError:
+        app.run()
+
 
 if __name__ == "__main__":
-    app = main()
-    app.run()
+    main()

deepTools/mcp_output/mcp_plugin/mcp_service.py

@@ -1,340 +1,302 @@
-import os
+from __future__ import annotations
+
+import importlib
+import json
 import sys
-from typing import Dict, Any, List, Optional
-
-source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
-
-from fastmcp import FastMCP
-
-from deeptools import (
-    bamCoverage,
-    bamCompare,
-    computeMatrix,
-    computeMatrixOperations,
-    plotHeatmap,
-    plotProfile,
-    multiBamSummary,
-    multiBigwigSummary,
-    plotCorrelation,
-    plotPCA,
-    plotCoverage,
-    plotFingerprint,
-    plotEnrichment,
-    estimateReadFiltering,
-    alignmentSieve,
-    bigwigCompare,
-    bigwigAverage,
-    computeGCBias,
-    correctGCBias,
-    bamPEFragmentSize,
+from pathlib import Path
+from typing import Any
+
+CURRENT_DIR = Path(__file__).resolve().parent
+SOURCE_DIR = CURRENT_DIR.parents[2] / "source"
+if str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
+
+try:
+    from fastmcp import FastMCP
+except Exception:
+    FastMCP = None
+
+try:
+    np = importlib.import_module("numpy")
+except Exception:
+    np = None
+
+try:
+    dt_utilities = importlib.import_module("deeptools.utilities")
+except Exception:
+    dt_utilities = None
+
+try:
+    dt_get_ratio = importlib.import_module("deeptools.getRatio")
+except Exception:
+    dt_get_ratio = None
+
+try:
+    matplotlib_mod = importlib.import_module("matplotlib")
+except Exception:
+    matplotlib_mod = None
+
+try:
+    dt_pkg = importlib.import_module("deeptools")
+except Exception:
+    dt_pkg = None
+
+try:
+    from .adapter import Adapter
+except Exception:
+    from adapter import Adapter
+
+
+class _FallbackMCP:
+    def __init__(self, name: str, description: str) -> None:
+        self.name = name
+        self.description = description
+        self.tools: list[Any] = []
+
+    def tool(self, name: str, description: str):
+        def decorator(func):
+            setattr(func, "name", name)
+            setattr(func, "description", description)
+            self.tools.append(func)
+            return func
+
+        return decorator
+
+    def run(self, transport: str = "stdio", host: str = "127.0.0.1", port: int = 8000) -> None:
+        raise RuntimeError("fastmcp is not installed. Install dependencies before running the MCP service.")
+
+
+mcp = (
+    FastMCP(name="deepTools-mcp", description="MCP wrapper for deepTools utilities and module introspection")
+    if FastMCP is not None
+    else _FallbackMCP(name="deepTools-mcp", description="MCP wrapper for deepTools utilities and module introspection")
 )
 
-mcp = FastMCP("deeptools_mcp_service")
-
-
-def _run_module_main(module: Any, argv: List[str]) -> Dict[str, Any]:
-    try:
-        old_argv = sys.argv[:]
-        sys.argv = [module.__name__.split(".")[-1]] + argv
-        if hasattr(module, "main"):
-            result = module.main()
-            return {"success": True, "result": result, "error": None}
-        return {"success": False, "result": None, "error": f"Module {module.__name__} has no main()"}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-    finally:
-        sys.argv = old_argv
-
-
-def _split_args(args: str) -> List[str]:
-    if not args.strip():
-        return []
-    return [a for a in args.strip().split(" ") if a]
-
-
-@mcp.tool(name="bam_coverage", description="Generate normalized coverage tracks from BAM files.")
-def bam_coverage(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools bamCoverage CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for bamCoverage.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(bamCoverage, _split_args(args))
-
-
-@mcp.tool(name="bam_compare", description="Compare two BAM files to produce ratio/difference tracks.")
-def bam_compare(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools bamCompare CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for bamCompare.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(bamCompare, _split_args(args))
-
-
-@mcp.tool(name="compute_matrix", description="Compute signal matrices around regions/reference points.")
-def compute_matrix(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools computeMatrix CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for computeMatrix.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(computeMatrix, _split_args(args))
-
-
-@mcp.tool(name="compute_matrix_operations", description="Perform operations on computed matrix files.")
-def compute_matrix_operations(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools computeMatrixOperations CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for computeMatrixOperations.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(computeMatrixOperations, _split_args(args))
-
-
-@mcp.tool(name="plot_heatmap", description="Render heatmaps from matrix files.")
-def plot_heatmap(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotHeatmap CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for plotHeatmap.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(plotHeatmap, _split_args(args))
-
-
-@mcp.tool(name="plot_profile", description="Render signal profiles from matrix files.")
-def plot_profile(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotProfile CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for plotProfile.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(plotProfile, _split_args(args))
-
-
-@mcp.tool(name="multi_bam_summary", description="Summarize multiple BAM files by bins/regions.")
-def multi_bam_summary(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools multiBamSummary CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for multiBamSummary.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(multiBamSummary, _split_args(args))
-
+adapter = Adapter(package_name="deeptools")
 
-@mcp.tool(name="multi_bigwig_summary", description="Summarize multiple bigWig files by bins/regions.")
-def multi_bigwig_summary(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools multiBigwigSummary CLI-compatible entrypoint.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for multiBigwigSummary.
+def _success(result: Any) -> dict[str, Any]:
+    return {"success": True, "result": result, "error": None}
 
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(multiBigwigSummary, _split_args(args))
 
+def _failure(error: str) -> dict[str, Any]:
+    return {"success": False, "result": None, "error": error}
 
-@mcp.tool(name="plot_correlation", description="Plot correlation heatmap/scatter from summary results.")
-def plot_correlation(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotCorrelation CLI-compatible entrypoint.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for plotCorrelation.
+def _parse_json_list(value: str) -> list[Any]:
+    parsed = json.loads(value)
+    if not isinstance(parsed, list):
+        raise ValueError("Expected a JSON list.")
+    return parsed
 
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(plotCorrelation, _split_args(args))
 
+def _parse_json_dict(value: str) -> dict[str, Any]:
+    parsed = json.loads(value)
+    if not isinstance(parsed, dict):
+        raise ValueError("Expected a JSON object.")
+    return parsed
 
-@mcp.tool(name="plot_pca", description="Plot PCA from summary matrix.")
-def plot_pca(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotPCA CLI-compatible entrypoint.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for plotPCA.
+@mcp.tool(name="health_check", description="Check MCP and deepTools dependency health")
+def health_check() -> dict[str, Any]:
+    """Return availability of runtime dependencies and adapter module loading status.
 
     Returns:
-    - Dict with success/result/error.
+        Standardized health payload with dependency booleans and adapter status.
     """
-    return _run_module_main(plotPCA, _split_args(args))
+    dependencies = {
+        "fastmcp": FastMCP is not None,
+        "numpy": np is not None,
+        "matplotlib": matplotlib_mod is not None,
+        "deeptools": dt_pkg is not None,
+        "deeptools.utilities": dt_utilities is not None,
+        "deeptools.getRatio": dt_get_ratio is not None,
+    }
+    return _success({"dependencies": dependencies, "adapter": adapter.health()})
 
 
-@mcp.tool(name="plot_coverage", description="Coverage QC visualization over sample sets.")
-def plot_coverage(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotCoverage CLI-compatible entrypoint.
+@mcp.tool(name="list_modules", description="List importable deeptools modules")
+def list_modules(include_failed: bool = True) -> dict[str, Any]:
+    """List modules discovered by the adapter.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for plotCoverage.
+    Args:
+        include_failed: Whether to include module import failures.
 
     Returns:
-    - Dict with success/result/error.
+        Loaded module names plus optional failure details.
     """
-    return _run_module_main(plotCoverage, _split_args(args))
+    return _success(adapter.list_modules(include_failed=include_failed))
 
 
-@mcp.tool(name="plot_fingerprint", description="ChIP/ATAC enrichment and complexity QC fingerprint plotting.")
-def plot_fingerprint(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotFingerprint CLI-compatible entrypoint.
+@mcp.tool(name="list_symbols", description="List symbols from an imported deeptools module")
+def list_symbols(module_name: str, public_only: bool = True, limit: int = 100) -> dict[str, Any]:
+    """List symbols exposed by one loaded module.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for plotFingerprint.
+    Args:
+        module_name: Fully qualified module name, for example ``deeptools.utilities``.
+        public_only: If true, hide symbols prefixed with underscore.
+        limit: Maximum symbol count returned.
 
     Returns:
-    - Dict with success/result/error.
+        Symbol list and metadata.
     """
-    return _run_module_main(plotFingerprint, _split_args(args))
+    data = adapter.list_symbols(module_name=module_name, public_only=public_only, limit=limit)
+    if data.get("status") == "error":
+        return _failure(str(data.get("message", "Unable to list symbols.")))
+    return _success(data)
 
 
-@mcp.tool(name="plot_enrichment", description="Feature-centric enrichment plotting.")
-def plot_enrichment(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools plotEnrichment CLI-compatible entrypoint.
+@mcp.tool(name="call_function", description="Call a function from a loaded deeptools module")
+def call_function(module_name: str, function_name: str, args_json: str = "[]", kwargs_json: str = "{}") -> dict[str, Any]:
+    """Call a module-level function from an imported deeptools module.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for plotEnrichment.
+    Args:
+        module_name: Fully qualified module name.
+        function_name: Function symbol to execute.
+        args_json: JSON-encoded list of positional arguments.
+        kwargs_json: JSON-encoded object of keyword arguments.
 
     Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(plotEnrichment, _split_args(args))
-
-
-@mcp.tool(name="estimate_read_filtering", description="Estimate read filtering effects under selected criteria.")
-def estimate_read_filtering(args: str) -> Dict[str, Any]:
+        Function call result, or an error payload.
     """
-    Run deepTools estimateReadFiltering CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for estimateReadFiltering.
+    try:
+        args = _parse_json_list(args_json)
+        kwargs = _parse_json_dict(kwargs_json)
+    except Exception as exc:
+        return _failure(f"Invalid JSON arguments: {type(exc).__name__}: {exc}")
+
+    data = adapter.call_function(
+        module_name=module_name,
+        function_name=function_name,
+        args=args,
+        kwargs=kwargs,
+    )
+    if data.get("status") == "error":
+        return _failure(str(data.get("message", "Function call failed.")))
+    return _success(data)
+
+
+@mcp.tool(name="create_instance", description="Instantiate a class from a loaded deeptools module")
+def create_instance(module_name: str, class_name: str, init_args_json: str = "[]", init_kwargs_json: str = "{}") -> dict[str, Any]:
+    """Create a class instance from an imported deeptools module.
+
+    Args:
+        module_name: Fully qualified module name.
+        class_name: Class symbol to instantiate.
+        init_args_json: JSON-encoded list of positional constructor arguments.
+        init_kwargs_json: JSON-encoded object of keyword constructor arguments.
 
     Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(estimateReadFiltering, _split_args(args))
-
-
-@mcp.tool(name="alignment_sieve", description="Filter and transform alignments based on flags/fragment criteria.")
-def alignment_sieve(args: str) -> Dict[str, Any]:
+        Instance metadata or a standardized error.
     """
-    Run deepTools alignmentSieve CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for alignmentSieve.
+    try:
+        init_args = _parse_json_list(init_args_json)
+        init_kwargs = _parse_json_dict(init_kwargs_json)
+    except Exception as exc:
+        return _failure(f"Invalid JSON constructor args: {type(exc).__name__}: {exc}")
+
+    data = adapter.create_instance(
+        module_name=module_name,
+        class_name=class_name,
+        init_args=init_args,
+        init_kwargs=init_kwargs,
+    )
+    if data.get("status") == "error":
+        return _failure(str(data.get("message", "Class creation failed.")))
+    return _success(data)
+
+
+@mcp.tool(name="compute_ratio", description="Compute deeptools ratio-style bin value")
+def compute_ratio(
+    value1: float,
+    value2: float,
+    value_type: str = "ratio",
+    scale_factor_1: float = 1.0,
+    scale_factor_2: float = 1.0,
+    pseudocount_1: float = 1.0,
+    pseudocount_2: float = 1.0,
+) -> dict[str, Any]:
+    """Compute a ratio-like bin value using ``deeptools.getRatio.getRatio`` semantics.
+
+    Args:
+        value1: Coverage value for sample 1.
+        value2: Coverage value for sample 2.
+        value_type: One of ``ratio``, ``log2``, ``reciprocal_ratio``, ``subtract``, ``add``, ``first``, ``second``, ``mean``.
+        scale_factor_1: Scaling factor for value1.
+        scale_factor_2: Scaling factor for value2.
+        pseudocount_1: Pseudocount added to sample 1 for ratio-like modes.
+        pseudocount_2: Pseudocount added to sample 2 for ratio-like modes.
 
     Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(alignmentSieve, _split_args(args))
-
-
-@mcp.tool(name="bigwig_compare", description="Compare two bigWig tracks.")
-def bigwig_compare_tool(args: str) -> Dict[str, Any]:
+        Computed numeric value.
     """
-    Run deepTools bigwigCompare CLI-compatible entrypoint.
+    if dt_get_ratio is None:
+        return _failure("deeptools.getRatio is unavailable.")
 
-    Parameters:
-    - args: Space-delimited command-line arguments for bigwigCompare.
+    func = getattr(dt_get_ratio, "getRatio", None)
+    if func is None:
+        return _failure("getRatio function is not available in deeptools.getRatio.")
 
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(bigwigCompare, _split_args(args))
+    try:
+        args = {
+            "valueType": value_type,
+            "scaleFactors": (float(scale_factor_1), float(scale_factor_2)),
+            "pseudocount": [float(pseudocount_1), float(pseudocount_2)],
+        }
+        output = func([float(value1), float(value2)], args)
+        return _success({"value": output})
+    except Exception as exc:
+        return _failure(f"Failed to compute ratio: {type(exc).__name__}: {exc}")
 
 
-@mcp.tool(name="bigwig_average", description="Average multiple bigWig tracks.")
-def bigwig_average_tool(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools bigwigAverage CLI-compatible entrypoint.
+@mcp.tool(name="smart_label", description="Create a normalized label from file path")
+def smart_label(label: str) -> dict[str, Any]:
+    """Normalize one label by removing path and first file extension.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for bigwigAverage.
+    Args:
+        label: Raw file path or label string.
 
     Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(bigwigAverage, _split_args(args))
-
-
-@mcp.tool(name="compute_gc_bias", description="Compute GC bias metrics.")
-def compute_gc_bias(args: str) -> Dict[str, Any]:
+        Normalized label.
     """
-    Run deepTools computeGCBias CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for computeGCBias.
+    if dt_utilities is None:
+        return _failure("deeptools.utilities is unavailable.")
+    func = getattr(dt_utilities, "smartLabel", None)
+    if func is None:
+        return _failure("smartLabel function is not available in deeptools.utilities.")
 
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(computeGCBias, _split_args(args))
+    try:
+        return _success({"label": func(label)})
+    except Exception as exc:
+        return _failure(f"Failed to normalize label: {type(exc).__name__}: {exc}")
 
 
-@mcp.tool(name="correct_gc_bias", description="Apply GC bias correction.")
-def correct_gc_bias(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools correctGCBias CLI-compatible entrypoint.
+@mcp.tool(name="convert_colormap", description="Convert matplotlib colormap to deeptools RGB scale")
+def convert_colormap(cmap_name: str = "viridis", vmin: float = 0.0, vmax: float = 1.0) -> dict[str, Any]:
+    """Convert a matplotlib colormap into deepTools-compatible RGB scale values.
 
-    Parameters:
-    - args: Space-delimited command-line arguments for correctGCBias.
+    Args:
+        cmap_name: Matplotlib colormap name.
+        vmin: Minimum normalization value.
+        vmax: Maximum normalization value.
 
     Returns:
-    - Dict with success/result/error.
+        List of normalized rgb stop definitions.
     """
-    return _run_module_main(correctGCBias, _split_args(args))
-
+    if dt_utilities is None:
+        return _failure("deeptools.utilities is unavailable.")
+    func = getattr(dt_utilities, "convertCmap", None)
+    if func is None:
+        return _failure("convertCmap function is not available in deeptools.utilities.")
 
-@mcp.tool(name="bam_pe_fragment_size", description="Estimate paired-end fragment-size distributions.")
-def bam_pe_fragment_size(args: str) -> Dict[str, Any]:
-    """
-    Run deepTools bamPEFragmentSize CLI-compatible entrypoint.
-
-    Parameters:
-    - args: Space-delimited command-line arguments for bamPEFragmentSize.
-
-    Returns:
-    - Dict with success/result/error.
-    """
-    return _run_module_main(bamPEFragmentSize, _split_args(args))
+    try:
+        result = func(cmap_name, vmin=float(vmin), vmax=float(vmax))
+        return _success({"colormap": cmap_name, "scale": result})
+    except Exception as exc:
+        return _failure(f"Failed to convert colormap: {type(exc).__name__}: {exc}")
 
 
-def create_app() -> FastMCP:
+def create_app() -> Any:
     return mcp
 
 

deepTools/mcp_output/requirements.txt

@@ -1,13 +1,5 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-numpy >= 2.0.0
-scipy >= 0.17.0
-matplotlib >= 3.5.0
-pysam >= 0.14.0
-numpydoc >= 0.5
-pyBigWig >= 0.2.1
-py2bit >= 0.2.0
-plotly >= 4.9
-deeptoolsintervals >= 0.1.8
+deeptools
+deeptoolsintervals
+numpy
+matplotlib

deepTools/mcp_output/start_mcp.py

@@ -1,30 +1,38 @@
+from __future__ import annotations
 
-"""
-MCP Service Startup Entry
-"""
-import sys
 import os
+import sys
+from pathlib import Path
 
-project_root = os.path.dirname(os.path.abspath(__file__))
-mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
-if mcp_plugin_dir not in sys.path:
-    sys.path.insert(0, mcp_plugin_dir)
+CURRENT_DIR = Path(__file__).resolve().parent
+PLUGIN_DIR = CURRENT_DIR / "mcp_plugin"
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
 
 from mcp_service import create_app
 
-def main():
-    """Start FastMCP service"""
+
+def main() -> None:
+    transport = os.getenv("MCP_TRANSPORT", "stdio").strip().lower()
+    port = int(os.getenv("MCP_PORT", "8000"))
     app = create_app()
-    # Use environment variable to configure port, default 8000
-    port = int(os.environ.get("MCP_PORT", "8000"))
-    
-    # Choose transport mode based on environment variable
-    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+
+    if transport == "stdio":
+        try:
+            app.run(transport="stdio")
+        except TypeError:
+            app.run()
+        return
+
     if transport == "http":
-        app.run(transport="http", host="0.0.0.0", port=port)
-    else:
-        # Default to STDIO mode
-        app.run()
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port, path="/mcp")
+        except TypeError:
+            app.run(transport="http", host="0.0.0.0", port=port)
+        return
+
+    raise ValueError(f"Unsupported MCP_TRANSPORT='{transport}'. Use 'stdio' or 'http'.")
+
 
 if __name__ == "__main__":
-    main()
+    main()

port.json

@@ -1,5 +1 @@
-{
-  "repo": "deepTools",
-  "port": 7963,
-  "timestamp": 1773293952
-}
+{"port": 7860}

requirements.txt

@@ -1,13 +1,7 @@
 fastmcp
+deeptools
+deeptoolsintervals
+numpy
+matplotlib
 fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-numpy >= 2.0.0
-scipy >= 0.17.0
-matplotlib >= 3.5.0
-pysam >= 0.14.0
-numpydoc >= 0.5
-pyBigWig >= 0.2.1
-py2bit >= 0.2.0
-plotly >= 4.9
-deeptoolsintervals >= 0.1.8
+uvicorn

run_docker.ps1

@@ -1,26 +1,8 @@
-cd $PSScriptRoot
 $ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "deepTools" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7963/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "deepTools-mcp" }
-$mcpDir = Join-Path $env:USERPROFILE ".cursor"
-$mcpPath = Join-Path $mcpDir "mcp.json"
-if (!(Test-Path $mcpDir)) { New-Item -ItemType Directory -Path $mcpDir | Out-Null }
-$config = @{}
-if (Test-Path $mcpPath) {
-  try { $config = Get-Content $mcpPath -Raw | ConvertFrom-Json } catch { $config = @{} }
-}
-$serversOrdered = [ordered]@{}
-if ($config -and ($config.PSObject.Properties.Name -contains "mcpServers") -and $config.mcpServers) {
-  $existing = $config.mcpServers
-  if ($existing -is [pscustomobject]) {
-    foreach ($p in $existing.PSObject.Properties) { if ($p.Name -ne $entryName) { $serversOrdered[$p.Name] = $p.Value } }
-  } elseif ($existing -is [System.Collections.IDictionary]) {
-    foreach ($k in $existing.Keys) { if ($k -ne $entryName) { $serversOrdered[$k] = $existing[$k] } }
-  }
-}
-$serversOrdered[$entryName] = @{ url = $entryUrl }
-$config = @{ mcpServers = $serversOrdered }
-$config | ConvertTo-Json -Depth 10 | Set-Content -Path $mcpPath -Encoding UTF8
+
+$portConfig = Get-Content -Raw -Path "port.json" | ConvertFrom-Json
+$port = [int]$portConfig.port
+$imageName = "deepTools-mcp"
+
 docker build -t $imageName .
-docker run --rm -p 7963:7860 $imageName
+docker run --rm -it -p "${port}:${port}" $imageName

run_docker.sh

@@ -1,75 +1,8 @@
 #!/usr/bin/env bash
 set -euo pipefail
-cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
-mcp_entry_name="${MCP_ENTRY_NAME:-deepTools}"
-mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7963/mcp}"
-mcp_dir="${HOME}/.cursor"
-mcp_path="${mcp_dir}/mcp.json"
-mkdir -p "${mcp_dir}"
-if command -v python3 >/dev/null 2>&1; then
-python3 - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
-import json, os, sys
-path, name, url = sys.argv[1:4]
-cfg = {"mcpServers": {}}
-if os.path.exists(path):
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
-    except Exception:
-        cfg = {"mcpServers": {}}
-if not isinstance(cfg, dict):
-    cfg = {"mcpServers": {}}
-servers = cfg.get("mcpServers")
-if not isinstance(servers, dict):
-    servers = {}
-ordered = {}
-for k, v in servers.items():
-    if k != name:
-        ordered[k] = v
-ordered[name] = {"url": url}
-cfg = {"mcpServers": ordered}
-with open(path, "w", encoding="utf-8") as f:
-    json.dump(cfg, f, indent=2, ensure_ascii=False)
-PY
-elif command -v python >/dev/null 2>&1; then
-python - "${mcp_path}" "${mcp_entry_name}" "${mcp_entry_url}" <<'PY'
-import json, os, sys
-path, name, url = sys.argv[1:4]
-cfg = {"mcpServers": {}}
-if os.path.exists(path):
-    try:
-        with open(path, "r", encoding="utf-8") as f:
-            cfg = json.load(f)
-    except Exception:
-        cfg = {"mcpServers": {}}
-if not isinstance(cfg, dict):
-    cfg = {"mcpServers": {}}
-servers = cfg.get("mcpServers")
-if not isinstance(servers, dict):
-    servers = {}
-ordered = {}
-for k, v in servers.items():
-    if k != name:
-        ordered[k] = v
-ordered[name] = {"url": url}
-cfg = {"mcpServers": ordered}
-with open(path, "w", encoding="utf-8") as f:
-    json.dump(cfg, f, indent=2, ensure_ascii=False)
-PY
-elif command -v jq >/dev/null 2>&1; then
-  name="${mcp_entry_name}"; url="${mcp_entry_url}"
-  if [ -f "${mcp_path}" ]; then
-    tmp="$(mktemp)"
-    jq --arg name "$name" --arg url "$url" '
-      .mcpServers = (.mcpServers // {})
-      | .mcpServers as $s
-      | ($s | with_entries(select(.key != $name))) as $base
-      | .mcpServers = ($base + {($name): {"url": $url}})
-    ' "${mcp_path}" > "${tmp}" && mv "${tmp}" "${mcp_path}"
-  else
-    printf '{ "mcpServers": { "%s": { "url": "%s" } } }
-' "$name" "$url" > "${mcp_path}"
-  fi
-fi
-docker build -t deepTools-mcp .
-docker run --rm -p 7963:7860 deepTools-mcp
+
+PORT=$(python3 -c "import json; print(json.load(open('port.json'))['port'])")
+IMAGE_NAME="deepTools-mcp"
+
+docker build -t "${IMAGE_NAME}" .
+docker run --rm -it -p "${PORT}:${PORT}" "${IMAGE_NAME}"