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 \
+    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 medpy /app/medpy
+COPY app.py /app/app.py
 
-COPY --chown=user . /app
 ENV MCP_TRANSPORT=http
 ENV MCP_PORT=7860
 
 EXPOSE 7860
 
+USER appuser
+
 CMD ["python", "medpy/mcp_output/start_mcp.py"]

README.md

@@ -1,10 +1,65 @@
 ---
-title: Medpy
-emoji: 🏢
-colorFrom: green
+title: medpy 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
+# medpy MCP Service
+
+This deployment package exposes MedPy medical-image processing capabilities through FastMCP.
+It supports local stdio usage (Claude Desktop / CLI) and HTTP transport for Docker/HuggingFace Spaces.
+
+## Available tools
+
+- `health_check` — dependency and adapter status
+- `list_modules` — list loaded MedPy modules
+- `list_symbols` — inspect public module symbols
+- `image_info` — inspect shape/dtype/spacing from an image
+- `anisotropic_diffusion` — denoise and save image
+- `otsu_segmentation` — threshold and save binary mask
+- `compute_overlap_metrics` — Dice/Jaccard/Precision/Recall
+- `bounding_box` — non-zero mask bounding box
+
+## Local stdio usage
+
+Run from the deployment root:
+
+```bash
+cd medpy/mcp_output
+export MCP_TRANSPORT=stdio
+python start_mcp.py
+```
+
+Or:
+
+```bash
+python medpy/mcp_output/mcp_plugin/main.py
+```
+
+## HTTP usage (Docker / HF Spaces)
+
+Docker entrypoint runs:
+
+```bash
+python medpy/mcp_output/start_mcp.py
+```
+
+with environment:
+
+- `MCP_TRANSPORT=http`
+- `MCP_PORT=7860`
+
+The MCP HTTP endpoint is available at:
+
+- `https://<host>/mcp`
+
+## Build and run with scripts
+
+- Bash: `./run_docker.sh`
+- PowerShell: `./run_docker.ps1`
+
+Both scripts read port mapping from `port.json` (fixed to `7860` for HF Spaces compatibility).

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, Dict, List
+
+from fastapi import FastAPI
+
+PLUGIN_DIR = Path(__file__).resolve().parent / "medpy" / "mcp_output" / "mcp_plugin"
+if PLUGIN_DIR.exists():
+    plugin_str = str(PLUGIN_DIR)
+    if plugin_str not in sys.path:
+        sys.path.insert(0, plugin_str)
+
+PORT = int(os.getenv("PORT", "7860"))
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "medpy", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+app = FastAPI(title="medpy-mcp-info", version="1.0.0")
 
