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

MONAI/mcp_output/README_MCP.md

@@ -1,145 +1,151 @@
-# MONAI MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This MCP (Model Context Protocol) service exposes practical, high-level MONAI capabilities for medical imaging workflows, with a focus on:
-
-- Bundle-based workflow execution (train/infer/evaluate from config)
-- Config parsing and validation
-- Sliding-window inference for large 2D/3D images
-- Optional access to model/dataset pipeline primitives (networks, transforms, datasets)
-
-Best-fit usage: integrating MONAI automation into LLM-driven developer tooling with minimal custom glue code.
-
----
-
-## 2) Installation Method
-
-### Requirements
-
-- Python >= 3.9
-- Core:
-  - torch
-  - numpy
-  - monai
-- Common optional dependencies (based on your workflow):
-  - nibabel, SimpleITK, pydicom, itk
-  - scipy, pillow, scikit-image
-  - ignite
-  - mlflow, tensorboard
-  - opencv-python, cucim, zarr, einops
-
-### Install (minimal)
-
-pip install monai torch numpy
-
-### Install (typical medical imaging stack)
-
-pip install monai[all]
-
-If your environment does not resolve extras reliably, install optional packages explicitly per feature needs.
-
----
-
-## 3) Quick Start
-
-### A. Run a MONAI bundle workflow
-
-Use the Bundle orchestration layer as the primary MCP (Model Context Protocol) surface:
-
-- `monai.bundle.scripts.run(...)`
-- `monai.bundle.scripts.verify_metadata(...)`
-- `monai.bundle.scripts.verify_net_in_out(...)`
-- `monai.bundle.scripts.download(...)`
-- `monai.bundle.scripts.init_bundle(...)`
-
-Typical MCP (Model Context Protocol) flow:
-1. Download/init bundle
-2. Parse/resolve config
-3. Verify metadata/network I/O
-4. Run train/infer command
-
-### B. Parse and inspect config safely
-
-Use `monai.bundle.config_parser.ConfigParser` and:
-- `load_config_file(...)`
-- `parse(...)`
-- `get_parsed_content(...)`
-
-This is the recommended path for declarative, controlled config access from tools/services.
-
-### C. Sliding-window inference
-
-For large volumes/WSI-style inputs:
-- `monai.inferers.inferer.sliding_window_inference(...)`
-- Or class-based inferers: `SlidingWindowInferer`, `SimpleInferer`
-
----
-
-## 4) Available Tools and Endpoints List
-
-Suggested MCP (Model Context Protocol) endpoints for a practical service layer:
-
-1. `bundle.run`
-- Execute a MONAI bundle workflow from config overrides.
-- Backend: `monai.bundle.scripts.run`
-
-2. `bundle.verify_metadata`
-- Validate bundle metadata schema/compliance.
-- Backend: `monai.bundle.scripts.verify_metadata`
-
-3. `bundle.verify_net_io`
-- Check model input/output shape and compatibility.
-- Backend: `monai.bundle.scripts.verify_net_in_out`
-
-4. `bundle.download`
-- Download model bundle assets.
-- Backend: `monai.bundle.scripts.download`
-
-5. `bundle.init`
-- Initialize a new bundle scaffold.
-- Backend: `monai.bundle.scripts.init_bundle`
-
-6. `config.parse`
-- Load and resolve MONAI config content.
-- Backend: `ConfigParser.load_config_file/parse/get_parsed_content`
-
-7. `infer.sliding_window`
-- Perform patch-based inference over large tensors/images.
-- Backend: `sliding_window_inference`
-
-8. `system.health`
-- Environment and dependency diagnostics (Python/Torch/MONAI/CUDA availability).
-
----
-
-## 5) Common Issues and Notes
-
-- Dependency mismatches:
-  - Many MONAI features are optional-dependency driven. Missing readers/transforms usually mean missing packages (e.g., nibabel/SimpleITK/itk).
-- GPU/CUDA issues:
-  - Ensure Torch CUDA build matches your driver/runtime.
-- Large-volume inference performance:
-  - Tune ROI size, overlap, batch size, and device placement for `sliding_window_inference`.
-- Config complexity:
-  - Prefer parser-based validation before runtime execution.
-- Heavy automation modules:
-  - `Auto3DSeg`/`nnUNet` paths are powerful but dependency-sensitive and compute-heavy.
-- Reproducibility:
-  - Pin MONAI + Torch versions and keep bundle configs versioned.
-
----
-
-## 6) Reference Links / Documentation
-
-- MONAI repository: https://github.com/Project-MONAI/MONAI
-- MONAI docs (installation/modules/config): `docs/source/` in repository
-- Bundle entrypoint: `python -m monai.bundle`
-- Auto3DSeg entrypoint: `python -m monai.apps.auto3dseg`
-- nnUNet entrypoint: `python -m monai.apps.nnunet`
-- Key modules:
-  - `monai.bundle.scripts`
-  - `monai.bundle.config_parser`
-  - `monai.inferers.inferer`
-  - `monai.transforms.compose`
-  - `monai.networks.nets`
+# MONAI MCP Plugin
+
+## Overview
+This MCP plugin exposes core MONAI capabilities through FastMCP tools.
+It supports `stdio` transport for local agent/desktop usage and `http` transport for service deployment.
+
+## Exposed Tools
+
+### 1) `health_check`
+- Parameters: none
+- Returns dependency availability (`fastmcp`, `monai`, `torch`, `numpy`) and adapter health.
+- Example:
+```json
+{"name": "health_check", "arguments": {}}
+```
+
+### 2) `list_modules`
+- Parameters:
+  - `include_failed` (bool, default `false`)
+  - `limit` (int, default `100`)
+- Lists MONAI modules loaded by adapter.
+- Example:
+```json
+{"name": "list_modules", "arguments": {"include_failed": true, "limit": 50}}
+```
+
+### 3) `list_symbols`
+- Parameters:
+  - `module_name` (str)
+  - `public_only` (bool, default `true`)
+  - `limit` (int, default `100`)
+- Lists exported symbols for a module.
+- Example:
+```json
+{"name": "list_symbols", "arguments": {"module_name": "monai.transforms"}}
+```
+
+### 4) `list_network_architectures`
+- Parameters:
+  - `limit` (int, default `80`)
+- Lists architecture classes from `monai.networks.nets`.
+- Example:
+```json
+{"name": "list_network_architectures", "arguments": {"limit": 40}}
+```
+
+### 5) `create_network`
+- Parameters:
+  - `network_name` (str)
+  - `spatial_dims` (int)
+  - `in_channels` (int)
+  - `out_channels` (int)
+  - `channels_json` (str JSON list)
+  - `strides_json` (str JSON list)
+- Creates a MONAI network instance and returns summary.
+- Example:
+```json
+{
+  "name": "create_network",
+  "arguments": {
+    "network_name": "UNet",
+    "spatial_dims": 3,
+    "in_channels": 1,
+    "out_channels": 2,
+    "channels_json": "[16,32,64,128]",
+    "strides_json": "[2,2,2]"
+  }
+}
+```
+
+### 6) `build_transform_pipeline`
+- Parameters:
+  - `transform_names_json` (str JSON list)
+- Creates a MONAI `Compose` pipeline using zero-argument transform constructors.
+- Example:
+```json
+{
+  "name": "build_transform_pipeline",
+  "arguments": {
+    "transform_names_json": "[\"EnsureChannelFirst\", \"ScaleIntensity\"]"
+  }
+}
+```
+
+### 7) `call_function`
+- Parameters:
+  - `module_name` (str)
+  - `function_name` (str)
+  - `args_json` (str JSON list, default `[]`)
+  - `kwargs_json` (str JSON object, default `{}`)
+- Calls a function through adapter reflection.
+- Example:
+```json
+{
+  "name": "call_function",
+  "arguments": {
+    "module_name": "monai.data",
+    "function_name": "decollate_batch",
+    "args_json": "[]",
+    "kwargs_json": "{}"
+  }
+}
+```
+
+### 8) `create_instance`
+- Parameters:
+  - `module_name` (str)
+  - `class_name` (str)
+  - `args_json` (str JSON list, default `[]`)
+  - `kwargs_json` (str JSON object, default `{}`)
+- Creates a class instance through adapter reflection.
+- Example:
+```json
+{
+  "name": "create_instance",
+  "arguments": {
+    "module_name": "monai.losses",
+    "class_name": "DiceLoss",
+    "args_json": "[]",
+    "kwargs_json": "{}"
+  }
+}
+```
+
+## Run Locally (stdio)
+
+From `mcp_output` directory:
+
+```bash
+python mcp_plugin/main.py
+```
+
+Or with launcher:
+
+```bash
+MCP_TRANSPORT=stdio python start_mcp.py
+```
+
+## Run via HTTP Transport
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+Clients should connect to:
+
+- `http://localhost:7860/mcp`
+
+## Notes
+- The plugin prepends local `source/` path (relative to deployment package) to `sys.path`.
+- If MONAI dependencies are missing, tools return structured error responses without crashing.