-app = FastAPI(
-    title="Medpy MCP Service",
-    description="Auto-generated MCP service for medpy",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def root() -> Dict[str, Any]:
     return {
-        "service": "Medpy MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "name": "medpy MCP service",
+        "description": "Supplementary info app for local development.",
+        "mcp_entrypoint": "medpy/mcp_output/start_mcp.py",
+        "default_port": PORT,
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "medpy 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)}"}
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+def tools() -> Dict[str, List[Dict[str, Any]]]:
+    from mcp_service import create_app
+
+    mcp = create_app()
+    tools_obj = getattr(mcp, "tools", None)
+    output: List[Dict[str, Any]] = []
+
+    if isinstance(tools_obj, dict):
+        for name, tool in tools_obj.items():
+            description = getattr(tool, "description", "")
+            output.append({"name": str(name), "description": str(description)})
+    elif isinstance(tools_obj, list):
+        for tool in tools_obj:
+            name = getattr(tool, "name", getattr(tool, "__name__", "unknown"))
+            description = getattr(tool, "description", "")
+            output.append({"name": str(name), "description": str(description)})
+
+    output.sort(key=lambda x: x["name"])
+    return {"tools": output}

medpy/mcp_output/README_MCP.md

@@ -1,154 +1,153 @@
-# MedPy MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This MCP (Model Context Protocol) service wraps core capabilities from **[medpy](https://github.com/loli/medpy)** for medical image processing workflows.
-
-It is designed for developers who need programmatic access to:
-
-- Medical image I/O (load/save + metadata)
-- Filtering and preprocessing (resampling, smoothing, morphology)
-- Feature extraction (intensity, histogram, texture)
-- Segmentation utilities (watershed, graph-cut workflows)
-- Evaluation metrics (Dice, Hausdorff, ASD/ASSD, etc.)
-
-Repository analyzed: `loli/medpy` (Python package with CLI tools and test coverage).
-
----
-
-## 2) Installation Method
-
-### Requirements
-
-- Python 3.8+ recommended
-- Required:
-  - `numpy`
-  - `scipy`
-- Optional (depending on formats/features used):
-  - `SimpleITK`
-  - `pydicom`
-  - `nibabel`
-  - `networkx`
-  - `maxflow` / `pymaxflow`
-
-### Install commands
-
-- Install MedPy:
-  - `pip install medpy`
-- Or install from source:
-  - `git clone https://github.com/loli/medpy.git`
-  - `cd medpy`
-  - `pip install .`
-
-If graph-cut functionality is required, ensure a compatible maxflow backend is installed.
-
----
-
-## 3) Quick Start
-
-### Python API style usage
-
-- Load image:
-  - `medpy.io.load(path)` → `(array, header)`
-- Save image:
-  - `medpy.io.save(array, output_path, hdr=header)`
-- Resample image:
-  - `medpy.filter.image.resample(img, hdr, target_spacing, bspline_order=3, mode='nearest')`
-- Metrics:
-  - `medpy.metric.binary.dc(result, reference)` (Dice)
-  - `medpy.metric.binary.hd95(result, reference, voxelspacing=..., connectivity=1)`
-
-### CLI-style workflow examples (service-wrapped)
-
-- Inspect metadata: `medpy_info`
-- Convert image format: `medpy_convert`
-- Compare volumes: `medpy_diff`
-- Resample volume: `medpy_resample`
-- Anisotropic diffusion: `medpy_anisotropic_diffusion`
-- Watershed segmentation: `medpy_watershed`
-- Graph-cut segmentation: `medpy_graphcut_voxel`, `medpy_graphcut_label`
-
-In MCP (Model Context Protocol) deployments, these are typically exposed as service endpoints/tools rather than raw shell commands.
-
----
-
-## 4) Available Tools and Endpoints List
-
-Recommended MCP (Model Context Protocol) service endpoints:
-
-- `image_info`
-  - Backed by: `medpy_info`
-  - Returns shape, spacing, datatype, header metadata summary.
-
-- `image_convert`
-  - Backed by: `medpy_convert`
-  - Converts between supported medical image formats.
-
-- `image_diff`
-  - Backed by: `medpy_diff`
-  - Computes/report differences between two images.
-
-- `image_resample`
-  - Backed by: `medpy_resample` / `medpy.filter.image.resample`
-  - Resamples to target voxel spacing or geometry.
-
-- `anisotropic_diffusion`
-  - Backed by: `medpy_anisotropic_diffusion` / `medpy.filter.smoothing.anisotropic_diffusion`
-  - Noise reduction with edge-preserving smoothing.
-
-- `watershed_segment`
-  - Backed by: `medpy_watershed`
-  - Watershed-based segmentation pipeline.
-
-- `graphcut_voxel_segment`
-  - Backed by: `medpy_graphcut_voxel`
-  - Voxel-level graph-cut segmentation.
-
-- `graphcut_label_segment`
-  - Backed by: `medpy_graphcut_label`
-  - Label-based graph-cut segmentation.
-
-- `segmentation_metrics`
-  - Backed by: `medpy.metric.binary`
-  - Dice, Jaccard, Hausdorff, ASD/ASSD, sensitivity/specificity.
-
-- `feature_extraction`
-  - Backed by: `medpy.features.intensity|histogram|texture`
-  - Computes handcrafted radiomics-style feature vectors.
-
----
-
-## 5) Common Issues and Notes
-
-- **Optional dependency gaps**  
-  Some image formats require `SimpleITK`, `pydicom`, or `nibabel`. Missing backends can cause load/save errors.
-
-- **Graph-cut setup**  
-  Graph-cut tools may fail without `maxflow/pymaxflow` and compatible compiled components.
-
-- **Metadata consistency**  
-  When resampling/saving, preserve and validate header spacing/origin metadata (`medpy.io.header` helpers).
-
-- **Large volume performance**  
-  3D/4D processing can be memory-intensive. Prefer chunk/patch workflows where possible.
-
-- **Input assumptions**  
-  Many metric functions assume binary masks and aligned geometry. Always verify shape, spacing, and orientation before evaluation.
-
-- **Import feasibility**  
-  Analysis indicates good integration feasibility (~0.84) with low intrusiveness and medium complexity.
-
----
-
-## 6) Reference Links / Documentation
-
-- Main repository: https://github.com/loli/medpy
-- Package docs/readme (in repo): `README.md`, `README_PYPI.md`
-- Tests for usage patterns: `tests/`
-- CLI scripts: `bin/`
-- Core modules:
-  - `medpy.io`
-  - `medpy.filter`
-  - `medpy.features`
-  - `medpy.metric`
-  - `medpy.graphcut`
+# MedPy MCP Plugin
+
+This MCP layer wraps core MedPy medical-image processing capabilities.
+
+## Exposed Tools
+
+### 1) `health_check`
+- **Parameters**: none
+- **Description**: Reports dependency availability and adapter module-load status.
+- **Example**:
+```json
+{"tool":"health_check","arguments":{}}
+```
+
+### 2) `list_modules`
+- **Parameters**: none
+- **Description**: Lists successfully loaded MedPy modules and failed imports.
+- **Example**:
+```json
+{"tool":"list_modules","arguments":{}}
+```
+
+### 3) `list_symbols`
+- **Parameters**:
+  - `module_name` (string): Fully qualified module path, e.g. `medpy.filter`.
+- **Example**:
+```json
+{"tool":"list_symbols","arguments":{"module_name":"medpy.metric"}}
+```
+
+### 4) `image_info`
+- **Parameters**:
+  - `image_path` (string): Path to image file or DICOM directory.
+- **Returns**: shape, dtype, min/max/mean, voxel spacing, and offset.
+- **Example**:
+```json
+{"tool":"image_info","arguments":{"image_path":"./data/brain.nii.gz"}}
+```
+
+### 5) `anisotropic_diffusion`
+- **Parameters**:
+  - `input_path` (string)
+  - `output_path` (string)
+  - `niter` (int, default `5`)
+  - `kappa` (float, default `30.0`)
+  - `gamma` (float, default `0.1`)
+  - `option` (int, one of `1|2|3`, default `1`)
+  - `use_compression` (bool, default `false`)
+- **Example**:
+```json
+{
+  "tool":"anisotropic_diffusion",
+  "arguments":{
+    "input_path":"./data/input.nii.gz",
+    "output_path":"./data/denoised.nii.gz",
+    "niter":8,
+    "kappa":40.0,
+    "gamma":0.1,
+    "option":1
+  }
+}
+```
+
+### 6) `otsu_segmentation`
+- **Parameters**:
+  - `input_path` (string)
+  - `output_mask_path` (string)
+  - `bins` (int, default `64`)
+  - `keep_largest_component` (bool, default `true`)
+  - `use_compression` (bool, default `false`)
+- **Example**:
+```json
+{
+  "tool":"otsu_segmentation",
+  "arguments":{
+    "input_path":"./data/input.nii.gz",
+    "output_mask_path":"./data/mask.nii.gz",
+    "bins":64,
+    "keep_largest_component":true
+  }
+}
+```
+
+### 7) `compute_overlap_metrics`
+- **Parameters**:
+  - `result_mask_path` (string)
+  - `reference_mask_path` (string)
+- **Returns**: `dice`, `jaccard`, `precision`, `recall`.
+- **Example**:
+```json
+{
+  "tool":"compute_overlap_metrics",
+  "arguments":{
+    "result_mask_path":"./data/pred.nii.gz",
+    "reference_mask_path":"./data/gt.nii.gz"
+  }
+}
+```
+
+### 8) `bounding_box`
+- **Parameters**:
+  - `mask_path` (string)
+- **Returns**: axis-aligned bounding box as start/stop pairs.
+- **Example**:
+```json
+{"tool":"bounding_box","arguments":{"mask_path":"./data/mask.nii.gz"}}
+```
+
+## Standard Tool Response
+All tools return:
+
+```json
+{
+  "success": true,
+  "result": {},
+  "error": null
+}
+```
+
+On error:
+
+```json
+{
+  "success": false,
+  "result": null,
+  "error": "message"
+}
+```
+
+## Run Locally (stdio)
+
+From `mcp_output`:
+
+```bash
+export MCP_TRANSPORT=stdio
+python start_mcp.py
+```
+
+Or directly:
+
+```bash
+python mcp_plugin/main.py
+```
+
+## Run via HTTP transport
+
+```bash
+export MCP_TRANSPORT=http
+export MCP_PORT=8000
+python start_mcp.py
+```
+
+MCP HTTP endpoint is served by FastMCP at `/mcp`.

medpy/mcp_output/mcp_plugin/adapter.py

@@ -1,312 +1,205 @@
-import os
-import sys
-import traceback
+from __future__ import annotations
+
 import importlib
-from typing import Any, Dict, List, Optional, Tuple
+import inspect
+import pkgutil
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
-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)
+SOURCE_DIR = Path(__file__).resolve().parents[2] / "source"
+if SOURCE_DIR.exists():
+    source_str = str(SOURCE_DIR)
+    if source_str not in sys.path:
+        sys.path.insert(0, source_str)
 
 
 class Adapter:
-    """
-    MCP import-mode adapter for the medpy repository.
+    def __init__(self, base_package: str = "medpy") -> None:
+        self.base_package = base_package
+        self.loaded_modules: Dict[str, Any] = {}
+        self.failed_modules: Dict[str, str] = {}
+        self.mode = "ready"
+        self._bootstrap()
+
+    def _bootstrap(self) -> None:
+        root = self._safe_import(self.base_package)
+        if root is None:
+            self.mode = "blackbox"
+            return
+
+        self.loaded_modules[self.base_package] = root
+        package_path = getattr(root, "__path__", None)
+        if package_path is None:
+            self.mode = "ready"
+            return
+
+        for module_info in pkgutil.walk_packages(package_path, prefix=f"{self.base_package}."):
+            self._safe_import(module_info.name)
+
+        if len(self.loaded_modules) <= 1:
+            self.mode = "fallback"
+
+    def _safe_import(self, module_name: str) -> Optional[Any]:
+        try:
+            module = importlib.import_module(module_name)
+            self.loaded_modules[module_name] = module
+            return module
+        except Exception as exc:  # pragma: no cover
+            self.failed_modules[module_name] = str(exc)
+            return None
 
-    This adapter prioritizes direct Python imports from the local `source` tree and
-    gracefully falls back to a CLI-guidance mode when imports or runtime calls fail.
-    All public methods return a unified dictionary format with at least:
-      - status: "success" | "error" | "fallback"
-      - mode: "import" | "cli"
-      - data / error / guidance fields where relevant
-    """
+    def health(self) -> Dict[str, Any]:
+        if not self.loaded_modules:
+            return {
+                "status": "fallback",
+                "mode": "blackbox",
+                "base_package": self.base_package,
+                "loaded_count": 0,
+                "failed_count": len(self.failed_modules),
+                "failed_modules": self.failed_modules,
+                "source_dir": str(SOURCE_DIR),
+            }
+
+        status = "ok"
+        if self.mode in {"blackbox", "fallback"}:
+            status = "fallback"
+
+        return {
+            "status": status,
+            "mode": self.mode,
+            "base_package": self.base_package,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+            "loaded_modules": sorted(self.loaded_modules.keys()),
+            "failed_modules": self.failed_modules,
+            "source_dir": str(SOURCE_DIR),
+        }
 
-    # -------------------------------------------------------------------------
-    # Initialization and module management
-    # -------------------------------------------------------------------------
+    def list_modules(self) -> Dict[str, Any]:
+        if not self.loaded_modules:
+            return {
+                "status": "fallback",
+                "mode": "blackbox",
+                "modules": [],
+                "failed_modules": self.failed_modules,
+            }
+
+        return {
+            "status": "ok",
+            "mode": self.mode,
+            "modules": sorted(self.loaded_modules.keys()),
+            "failed_modules": self.failed_modules,
+        }
 
-    def __init__(self) -> None:
-        self.mode = "import"
-        self._modules: Dict[str, Any] = {}
-        self._imports: Dict[str, Any] = {}
-        self._import_errors: Dict[str, str] = {}
-        self._load_modules()
+    def list_symbols(self, module_name: str) -> Dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            module = self._safe_import(module_name)
+
+        if module is None:
+            return {
+                "status": "error",
+                "message": f"Module not available: {module_name}",
+                "failed_modules": self.failed_modules,
+            }
+
+        symbols: List[Dict[str, str]] = []
+        for name, value in inspect.getmembers(module):
+            if name.startswith("_"):
+                continue
+            if inspect.isclass(value):
+                sym_type = "class"
+            elif inspect.isfunction(value) or inspect.isbuiltin(value):
+                sym_type = "function"
+            elif inspect.ismodule(value):
+                sym_type = "module"
+            else:
+                sym_type = "value"
+            symbols.append({"name": name, "type": sym_type})
+
+        return {
+            "status": "ok",
+            "module": module_name,
+            "symbol_count": len(symbols),
+            "symbols": symbols,
+        }
 
-    def _result(
+    def call_function(
         self,
-        status: str,
-        data: Optional[Dict[str, Any]] = None,
-        error: Optional[str] = None,
-        guidance: Optional[str] = None,
-        details: Optional[Dict[str, Any]] = None,
+        module_name: str,
+        function_name: str,
+        args: Optional[List[Any]] = None,
+        kwargs: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
-        payload: Dict[str, Any] = {"status": status, "mode": self.mode}
-        if data is not None:
-            payload["data"] = data
-        if error is not None:
-            payload["error"] = error
-        if guidance is not None:
-            payload["guidance"] = guidance
-        if details is not None:
-            payload["details"] = details
-        return payload
-
-    def _load_modules(self) -> None:
-        targets = {
-            "setup": "setup",
-            "bin.medpy_reslice_3d_to_4d": "bin.medpy_reslice_3d_to_4d",
-            "bin.medpy_extract_min_max": "bin.medpy_extract_min_max",
-            "bin.medpy_convert": "bin.medpy_convert",
-        }
-        for key, path in targets.items():
-            try:
-                self._modules[key] = importlib.import_module(path)
-            except Exception as exc:
-                self._import_errors[key] = f"{type(exc).__name__}: {exc}"
-
-        self._bind_imports()
-        if self._import_errors:
-            self.mode = "cli"
-
-    def _bind_imports(self) -> None:
-        # setup.py symbols
-        setup_mod = self._modules.get("setup")
-        if setup_mod is not None:
-            for symbol in ["read", "run_setup", "try_find_library", "BuildFailed", "ve_build_ext"]:
-                if hasattr(setup_mod, symbol):
-                    self._imports[f"setup.{symbol}"] = getattr(setup_mod, symbol)
-
-        # bin/medpy_reslice_3d_to_4d.py symbols
-        r_mod = self._modules.get("bin.medpy_reslice_3d_to_4d")
-        if r_mod is not None:
-            for symbol in ["getArguments", "getParser", "main"]:
-                if hasattr(r_mod, symbol):
-                    self._imports[f"bin.medpy_reslice_3d_to_4d.{symbol}"] = getattr(r_mod, symbol)
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            module = self._safe_import(module_name)
+        if module is None:
+            return {"status": "error", "message": f"Module not available: {module_name}"}
+
+        function_obj = getattr(module, function_name, None)
+        if function_obj is None or not callable(function_obj):
+            return {
+                "status": "error",
+                "message": f"Function not found or not callable: {module_name}.{function_name}",
+            }
+
+        call_args = args if args is not None else []
+        call_kwargs = kwargs if kwargs is not None else {}
 
-        # bin/medpy_extract_min_max.py symbols
-        emm = self._modules.get("bin.medpy_extract_min_max")
-        if emm is not None:
-            for symbol in ["getArguments", "getParser", "main"]:
-                if hasattr(emm, symbol):
-                    self._imports[f"bin.medpy_extract_min_max.{symbol}"] = getattr(emm, symbol)
-
-        # bin/medpy_convert.py symbols
-        c_mod = self._modules.get("bin.medpy_convert")
-        if c_mod is not None and hasattr(c_mod, "getArguments"):
-            self._imports["bin.medpy_convert.getArguments"] = getattr(c_mod, "getArguments")
-
-    def health(self) -> Dict[str, Any]:
-        """
-        Report adapter readiness and import status.
-
-        Returns:
-            Dict with status, mode, imported modules, available symbols, and import errors.
-        """
-        return self._result(
-            status="success" if not self._import_errors else "fallback",
-            data={
-                "imported_modules": sorted(self._modules.keys()),
-                "available_symbols": sorted(self._imports.keys()),
-                "import_errors": self._import_errors,
-            },
-            guidance=(
-                "Import mode fully available."
-                if not self._import_errors
-                else "Some imports failed. Use CLI commands as fallback."
-            ),
-        )
-
-    # -------------------------------------------------------------------------
-    # Utility execution wrappers
-    # -------------------------------------------------------------------------
-
-    def _call(self, key: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        func = self._imports.get(key)
-        if func is None:
-            return self._result(
-                status="fallback",
-                error=f"Function '{key}' is not available in import mode.",
-                guidance="Verify source checkout and dependencies, or run the corresponding CLI command.",
-                details={"import_errors": self._import_errors},
-            )
         try:
-            value = func(*args, **kwargs)
-            return self._result(status="success", data={"result": value, "callable": key})
+            result = function_obj(*call_args, **call_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "function": function_name,
+                "result": result,
+            }
         except Exception as exc:
-            return self._result(
-                status="error",
-                error=f"{type(exc).__name__}: {exc}",
-                guidance="Check input arguments and required runtime dependencies (e.g., numpy/scipy).",
-                details={"traceback": traceback.format_exc(), "callable": key},
-            )
-
-    # -------------------------------------------------------------------------
-    # setup.py classes and functions
-    # -------------------------------------------------------------------------
-
-    def create_build_failed(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create an instance of setup.BuildFailed.
-
-        Parameters:
-            *args, **kwargs: Forwarded to BuildFailed constructor.
-
-        Returns:
-            Unified status dictionary with the created instance in data.result.
-        """
-        cls = self._imports.get("setup.BuildFailed")
-        if cls is None:
-            return self._result(
-                status="fallback",
-                error="Class 'setup.BuildFailed' is not available.",
-                guidance="Ensure setup.py can be imported from source.",
-                details={"import_errors": self._import_errors},
-            )
-        try:
-            obj = cls(*args, **kwargs)
-            return self._result(status="success", data={"result": obj, "class": "setup.BuildFailed"})
-        except Exception as exc:
-            return self._result(
-                status="error",
-                error=f"{type(exc).__name__}: {exc}",
-                guidance="Review constructor arguments for BuildFailed.",
-                details={"traceback": traceback.format_exc()},
-            )
-
-    def create_ve_build_ext(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create an instance of setup.ve_build_ext.
-
-        Parameters:
-            *args, **kwargs: Forwarded to ve_build_ext constructor.
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "message": str(exc),
+            }
+
+    def create_instance(
+        self,
+        module_name: str,
+        class_name: str,
+        args: Optional[List[Any]] = None,
+        kwargs: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            module = self._safe_import(module_name)
+        if module is None:
+            return {"status": "error", "message": f"Module not available: {module_name}"}
+
+        class_obj = getattr(module, class_name, None)
+        if class_obj is None or not inspect.isclass(class_obj):
+            return {
+                "status": "error",
+                "message": f"Class not found: {module_name}.{class_name}",
+            }
+
+        init_args = args if args is not None else []
+        init_kwargs = kwargs if kwargs is not None else {}
 
-        Returns:
-            Unified status dictionary with the created instance in data.result.
-        """
-        cls = self._imports.get("setup.ve_build_ext")
-        if cls is None:
-            return self._result(
-                status="fallback",
-                error="Class 'setup.ve_build_ext' is not available.",
-                guidance="Ensure setuptools extension build class is importable from setup.py.",
-                details={"import_errors": self._import_errors},
-            )
         try:
-            obj = cls(*args, **kwargs)
-            return self._result(status="success", data={"result": obj, "class": "setup.ve_build_ext"})
+            instance = class_obj(*init_args, **init_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "class": class_name,
+                "instance_type": type(instance).__name__,
+                "instance_repr": repr(instance),
+            }
         except Exception as exc:
-            return self._result(
-                status="error",
-                error=f"{type(exc).__name__}: {exc}",
-                guidance="Pass a valid setuptools Distribution object and expected parameters.",
-                details={"traceback": traceback.format_exc()},
-            )
-
-    def call_setup_read(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """Call setup.read(*args, **kwargs)."""
-        return self._call("setup.read", *args, **kwargs)
-
-    def call_setup_run_setup(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """Call setup.run_setup(*args, **kwargs)."""
-        return self._call("setup.run_setup", *args, **kwargs)
-
-    def call_setup_try_find_library(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """Call setup.try_find_library(*args, **kwargs)."""
-        return self._call("setup.try_find_library", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # bin.medpy_reslice_3d_to_4d functions
-    # -------------------------------------------------------------------------
-
-    def call_medpy_reslice_3d_to_4d_get_arguments(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_reslice_3d_to_4d.getArguments.
-
-        Typically parses CLI-like arguments for reslicing 3D volumes into 4D.
-        """
-        return self._call("bin.medpy_reslice_3d_to_4d.getArguments", *args, **kwargs)
-
-    def call_medpy_reslice_3d_to_4d_get_parser(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_reslice_3d_to_4d.getParser.
-
-        Returns parser object used by the script.
-        """
-        return self._call("bin.medpy_reslice_3d_to_4d.getParser", *args, **kwargs)
-
-    def call_medpy_reslice_3d_to_4d_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_reslice_3d_to_4d.main.
-
-        Executes the script main flow in import mode.
-        """
-        return self._call("bin.medpy_reslice_3d_to_4d.main", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # bin.medpy_extract_min_max functions
-    # -------------------------------------------------------------------------
-
-    def call_medpy_extract_min_max_get_arguments(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_extract_min_max.getArguments.
-
-        Typically parses arguments for min/max extraction from medical volumes.
-        """
-        return self._call("bin.medpy_extract_min_max.getArguments", *args, **kwargs)
-
-    def call_medpy_extract_min_max_get_parser(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_extract_min_max.getParser.
-
-        Returns parser object used by the script.
-        """
-        return self._call("bin.medpy_extract_min_max.getParser", *args, **kwargs)
-
-    def call_medpy_extract_min_max_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_extract_min_max.main.
-
-        Executes min/max extraction script logic.
-        """
-        return self._call("bin.medpy_extract_min_max.main", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # bin.medpy_convert functions
-    # -------------------------------------------------------------------------
-
-    def call_medpy_convert_get_arguments(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call bin.medpy_convert.getArguments.
-
-        Parses conversion CLI arguments for supported medical image formats.
-        """
-        return self._call("bin.medpy_convert.getArguments", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # CLI fallback guidance (from analysis-reported commands)
-    # -------------------------------------------------------------------------
-
-    def cli_fallback_commands(self) -> Dict[str, Any]:
-        """
-        Provide curated CLI fallback commands detected by analysis.
-
-        Returns:
-            Unified dictionary with command list and descriptions.
-        """
-        commands: List[Dict[str, str]] = [
-            {"name": "medpy_info", "module": "bin/medpy_info.py", "description": "Inspect image metadata and dimensional information."},
-            {"name": "medpy_convert", "module": "bin/medpy_convert.py", "description": "Convert medical image volumes between supported formats."},
-            {"name": "medpy_diff", "module": "bin/medpy_diff.py", "description": "Compare two images/volumes and report differences."},
-            {"name": "medpy_resample", "module": "bin/medpy_resample.py", "description": "Resample image volume to target spacing/shape."},
-            {"name": "medpy_anisotropic_diffusion", "module": "bin/medpy_anisotropic_diffusion.py", "description": "Apply anisotropic diffusion filtering to a volume."},
-            {"name": "medpy_watershed", "module": "bin/medpy_watershed.py", "description": "Run watershed segmentation on image data."},
-            {"name": "medpy_graphcut_voxel", "module": "bin/medpy_graphcut_voxel.py", "description": "Voxel-level graph-cut segmentation CLI workflow."},
-            {"name": "medpy_graphcut_label", "module": "bin/medpy_graphcut_label.py", "description": "Label-based graph-cut segmentation CLI workflow."},
-        ]
-        return self._result(
-            status="success",
-            data={"commands": commands},
-            guidance="If import calls fail, run these commands from the project environment where medpy dependencies are installed.",
-        )
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "message": str(exc),
+            }

medpy/mcp_output/mcp_plugin/main.py

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

medpy/mcp_output/mcp_plugin/mcp_service.py

@@ -1,207 +1,343 @@
+from __future__ import annotations
+
 import os
 import sys
+from pathlib import Path
+from typing import Any, Dict, List
 
-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)
+SOURCE_DIR = Path(__file__).resolve().parents[2] / "source"
+if SOURCE_DIR.exists():
+    source_str = str(SOURCE_DIR)
+    if source_str not in sys.path:
+        sys.path.insert(0, source_str)
 
-from fastmcp import FastMCP
+try:
+    import numpy as np
+except Exception:  # pragma: no cover
+    np = None
 
-from setup import run_setup, read, ve_build_ext, try_find_library, BuildFailed
-from bin.medpy_reslice_3d_to_4d import main, getArguments, getParser
-from bin.medpy_extract_min_max import main, getArguments, getParser
-from bin.medpy_convert import getArguments
+try:
+    import medpy.io as medpy_io
+except Exception:  # pragma: no cover
+    medpy_io = None
 
-mcp = FastMCP("unknown_service")
+try:
+    import medpy.filter as medpy_filter
+except Exception:  # pragma: no cover
+    medpy_filter = None
 
+try:
+    import medpy.metric as medpy_metric
+except Exception:  # pragma: no cover
+    medpy_metric = None
 
-@mcp.tool(name="read", description="Auto-wrapped function read")
-def read(payload: dict):
-    try:
-        if read is None:
-            return {"success": False, "result": None, "error": "Function read is not available"}
-        result = read(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="run_setup", description="Auto-wrapped function run_setup")
-def run_setup(payload: dict):
-    try:
-        if run_setup is None:
-            return {"success": False, "result": None, "error": "Function run_setup is not available"}
-        result = run_setup(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="try_find_library", description="Auto-wrapped function try_find_library")
-def try_find_library(payload: dict):
-    try:
-        if try_find_library is None:
-            return {"success": False, "result": None, "error": "Function try_find_library is not available"}
-        result = try_find_library(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="buildfailed", description="BuildFailed class")
-def buildfailed(*args, **kwargs):
-    """BuildFailed class"""
-    try:
-        if BuildFailed is None:
-            return {"success": False, "result": None, "error": "Class BuildFailed is not available, path may need adjustment"}
-        
-        # MCP parameter type conversion
-        converted_args = []
-        converted_kwargs = kwargs.copy()
-        
-        # Handle position argument type conversion
-        for arg in args:
-            if isinstance(arg, str):
-                # Try to convert to numeric type
-                try:
-                    if '.' in arg:
-                        converted_args.append(float(arg))
-                    else:
-                        converted_args.append(int(arg))
-                except ValueError:
-                    converted_args.append(arg)
-            else:
-                converted_args.append(arg)
-        
-        # Handle keyword argument type conversion
-        for key, value in converted_kwargs.items():
-            if isinstance(value, str):
-                try:
-                    if '.' in value:
-                        converted_kwargs[key] = float(value)
-                    else:
-                        converted_kwargs[key] = int(value)
-                except ValueError:
-                    pass
-        
-        instance = BuildFailed(*converted_args, **converted_kwargs)
-        return {"success": True, "result": str(instance), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="ve_build_ext", description="ve_build_ext class")
-def ve_build_ext(*args, **kwargs):
-    """ve_build_ext class"""
-    try:
-        if ve_build_ext is None:
-            return {"success": False, "result": None, "error": "Class ve_build_ext is not available, path may need adjustment"}
-        
-        # MCP parameter type conversion
-        converted_args = []
-        converted_kwargs = kwargs.copy()
-        
-        # Handle position argument type conversion
-        for arg in args:
-            if isinstance(arg, str):
-                # Try to convert to numeric type
-                try:
-                    if '.' in arg:
-                        converted_args.append(float(arg))
-                    else:
-                        converted_args.append(int(arg))
-                except ValueError:
-                    converted_args.append(arg)
-            else:
-                converted_args.append(arg)
-        
-        # Handle keyword argument type conversion
-        for key, value in converted_kwargs.items():
-            if isinstance(value, str):
-                try:
-                    if '.' in value:
-                        converted_kwargs[key] = float(value)
-                    else:
-                        converted_kwargs[key] = int(value)
-                except ValueError:
-                    pass
-        
-        instance = ve_build_ext(*converted_args, **converted_kwargs)
-        return {"success": True, "result": str(instance), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="getArguments", description="Auto-wrapped function getArguments")
-def getArguments(payload: dict):
+try:
+    from fastmcp import FastMCP
+except Exception:  # pragma: no cover
+    FastMCP = None
+
+from .adapter import Adapter
+
+
+class _FallbackMCP:
+    def tool(self, name: str, description: str):
+        def _decorator(func):
+            return func
+
+        return _decorator
+
+    def run(self, *args, **kwargs):
+        raise RuntimeError("fastmcp is not available. Please install dependencies.")
+
+
+mcp = FastMCP(name="medpy-mcp-service") if FastMCP is not None else _FallbackMCP()
+adapter = Adapter(base_package="medpy")
+
+
+def _ok(result: Any) -> Dict[str, Any]:
+    return {"success": True, "result": result, "error": None}
+
+
+def _err(message: str) -> Dict[str, Any]:
+    return {"success": False, "result": None, "error": message}
+
+
+def _load_image(path: str):
+    if medpy_io is None:
+        raise RuntimeError("medpy.io is unavailable")
+    return medpy_io.load(path)
+
+
+def _save_image(array: Any, path: str, header: Any = None, use_compression: bool = False) -> None:
+    if medpy_io is None:
+        raise RuntimeError("medpy.io is unavailable")
+    medpy_io.save(array, path, hdr=header if header is not None else False, force=True, use_compression=use_compression)
+
+
+@mcp.tool(name="health_check", description="Check MCP and MedPy dependency availability.")
+def health_check() -> Dict[str, Any]:
+    """Return runtime health status and dependency availability."""
+    deps = {
+        "fastmcp": FastMCP is not None,
+        "numpy": np is not None,
+        "medpy.io": medpy_io is not None,
+        "medpy.filter": medpy_filter is not None,
+        "medpy.metric": medpy_metric is not None,
+        "source_dir": str(SOURCE_DIR),
+        "source_dir_exists": SOURCE_DIR.exists(),
+    }
+    return _ok({"dependencies": deps, "adapter": adapter.health()})
+
+
+@mcp.tool(name="list_modules", description="List loaded MedPy modules and failed imports.")
+def list_modules() -> Dict[str, Any]:
+    """List module loading details from the adapter."""
     try:
-        if getArguments is None:
-            return {"success": False, "result": None, "error": "Function getArguments is not available"}
-        result = getArguments(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="getParser", description="Auto-wrapped function getParser")
-def getParser(payload: dict):
+        return _ok(adapter.list_modules())
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="list_symbols", description="List public symbols from a MedPy module.")
+def list_symbols(module_name: str) -> Dict[str, Any]:
+    """
+    List public members of the given module.
+
+    Parameters
+    ----------
+    module_name : str
+        Fully qualified module path, for example 'medpy.filter' or 'medpy.metric.binary'.
+    """
     try:
-        if getParser is None:
-            return {"success": False, "result": None, "error": "Function getParser is not available"}
-        result = getParser(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="main", description="Auto-wrapped function main")
-def main(payload: dict):
+        return _ok(adapter.list_symbols(module_name))
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="image_info", description="Load an image and return shape, dtype, and metadata summary.")
+def image_info(image_path: str) -> Dict[str, Any]:
+    """
+    Inspect an image file using MedPy I/O.
+
+    Parameters
+    ----------
+    image_path : str
+        Path to an image file or DICOM directory.
+    """
     try:
-        if main is None:
-            return {"success": False, "result": None, "error": "Function main is not available"}
-        result = main(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="getArguments", description="Auto-wrapped function getArguments")
-def getArguments(payload: dict):
+        image, header = _load_image(image_path)
+        spacing = None
+        offset = None
+        if medpy_io is not None:
+            spacing = medpy_io.get_voxel_spacing(header)
+            offset = medpy_io.get_offset(header)
+
+        info = {
+            "path": image_path,
+            "shape": list(image.shape),
+            "dtype": str(image.dtype),
+            "min": float(image.min()),
+            "max": float(image.max()),
+            "mean": float(image.mean()),
+            "voxel_spacing": list(spacing) if spacing is not None else None,
+            "offset": list(offset) if offset is not None else None,
+        }
+        return _ok(info)
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="anisotropic_diffusion", description="Apply anisotropic diffusion denoising and save output image.")
+def anisotropic_diffusion(
+    input_path: str,
+    output_path: str,
+    niter: int = 5,
+    kappa: float = 30.0,
+    gamma: float = 0.1,
+    option: int = 1,
+    use_compression: bool = False,
+) -> Dict[str, Any]:
+    """
+    Denoise an image with MedPy anisotropic diffusion.
+
+    Parameters
+    ----------
+    input_path : str
+        Input image path.
+    output_path : str
+        Output image path.
+    niter : int
+        Number of diffusion iterations.
+    kappa : float
+        Conduction coefficient.
+    gamma : float
+        Diffusion step size, usually <= 0.25.
+    option : int
+        Diffusion mode: 1, 2, or 3.
+    use_compression : bool
+        Whether to request compressed output where supported.
+    """
     try:
-        if getArguments is None:
-            return {"success": False, "result": None, "error": "Function getArguments is not available"}
-        result = getArguments(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="getParser", description="Auto-wrapped function getParser")
-def getParser(payload: dict):
+        if medpy_filter is None:
+            return _err("medpy.filter is unavailable")
+
+        image, header = _load_image(input_path)
+        output = medpy_filter.anisotropic_diffusion(
+            image,
+            niter=int(niter),
+            kappa=float(kappa),
+            gamma=float(gamma),
+            option=int(option),
+        )
+        _save_image(output, output_path, header=header, use_compression=use_compression)
+        return _ok(
+            {
+                "input_path": input_path,
+                "output_path": output_path,
+                "shape": list(output.shape),
+                "dtype": str(output.dtype),
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="otsu_segmentation", description="Compute Otsu threshold, generate binary mask, and save it.")
+def otsu_segmentation(
+    input_path: str,
+    output_mask_path: str,
+    bins: int = 64,
+    keep_largest_component: bool = True,
+    use_compression: bool = False,
+) -> Dict[str, Any]:
+    """
+    Segment foreground using Otsu thresholding.
+
+    Parameters
+    ----------
+    input_path : str
+        Input image path.
+    output_mask_path : str
+        Output binary mask path.
+    bins : int
+        Histogram bin count used by Otsu algorithm.
+    keep_largest_component : bool
+        If true, keep only the largest connected foreground component.
+    use_compression : bool
+        Whether to request compressed output where supported.
+    """
     try:
-        if getParser is None:
-            return {"success": False, "result": None, "error": "Function getParser is not available"}
-        result = getParser(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="main", description="Auto-wrapped function main")
-def main(payload: dict):
+        if medpy_filter is None:
+            return _err("medpy.filter is unavailable")
+        if np is None:
+            return _err("numpy is unavailable")
+
+        image, header = _load_image(input_path)
+        threshold = float(medpy_filter.otsu(image, bins=int(bins)))
+        mask = image >= threshold
+
+        if keep_largest_component:
+            mask = medpy_filter.largest_connected_component(mask)
+
+        mask_to_save = np.asarray(mask, dtype=np.uint8)
+        _save_image(mask_to_save, output_mask_path, header=header, use_compression=use_compression)
+        return _ok(
+            {
+                "input_path": input_path,
+                "output_mask_path": output_mask_path,
+                "threshold": threshold,
+                "foreground_voxels": int(np.count_nonzero(mask)),
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="compute_overlap_metrics", description="Compute Dice/Jaccard/Precision/Recall between two masks.")
+def compute_overlap_metrics(result_mask_path: str, reference_mask_path: str) -> Dict[str, Any]:
+    """
+    Evaluate overlap metrics for two binary masks.
+
+    Parameters
+    ----------
+    result_mask_path : str
+        Path to predicted or result mask.
+    reference_mask_path : str
+        Path to ground-truth or reference mask.
+    """
     try:
-        if main is None:
-            return {"success": False, "result": None, "error": "Function main is not available"}
-        result = main(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="getArguments", description="Auto-wrapped function getArguments")
-def getArguments(payload: dict):
+        if medpy_metric is None:
+            return _err("medpy.metric is unavailable")
+        if np is None:
+            return _err("numpy is unavailable")
+
+        result, _ = _load_image(result_mask_path)
+        reference, _ = _load_image(reference_mask_path)
+
+        result_bin = np.asarray(result != 0)
+        reference_bin = np.asarray(reference != 0)
+
+        if result_bin.shape != reference_bin.shape:
+            return _err(
+                f"Mask shapes do not match: {result_bin.shape} vs {reference_bin.shape}"
+            )
+
+        metrics = {
+            "dice": float(medpy_metric.dc(result_bin, reference_bin)),
+            "jaccard": float(medpy_metric.jc(result_bin, reference_bin)),
+            "precision": float(medpy_metric.precision(result_bin, reference_bin)),
+            "recall": float(medpy_metric.recall(result_bin, reference_bin)),
+        }
+        return _ok(metrics)
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="bounding_box", description="Compute bounding box slices for non-zero voxels in a mask.")
+def bounding_box(mask_path: str) -> Dict[str, Any]:
+    """
+    Return an axis-aligned bounding box around non-zero voxels.
+
+    Parameters
+    ----------
+    mask_path : str
+        Input mask image path.
+    """
     try:
-        if getArguments is None:
-            return {"success": False, "result": None, "error": "Function getArguments is not available"}
-        result = getArguments(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        if medpy_filter is None:
+            return _err("medpy.filter is unavailable")
+        if np is None:
+            return _err("numpy is unavailable")
 
+        mask, _ = _load_image(mask_path)
+        mask_bin = np.asarray(mask != 0)
+        if not np.any(mask_bin):
+            return _ok({"bbox": [], "message": "mask is empty"})
+
+        bbox = medpy_filter.bounding_box(mask_bin)
+        result: List[Dict[str, int]] = []
+        for idx, item in enumerate(bbox):
+            result.append({"axis": idx, "start": int(item.start), "stop": int(item.stop)})
+
+        return _ok({"bbox": result})
+    except Exception as exc:
+        return _err(str(exc))
 
 
 def create_app():
-    """Create and return FastMCP application instance"""
     return mcp
 
+
 if __name__ == "__main__":
-    mcp.run(transport="http", host="0.0.0.0", port=8000)
+    transport = os.getenv("MCP_TRANSPORT", "stdio").lower()
+    port = int(os.getenv("MCP_PORT", "8000"))
+    if transport == "http":
+        try:
+            mcp.run(transport="http", host="0.0.0.0", port=port)
+        except TypeError:
+            mcp.run()
+    else:
+        try:
+            mcp.run(transport="stdio")
+        except TypeError:
+            mcp.run()

medpy/mcp_output/requirements.txt

@@ -1,7 +1,5 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-scipy >= 1.10
-numpy >= 1.24
-SimpleITK >= 2.1
+medpy
+numpy>=1.24
+scipy>=1.10
+SimpleITK>=2.1

medpy/mcp_output/start_mcp.py

@@ -1,30 +1,35 @@
+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)
+PLUGIN_DIR = Path(__file__).resolve().parent / "mcp_plugin"
+if PLUGIN_DIR.exists():
+    plugin_str = str(PLUGIN_DIR)
+    if plugin_str not in sys.path:
+        sys.path.insert(0, plugin_str)
 
 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 == "http":
-        app.run(transport="http", host="0.0.0.0", port=port)
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port)
+        except TypeError:
+            app.run()
     else:
-        # Default to STDIO mode
-        app.run()
+        try:
+            app.run(transport="stdio")
+        except TypeError:
+            app.run()
+
 
 if __name__ == "__main__":
     main()

port.json

@@ -1,5 +1 @@
-{
-  "repo": "medpy",
-  "port": 7898,
-  "timestamp": 1773273469
-}
+{"port": 7860}

requirements.txt

@@ -1,7 +1,7 @@
 fastmcp
+medpy
+numpy>=1.24
+scipy>=1.10
+SimpleITK>=2.1
 fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-scipy >= 1.10
-numpy >= 1.24
-SimpleITK >= 2.1
+uvicorn

run_docker.ps1

@@ -1,26 +1,7 @@
-cd $PSScriptRoot
 $ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "medpy" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7898/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "medpy-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
+
+$port = (Get-Content -Raw -Path "port.json" | ConvertFrom-Json).port
+$imageName = "medpy-mcp"
+
 docker build -t $imageName .
-docker run --rm -p 7898: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:-medpy}"
-mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7898/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 medpy-mcp .
-docker run --rm -p 7898:7860 medpy-mcp
+
+PORT=$(python3 -c 'import json; print(json.load(open("port.json", "r", encoding="utf-8"))["port"])')
+IMAGE_NAME="medpy-mcp"
+
+docker build -t "$IMAGE_NAME" .
+docker run --rm -it -p "${PORT}:${PORT}" "$IMAGE_NAME"