MONAI/mcp_output/mcp_plugin/adapter.py

@@ -1,261 +1,195 @@
-import os
+from __future__ import annotations
+
+import importlib
+import pkgutil
 import sys
-from typing import Any, Dict, Optional
+from pathlib import Path
+from typing import Any
 
-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_dir_str = str(SOURCE_DIR)
+    if source_dir_str not in sys.path:
+        sys.path.insert(0, source_dir_str)
 
 
 class Adapter:
-    """
-    MCP Import Mode Adapter for MONAI repository integration.
-
-    This adapter prioritizes direct Python imports from the local `source` path and
-    provides CLI fallback hints when imports are unavailable. All public methods
-    return a unified dictionary with at least a `status` field.
-    """
-
-    def __init__(self) -> None:
-        self.mode = "import"
-        self._imports: Dict[str, Any] = {}
-        self._errors: Dict[str, str] = {}
-        self._initialize_imports()
-
-    # -------------------------------------------------------------------------
-    # Internal helpers
-    # -------------------------------------------------------------------------
-    def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]:
-        payload = {"status": status}
-        payload.update(kwargs)
-        return payload
-
-    def _safe_import(self, key: str, module_path: str, attr_name: Optional[str] = None) -> None:
+    def __init__(self, target_package: str = "monai") -> None:
+        self.target_package = target_package
+        self.mode = "normal"
+        self._root_module = None
+        self._loaded_modules: dict[str, Any] = {}
+        self._failed_modules: dict[str, str] = {}
+        self._bootstrap()
+
+    def _bootstrap(self) -> None:
         try:
-            module = __import__(module_path, fromlist=[attr_name] if attr_name else [])
-            self._imports[key] = getattr(module, attr_name) if attr_name else module
+            self._root_module = importlib.import_module(self.target_package)
+            self._loaded_modules[self.target_package] = self._root_module
         except Exception as exc:
-            self._errors[key] = (
-                f"Failed to import '{module_path}'"
-                + (f".'{attr_name}'" if attr_name else "")
-                + f": {exc}. Ensure repository source is present at '{source_path}' and dependencies are installed."
-            )
-
-    def _initialize_imports(self) -> None:
-        self._safe_import("bundle_main", "monai.bundle.__main__")
-        self._safe_import("auto3dseg_main", "monai.apps.auto3dseg.__main__")
-        self._safe_import("nnunet_main", "monai.apps.nnunet.__main__")
-
-    def _get_import(self, key: str) -> Dict[str, Any]:
-        if key in self._imports:
-            return self._result("success", object=self._imports[key], mode=self.mode)
-        return self._result(
-            "error",
-            mode=self.mode,
-            message=self._errors.get(
-                key,
-                f"Import key '{key}' is not available. Verify source path and optional dependencies.",
-            ),
-            fallback="Use CLI entrypoints if imports are unavailable.",
-        )
-
-    # -------------------------------------------------------------------------
-    # Adapter status and diagnostics
-    # -------------------------------------------------------------------------
-    def health_check(self) -> Dict[str, Any]:
-        """
-        Check adapter readiness and imported module availability.
-
-        Returns:
-            Dict[str, Any]:
-                {
-                    "status": "success" | "partial" | "error",
-                    "mode": "import",
-                    "available": [...],
-                    "failed": {...},
-                    "guidance": str
+            self.mode = "blackbox"
+            self._failed_modules[self.target_package] = str(exc)
+            return
+
+        if not hasattr(self._root_module, "__path__"):
+            return
+
+        for module_info in pkgutil.walk_packages(self._root_module.__path__, prefix=f"{self.target_package}."):
+            module_name = module_info.name
+            try:
+                loaded = importlib.import_module(module_name)
+                self._loaded_modules[module_name] = loaded
+            except Exception as exc:
+                self._failed_modules[module_name] = str(exc)
+
+        if not self._loaded_modules:
+            self.mode = "blackbox"
+
+    def _status(self) -> str:
+        if self.mode == "blackbox":
+            return "fallback"
+        return "ok"
+
+    def health(self) -> dict[str, Any]:
+        return {
+            "status": self._status(),
+            "mode": self.mode,
+            "target_package": self.target_package,
+            "loaded_count": len(self._loaded_modules),
+            "failed_count": len(self._failed_modules),
+            "loaded_root": self.target_package in self._loaded_modules,
+        }
+
+    def list_modules(self, include_failed: bool = False, limit: int = 200) -> dict[str, Any]:
+        loaded = sorted(self._loaded_modules.keys())[: max(limit, 0)]
+        result: dict[str, Any] = {
+            "status": self._status(),
+            "mode": self.mode,
+            "loaded_modules": loaded,
+            "loaded_count": len(self._loaded_modules),
+        }
+        if include_failed:
+            failed_items = sorted(self._failed_modules.items(), key=lambda x: x[0])[: max(limit, 0)]
+            result["failed_modules"] = [{"module": k, "error": v} for k, v in failed_items]
+            result["failed_count"] = len(self._failed_modules)
+        return result
+
+    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:
+            try:
+                module = importlib.import_module(module_name)
+            except Exception as exc:
+                return {
+                    "status": "error",
+                    "module": module_name,
+                    "error": f"failed to import module: {exc}",
                 }
-        """
-        available = sorted(self._imports.keys())
-        failed = dict(self._errors)
-        if available and not failed:
-            status = "success"
-        elif available and failed:
-            status = "partial"
-        else:
-            status = "error"
-        return self._result(
-            status,
-            mode=self.mode,
-            available=available,
-            failed=failed,
-            guidance=(
-                "Install required dependencies (python>=3.9, torch, numpy) and optional MONAI extras "
-                "if specific modules fail."
-            ),
-        )
-
-    # -------------------------------------------------------------------------
-    # Module accessors (instance methods for identified modules/classes scope)
-    # -------------------------------------------------------------------------
-    def get_bundle_main_module(self) -> Dict[str, Any]:
-        """
-        Get imported module object for MONAI Bundle CLI entrypoint.
-
-        Returns:
-            Dict[str, Any]:
-                status plus module object under `object` if available.
-        """
-        return self._get_import("bundle_main")
-
-    def get_auto3dseg_main_module(self) -> Dict[str, Any]:
-        """
-        Get imported module object for MONAI Auto3DSeg CLI entrypoint.
-
-        Returns:
-            Dict[str, Any]:
-                status plus module object under `object` if available.
-        """
-        return self._get_import("auto3dseg_main")
-
-    def get_nnunet_main_module(self) -> Dict[str, Any]:
-        """
-        Get imported module object for MONAI nnUNet CLI entrypoint.
 
-        Returns:
-            Dict[str, Any]:
-                status plus module object under `object` if available.
-        """
-        return self._get_import("nnunet_main")
-
-    # -------------------------------------------------------------------------
-    # CLI-aligned call methods (function-equivalent wrappers)
-    # -------------------------------------------------------------------------
-    def call_bundle_cli(self, args: Optional[list] = None) -> Dict[str, Any]:
-        """
-        Execute MONAI Bundle CLI via imported module when possible.
-
-        Parameters:
-            args (Optional[list]): Command-line style arguments. If None, defaults to [].
-
-        Returns:
-            Dict[str, Any]:
-                Unified status dictionary with execution result or actionable fallback guidance.
-        """
-        args = args or []
-        mod_res = self._get_import("bundle_main")
-        if mod_res["status"] != "success":
-            return self._result(
-                "error",
-                mode=self.mode,
-                message=mod_res["message"],
-                fallback="Run manually: python -m monai.bundle <args>",
-            )
         try:
-            module = mod_res["object"]
-            if hasattr(module, "main") and callable(module.main):
-                rc = module.main(args)
-                return self._result("success", mode=self.mode, return_code=rc, entrypoint="python -m monai.bundle")
-            return self._result(
-                "error",
-                mode=self.mode,
-                message="Imported module does not expose a callable 'main(args)'.",
-                fallback="Run manually: python -m monai.bundle <args>",
-            )
+            symbols = dir(module)
+            if public_only:
+                symbols = [s for s in symbols if not s.startswith("_")]
+            symbols = sorted(symbols)[: max(limit, 0)]
+            return {
+                "status": "ok",
+                "module": module_name,
+                "symbols": symbols,
+                "count": len(symbols),
+            }
         except Exception as exc:
-            return self._result(
-                "error",
-                mode=self.mode,
-                message=f"Bundle CLI execution failed: {exc}. Check argument syntax and required runtime dependencies.",
-                fallback="Run manually: python -m monai.bundle <args>",
-            )
-
-    def call_auto3dseg_cli(self, args: Optional[list] = None) -> Dict[str, Any]:
-        """
-        Execute MONAI Auto3DSeg CLI via imported module when possible.
-
-        Parameters:
-            args (Optional[list]): Command-line style arguments. If None, defaults to [].
-
-        Returns:
-            Dict[str, Any]:
-                Unified status dictionary with execution result or fallback guidance.
-        """
+            return {
+                "status": "error",
+                "module": module_name,
+                "error": str(exc),
+            }
+
+    def call_function(
+        self,
+        module_name: str,
+        function_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         args = args or []
-        mod_res = self._get_import("auto3dseg_main")
-        if mod_res["status"] != "success":
-            return self._result(
-                "error",
-                mode=self.mode,
-                message=mod_res["message"],
-                fallback="Run manually: python -m monai.apps.auto3dseg <args>",
-            )
+        kwargs = kwargs or {}
+
         try:
-            module = mod_res["object"]
-            if hasattr(module, "main") and callable(module.main):
-                rc = module.main(args)
-                return self._result(
-                    "success",
-                    mode=self.mode,
-                    return_code=rc,
-                    entrypoint="python -m monai.apps.auto3dseg",
-                )
-            return self._result(
-                "error",
-                mode=self.mode,
-                message="Imported module does not expose a callable 'main(args)'.",
-                fallback="Run manually: python -m monai.apps.auto3dseg <args>",
-            )
+            module = importlib.import_module(module_name)
         except Exception as exc:
-            return self._result(
-                "error",
-                mode=self.mode,
-                message=f"Auto3DSeg CLI execution failed: {exc}. Validate dataset/config paths and dependencies.",
-                fallback="Run manually: python -m monai.apps.auto3dseg <args>",
-            )
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": f"failed to import module: {exc}",
+            }
+
+        fn = getattr(module, function_name, None)
+        if fn is None or not callable(fn):
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": "function not found or not callable",
+            }
 
-    def call_nnunet_cli(self, args: Optional[list] = None) -> Dict[str, Any]:
-        """
-        Execute MONAI nnUNet CLI via imported module when possible.
+        try:
+            value = fn(*args, **kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "function": function_name,
+                "result": value,
+            }
+        except Exception as exc:
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": str(exc),
+            }
+
+    def create_instance(
+        self,
+        module_name: str,
+        class_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        args = args or []
+        kwargs = kwargs or {}
 
-        Parameters:
-            args (Optional[list]): Command-line style arguments. If None, defaults to [].
+        try:
+            module = importlib.import_module(module_name)
+        except Exception as exc:
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": f"failed to import module: {exc}",
+            }
+
+        cls = getattr(module, class_name, None)
+        if cls is None:
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": "class not found",
+            }
 
-        Returns:
-            Dict[str, Any]:
-                Unified status dictionary with execution result or fallback guidance.
-        """
-        args = args or []
-        mod_res = self._get_import("nnunet_main")
-        if mod_res["status"] != "success":
-            return self._result(
-                "error",
-                mode=self.mode,
-                message=mod_res["message"],
-                fallback="Run manually: python -m monai.apps.nnunet <args>",
-            )
         try:
-            module = mod_res["object"]
-            if hasattr(module, "main") and callable(module.main):
-                rc = module.main(args)
-                return self._result(
-                    "success",
-                    mode=self.mode,
-                    return_code=rc,
-                    entrypoint="python -m monai.apps.nnunet",
-                )
-            return self._result(
-                "error",
-                mode=self.mode,
-                message="Imported module does not expose a callable 'main(args)'.",
-                fallback="Run manually: python -m monai.apps.nnunet <args>",
-            )
+            instance = cls(*args, **kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "class": class_name,
+                "instance": instance,
+            }
         except Exception as exc:
-            return self._result(
-                "error",
-                mode=self.mode,
-                message=f"nnUNet CLI execution failed: {exc}. Confirm nnUNet configuration and dependencies.",
-                fallback="Run manually: python -m monai.apps.nnunet <args>",
-            )
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": str(exc),
+            }

MONAI/mcp_output/mcp_plugin/main.py

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

MONAI/mcp_output/mcp_plugin/mcp_service.py

@@ -1,201 +1,354 @@
-import os
+from __future__ import annotations
+
+import json
 import sys
+from pathlib import Path
 from typing import Any
 
-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_dir_str = str(SOURCE_DIR)
+    if source_dir_str not in sys.path:
+        sys.path.insert(0, source_dir_str)
+
+try:
+    from fastmcp import FastMCP
+except Exception:
+    FastMCP = None
+
+try:
+    import monai
+except Exception:
+    monai = None
+
+try:
+    import torch
+except Exception:
+    torch = None
+
+try:
+    import numpy as np
+except Exception:
+    np = None
+
+try:
+    from .adapter import Adapter
+except Exception:
+    Adapter = None
+
 
-from fastmcp import FastMCP
-import monai
+class _FallbackMCP:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tools: list[Any] = []
 
+    def tool(self, name: str, description: str):
+        def decorator(func):
+            func.__mcp_name__ = name
+            func.__mcp_description__ = description
+            self.tools.append(func)
+            return func
 
-mcp = FastMCP("monai_service")
+        return decorator
 
+    def run(self, *args: Any, **kwargs: Any) -> None:
+        raise RuntimeError("fastmcp is not available. Please install dependencies first.")
 
-def _ok(result: Any) -> dict:
+
+mcp = FastMCP(name="MONAI MCP Service") if FastMCP is not None else _FallbackMCP(name="MONAI MCP Service")
+_adapter = Adapter(target_package="monai") if Adapter is not None else None
+
+
+def _ok(result: Any) -> dict[str, Any]:
     return {"success": True, "result": result, "error": None}
 
 
-def _err(message: str) -> dict:
+def _err(message: str) -> dict[str, Any]:
     return {"success": False, "result": None, "error": message}
 
 
-@mcp.tool(name="monai_version", description="Get MONAI version and basic environment info.")
-def monai_version() -> dict:
-    """
-    Return MONAI version details.
+def _json_to_list(value: str) -> list[Any]:
+    parsed = json.loads(value)
+    if not isinstance(parsed, list):
+        raise ValueError("expected a JSON list")
+    return parsed
+
+
+def _json_to_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="health_check", description="Report availability of FastMCP and MONAI-related dependencies.")
+def health_check() -> dict[str, Any]:
+    """Return health information for runtime dependencies and adapter state.
+
+    Parameters:
+        None.
 
     Returns:
-        dict: Standard response dictionary with version and module path details.
+        Standard MCP response containing dependency availability and adapter health.
     """
-    try:
-        result = {
-            "version": getattr(monai, "__version__", "unknown"),
-            "module": monai.__name__,
-            "file": getattr(monai, "__file__", None),
+    adapter_health = _adapter.health() if _adapter is not None else {"status": "error", "error": "adapter unavailable"}
+    return _ok(
+        {
+            "dependencies": {
+                "fastmcp": FastMCP is not None,
+                "monai": monai is not None,
+                "torch": torch is not None,
+                "numpy": np is not None,
+                "adapter": _adapter is not None,
+            },
+            "adapter": adapter_health,
         }
-        return _ok(result)
-    except Exception as exc:
-        return _err(str(exc))
+    )
+
+
+@mcp.tool(name="list_modules", description="List loaded MONAI modules and optional failures from the adapter.")
+def list_modules(include_failed: bool = False, limit: int = 100) -> dict[str, Any]:
+    """List modules discovered by the adapter.
+
+    Parameters:
+        include_failed: Whether to include modules that failed to import.
+        limit: Maximum number of module records to return.
+
+    Returns:
+        Standard MCP response with module inventory.
+    """
+    if _adapter is None:
+        return _err("adapter is not available")
+
+    return _ok(_adapter.list_modules(include_failed=include_failed, limit=limit))
 
 
-@mcp.tool(name="bundle_run", description="Run MONAI bundle CLI-style commands programmatically.")
-def bundle_run(args: str) -> dict:
+@mcp.tool(name="list_symbols", description="List symbols exported by a MONAI module.")
+def list_symbols(module_name: str, public_only: bool = True, limit: int = 100) -> dict[str, Any]:
+    """List attributes and symbols from a module.
+
+    Parameters:
+        module_name: Full module path, for example 'monai.transforms'.
+        public_only: Exclude symbols that start with underscore when true.
+        limit: Maximum number of symbols to return.
+
+    Returns:
+        Standard MCP response with symbol list.
     """
-    Execute MONAI bundle script entry with argument string.
+    if _adapter is None:
+        return _err("adapter is not available")
+
+    result = _adapter.list_symbols(module_name=module_name, public_only=public_only, limit=limit)
+    if result.get("status") == "error":
+        return _err(result.get("error", "unknown error"))
+    return _ok(result)
+
+
+@mcp.tool(name="list_network_architectures", description="List available MONAI network architecture class names.")
+def list_network_architectures(limit: int = 80) -> dict[str, Any]:
+    """List candidate network architecture classes from monai.networks.nets.
 
     Parameters:
-        args (str): CLI-like argument string, e.g. 'run --config_file config.json'.
+        limit: Maximum number of architecture names to return.
 
     Returns:
-        dict: Standard response dictionary with script return value.
+        Standard MCP response with architecture names.
     """
-    try:
-        from monai.bundle.scripts import run as bundle_run_fn
+    if monai is None:
+        return _err("monai is not available")
 
-        argv = [a for a in args.split(" ") if a.strip()]
-        out = bundle_run_fn(argv)
-        return _ok(out)
+    try:
+        nets_module = __import__("monai.networks.nets", fromlist=["*"])
+        names: list[str] = []
+        for name in dir(nets_module):
+            if name.startswith("_"):
+                continue
+            value = getattr(nets_module, name, None)
+            if isinstance(value, type):
+                names.append(name)
+        names = sorted(set(names))[: max(limit, 0)]
+        return _ok({"architectures": names, "count": len(names)})
     except Exception as exc:
         return _err(str(exc))
 
 
-@mcp.tool(name="auto3dseg_run", description="Run Auto3DSeg pipeline from MONAI apps.")
-def auto3dseg_run(
-    input_data_config: str,
-    work_dir: str,
-    algorithms: str = "",
-    templates_path_or_url: str = "",
-) -> dict:
-    """
-    Launch an Auto3DSeg run using MONAI AutoRunner.
+@mcp.tool(name="create_network", description="Create a MONAI network instance from monai.networks.nets.")
+def create_network(
+    network_name: str,
+    spatial_dims: int,
+    in_channels: int,
+    out_channels: int,
+    channels_json: str,
+    strides_json: str,
+) -> dict[str, Any]:
+    """Instantiate a MONAI network with common constructor arguments.
 
     Parameters:
-        input_data_config (str): Path to data list/config JSON.
-        work_dir (str): Working directory for outputs.
-        algorithms (str): Comma-separated algorithm names to include.
-        templates_path_or_url (str): Optional local path or URL for templates.
+        network_name: Class name under monai.networks.nets, such as 'UNet' or 'DynUNet'.
+        spatial_dims: Number of spatial dimensions (2 or 3 usually).
+        in_channels: Number of input channels.
+        out_channels: Number of output channels.
+        channels_json: JSON list of channel widths, for example '[16,32,64,128]'.
+        strides_json: JSON list of strides, for example '[2,2,2]'.
 
     Returns:
-        dict: Standard response dictionary with run status/output.
+        Standard MCP response with object summary.
     """
+    if monai is None:
+        return _err("monai is not available")
+
     try:
-        from monai.apps.auto3dseg.auto_runner import AutoRunner
-
-        algos = [a.strip() for a in algorithms.split(",") if a.strip()] or None
-        runner = AutoRunner(
-            input=input_data_config,
-            work_dir=work_dir,
-            algos=algos,
-            templates_path_or_url=templates_path_or_url or None,
+        channels = [int(v) for v in _json_to_list(channels_json)]
+        strides = [int(v) for v in _json_to_list(strides_json)]
+        nets_module = __import__("monai.networks.nets", fromlist=[network_name])
+        network_cls = getattr(nets_module, network_name, None)
+        if network_cls is None:
+            return _err(f"network class not found: {network_name}")
+
+        network = network_cls(
+            spatial_dims=spatial_dims,
+            in_channels=in_channels,
+            out_channels=out_channels,
+            channels=channels,
+            strides=strides,
+        )
+        return _ok(
+            {
+                "network_name": network_name,
+                "network_type": type(network).__name__,
+                "repr": repr(network),
+            }
         )
-        output = runner.run()
-        return _ok(output)
     except Exception as exc:
         return _err(str(exc))
 
 
-@mcp.tool(name="nnunetv2_run", description="Run MONAI nnUNetV2 workflow wrapper.")
-def nnunetv2_run(
-    input_config: str,
-    work_dir: str,
-    datalist: str = "",
-    fold: int = 0,
-) -> dict:
-    """
-    Execute nnUNetV2 runner from MONAI apps.
+@mcp.tool(name="build_transform_pipeline", description="Build a MONAI Compose pipeline from transform class names.")
+def build_transform_pipeline(transform_names_json: str) -> dict[str, Any]:
+    """Create a Compose pipeline from zero-argument MONAI transform constructors.
 
     Parameters:
-        input_config (str): Path to nnUNetV2 config file.
-        work_dir (str): Working directory.
-        datalist (str): Optional datalist path.
-        fold (int): Fold index.
+        transform_names_json: JSON list of transform class names under monai.transforms,
+            for example '["EnsureChannelFirst", "ScaleIntensity"]'.
 
     Returns:
-        dict: Standard response dictionary with runner output.
+        Standard MCP response with pipeline summary.
     """
-    try:
-        from monai.apps.nnunet.nnunetv2_runner import NNUNetV2Runner
+    if monai is None:
+        return _err("monai is not available")
 
-        runner = NNUNetV2Runner(
-            input_config=input_config,
-            work_dir=work_dir,
-            datalist=datalist or None,
-            fold=fold,
+    try:
+        names = [str(v) for v in _json_to_list(transform_names_json)]
+        transforms_module = __import__("monai.transforms", fromlist=["Compose"])
+        compose_cls = getattr(transforms_module, "Compose", None)
+        if compose_cls is None:
+            return _err("Compose is not available in monai.transforms")
+
+        instances: list[Any] = []
+        created_names: list[str] = []
+        for transform_name in names:
+            transform_cls = getattr(transforms_module, transform_name, None)
+            if transform_cls is None:
+                return _err(f"transform class not found: {transform_name}")
+            instance = transform_cls()
+            instances.append(instance)
+            created_names.append(transform_name)
+
+        pipeline = compose_cls(instances)
+        return _ok(
+            {
+                "pipeline_type": type(pipeline).__name__,
+                "num_transforms": len(created_names),
+                "transforms": created_names,
+            }
         )
-        output = runner.run()
-        return _ok(output)
     except Exception as exc:
         return _err(str(exc))
 
 
-@mcp.tool(name="config_parse", description="Parse a MONAI bundle config file and return resolved content.")
-def config_parse(config_file: str) -> dict:
-    """
-    Parse and resolve MONAI bundle configuration.
+@mcp.tool(name="call_function", description="Call a MONAI function via adapter reflection with JSON args.")
+def call_function(module_name: str, function_name: str, args_json: str = "[]", kwargs_json: str = "{}") -> dict[str, Any]:
+    """Call a function from a target module using JSON-encoded arguments.
 
     Parameters:
-        config_file (str): Path to config JSON/YAML.
+        module_name: Full module path, for example 'monai.data'.
+        function_name: Callable name inside the module.
+        args_json: JSON list of positional arguments.
+        kwargs_json: JSON object of keyword arguments.
 
     Returns:
-        dict: Standard response dictionary with parsed config content.
+        Standard MCP response with call result if serializable.
     """
-    try:
-        from monai.bundle.config_parser import ConfigParser
+    if _adapter is None:
+        return _err("adapter is not available")
 
-        parser = ConfigParser()
-        parser.read_config(config_file)
-        parser.parse()
-        content = parser.get_parsed_content()
-        return _ok(content)
+    try:
+        args = _json_to_list(args_json)
+        kwargs = _json_to_dict(kwargs_json)
+        result = _adapter.call_function(module_name=module_name, function_name=function_name, args=args, kwargs=kwargs)
+        if result.get("status") == "error":
+            return _err(result.get("error", "unknown error"))
+
+        value = result.get("result")
+        safe_value: Any
+        try:
+            json.dumps(value)
+            safe_value = value
+        except Exception:
+            safe_value = repr(value)
+
+        return _ok(
+            {
+                "status": result.get("status"),
+                "module": module_name,
+                "function": function_name,
+                "result": safe_value,
+            }
+        )
     except Exception as exc:
         return _err(str(exc))
 
 
-@mcp.tool(name="list_optional_dependencies", description="Check presence of common optional MONAI dependencies.")
-def list_optional_dependencies() -> dict:
-    """
-    Check import availability for key optional packages used by MONAI.
+@mcp.tool(name="create_instance", description="Create an instance from a MONAI class via adapter reflection.")
+def create_instance(module_name: str, class_name: str, args_json: str = "[]", kwargs_json: str = "{}") -> dict[str, Any]:
+    """Instantiate a class from a module using JSON arguments.
+
+    Parameters:
+        module_name: Full module path, for example 'monai.losses'.
+        class_name: Class name in the module.
+        args_json: JSON list of positional constructor args.
+        kwargs_json: JSON object of keyword constructor args.
 
     Returns:
-        dict: Standard response dictionary containing package availability map.
+        Standard MCP response with instance summary.
     """
+    if _adapter is None:
+        return _err("adapter is not available")
+
     try:
-        packages = [
-            "nibabel",
-            "SimpleITK",
-            "pydicom",
-            "itk",
-            "scipy",
-            "PIL",
-            "ignite",
-            "einops",
-            "skimage",
-            "mlflow",
-            "tensorboard",
-            "cv2",
-            "cucim",
-            "zarr",
-        ]
-        availability = {}
-        for pkg in packages:
-            try:
-                __import__(pkg)
-                availability[pkg] = True
-            except Exception:
-                availability[pkg] = False
-        return _ok(availability)
+        args = _json_to_list(args_json)
+        kwargs = _json_to_dict(kwargs_json)
+        result = _adapter.create_instance(module_name=module_name, class_name=class_name, args=args, kwargs=kwargs)
+        if result.get("status") == "error":
+            return _err(result.get("error", "unknown error"))
+
+        instance = result.get("instance")
+        return _ok(
+            {
+                "status": result.get("status"),
+                "module": module_name,
+                "class": class_name,
+                "instance_type": type(instance).__name__ if instance is not None else None,
+                "repr": repr(instance),
+            }
+        )
     except Exception as exc:
         return _err(str(exc))
 
 
-def create_app() -> FastMCP:
+def create_app() -> Any:
     return mcp
 
 
 if __name__ == "__main__":
-    mcp.run()
+    mcp.run()

MONAI/mcp_output/requirements.txt

@@ -1,6 +1,4 @@
-fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-torch>=2.4.1; platform_system != "Windows"
-numpy>=1.24,<3.0
+fastmcp>=2.0.0
+monai
+numpy
+torch

MONAI/mcp_output/start_mcp.py

@@ -1,30 +1,37 @@
+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"
+plugin_dir_str = str(PLUGIN_DIR)
+if plugin_dir_str not in sys.path:
+    sys.path.insert(0, plugin_dir_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)
-    else:
-        # Default to STDIO mode
-        app.run()
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port)
+            return
+        except TypeError:
+            try:
+                app.run(transport="http", port=port)
+                return
+            except TypeError:
+                app.run(port=port)
+                return
+
+    app.run()
+
 
 if __name__ == "__main__":
     main()

README.md

@@ -1,10 +1,67 @@
 ---
-title: MONAI
-emoji: 🔥
-colorFrom: indigo
-colorTo: pink
+title: MONAI 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
+# MONAI MCP Service
+
+This deployment package wraps MONAI capabilities as MCP tools using FastMCP.
+It supports local `stdio` usage and HTTP MCP endpoint deployment for Docker/HuggingFace Spaces.
+
+## Available Tools
+
+- `health_check`
+- `list_modules`
+- `list_symbols`
+- `list_network_architectures`
+- `create_network`
+- `build_transform_pipeline`
+- `call_function`
+- `create_instance`
+
+Detailed tool docs are in `MONAI/mcp_output/README_MCP.md`.
+
+## Local stdio (Claude Desktop / CLI)
+
+```bash
+cd MONAI/mcp_output
+python mcp_plugin/main.py
+```
+
+or:
+
+```bash
+MCP_TRANSPORT=stdio python start_mcp.py
+```
+
+## HTTP MCP endpoint (Docker/HF Spaces)
+
+The Docker entrypoint launches FastMCP directly from:
+
+- `python MONAI/mcp_output/start_mcp.py`
+
+Runtime env in container:
+
+- `MCP_TRANSPORT=http`
+- `MCP_PORT=7860`
+
+MCP clients should connect to:
+
+- `https://<your-host>/mcp`
+
+## Build and Run Docker
+
+```bash
+./run_docker.sh
+```
+
+On Windows PowerShell:
+
+```powershell
+./run_docker.ps1
+```

app.py

@@ -1,45 +1,49 @@
-from fastapi import FastAPI
+from __future__ import annotations
+
 import os
 import sys
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
+
+PLUGIN_DIR = Path(__file__).resolve().parent / "MONAI" / "mcp_output" / "mcp_plugin"
+plugin_dir_str = str(PLUGIN_DIR)
+if plugin_dir_str not in sys.path:
+    sys.path.insert(0, plugin_dir_str)
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "MONAI", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+PORT = int(os.getenv("PORT", "7860"))
+
+app = FastAPI(title="MONAI MCP Info App", version="1.0.0")
 
-app = FastAPI(
-    title="Monai MCP Service",
-    description="Auto-generated MCP service for MONAI",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def root() -> dict[str, Any]:
     return {
-        "service": "Monai MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "MONAI MCP Service",
+        "description": "Supplementary info API for local development.",
+        "mcp_http_endpoint": "/mcp",
+        "default_port": PORT,
+        "note": "This FastAPI app is not the MCP runtime entry point.",
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "MONAI MCP"}
+def health() -> dict[str, str]:
+    return {"status": "healthy"}
+
 
 @app.get("/tools")
-def list_tools():
+def tools() -> dict[str, Any]:
     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)
+
+        mcp = create_app()
+        items = []
+        for tool in getattr(mcp, "tools", []):
+            name = getattr(tool, "name", None) or getattr(tool, "__mcp_name__", None) or getattr(tool, "__name__", "unknown")
+            description = getattr(tool, "description", None) or getattr(tool, "__mcp_description__", None) or ""
+            items.append({"name": name, "description": description})
+        return {"count": len(items), "tools": items}
+    except Exception as exc:
+        return {"count": 0, "tools": [], "error": str(exc)}

port.json

@@ -1,5 +1 @@
-{
-  "repo": "MONAI",
-  "port": 7919,
-  "timestamp": 1773273129
-}
+{"port": 7860}

requirements.txt

@@ -1,6 +1,6 @@
-fastmcp
+fastmcp>=2.0.0
+monai
+numpy
+torch
 fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-torch>=2.4.1; platform_system != "Windows"
-numpy>=1.24,<3.0
+uvicorn

run_docker.ps1

@@ -1,26 +1,8 @@
-cd $PSScriptRoot
-$ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "MONAI" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7919/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "MONAI-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 = "MONAI-mcp"
+
+Write-Host "Building Docker image: $imageName"
 docker build -t $imageName .
-docker run --rm -p 7919:7860 $imageName
+
+Write-Host "Running container on port $port"
+docker run --rm -p "${port}:${port}" $imageName

run_docker.sh

@@ -1,75 +1,12 @@
 #!/usr/bin/env bash
 set -euo pipefail
-cd "$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
-mcp_entry_name="${MCP_ENTRY_NAME:-MONAI}"
-mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7919/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 MONAI-mcp .
-docker run --rm -p 7919:7860 MONAI-mcp
+
+PORT=$(python3 -c 'import json; print(json.load(open("port.json", "r", encoding="utf-8"))["port"])')
+IMAGE_NAME="MONAI-mcp"
+
+
+echo "Building Docker image: ${IMAGE_NAME}"
+docker build -t "${IMAGE_NAME}" .
+
+echo "Running container on port ${PORT}"
+docker run --rm -p "${PORT}:${PORT}" "${IMAGE_NAME}"