Upload 14 files

Dockerfile

@@ -1,17 +1,22 @@
-FROM python:3.10
+FROM python:3.11-slim
 
-RUN useradd -m -u 1000 user && python -m pip install --upgrade pip
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV MCP_TRANSPORT=http
+ENV MCP_PORT=7860
 
 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 --chown=user . /app
-ENV MCP_TRANSPORT=http
-ENV MCP_PORT=7860
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r /app/requirements.txt
+
+COPY climlab/ /app/climlab/
+COPY app.py /app/app.py
+
+USER appuser
 
 EXPOSE 7860
 

README.md

@@ -1,10 +1,69 @@
 ---
-title: Climlab
-emoji: ⚡
+title: climlab MCP Service
+emoji: 🔧
 colorFrom: blue
-colorTo: yellow
+colorTo: indigo
 sdk: docker
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# climlab MCP Service
+
+这是一个面向 `climlab` 仓库的 MCP 部署包，支持：
+- 本地 `stdio` 连接（Claude Desktop / CLI）
+- HTTP 方式连接（Docker / HuggingFace Spaces）
+
+## 可用工具
+
+- `health_check`
+- `get_version`
+- `list_modules`
+- `list_symbols`
+- `compute_daily_insolation`
+- `run_ebm_simulation`
+- `run_grey_radiation_column`
+- `call_function`
+
+详细参数与示例见 `climlab/mcp_output/README_MCP.md`。
+
+## 本地 stdio 运行
+
+```bash
+cd climlab/mcp_output
+python start_mcp.py
+```
+
+或：
+
+```bash
+MCP_TRANSPORT=stdio MCP_PORT=8000 python climlab/mcp_output/start_mcp.py
+```
+
+## HTTP 客户端连接
+
+### 本地 Docker
+
+```bash
+./run_docker.sh
+```
+
+容器启动后，MCP HTTP 端点为：
+
+- `http://localhost:7860/mcp`
+
+### HuggingFace Spaces
+
+Docker 入口直接运行 MCP 服务：
+
+- `python climlab/mcp_output/start_mcp.py`
+
+平台会暴露 7860 端口，客户端连接：
+
+- `https://<your-space>.hf.space/mcp`
+
+## 目录说明
+
+- `climlab/mcp_output/mcp_plugin/`：MCP 插件核心
+- `climlab/mcp_output/start_mcp.py`：按环境变量选择 `stdio/http` 的入口
+- `app.py`：补充 FastAPI 信息页（非 Docker 主入口）

app.py

@@ -1,45 +1,65 @@
-from fastapi import FastAPI
 import os
 import sys
+import importlib
+from pathlib import Path
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "climlab", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+try:
+    FastAPI = importlib.import_module("fastapi").FastAPI
+except Exception:
+    FastAPI = None
+
+PLUGIN_DIR = Path(__file__).resolve().parent / "climlab" / "mcp_output" / "mcp_plugin"
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
+
+if FastAPI is None:
+    class _FallbackApp:
+        def get(self, _: str):
+            def decorator(func):
+                return func
+            return decorator
+
+    app = _FallbackApp()
+else:
+    app = FastAPI(title="climlab MCP info app", version="1.0.0")
 
-app = FastAPI(
-    title="Climlab MCP Service",
-    description="Auto-generated MCP service for climlab",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def root() -> dict:
     return {
-        "service": "Climlab MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "name": "climlab-mcp",
+        "description": "Supplementary API for local development and tool discovery.",
+        "mcp_http_path": "/mcp",
+        "port": int(os.getenv("PORT", "7860")),
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "climlab MCP"}
+def health() -> dict:
+    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:
+    mcp_service = importlib.import_module("mcp_service")
+    create_app = getattr(mcp_service, "create_app")
+
+    mcp = create_app()
+    tool_entries = []
+
+    raw_tools = getattr(mcp, "tools", [])
+    if isinstance(raw_tools, dict):
+        iterable = raw_tools.values()
+    else:
+        iterable = raw_tools
+
+    for item in iterable:
+        if isinstance(item, dict):
+            name = item.get("name", "unknown")
+            description = item.get("description", "")
+        else:
+            name = getattr(item, "name", "unknown")
+            description = getattr(item, "description", "")
+        tool_entries.append({"name": name, "description": description})
+
+    return {"count": len(tool_entries), "tools": tool_entries}

climlab/mcp_output/README_MCP.md

@@ -1,124 +1,182 @@
-# climlab MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This service wraps key `climlab` capabilities into MCP (Model Context Protocol)-friendly endpoints for climate modeling workflows.  
-It is designed for developers who want to:
-
-- Build and run simple climate models (especially EBM and column models)
-- Compute insolation diagnostics
-- Access thermodynamic helper functions
-- Read core constants and model metadata
-- Orchestrate process-based simulations with `Process` / `TimeDependentProcess`
-
-Primary library: https://github.com/climlab/climlab
-
----
-
-## 2) Installation Method
-
-### System requirements
-- Python 3.9+ recommended
-- `numpy`, `scipy` required
-- Optional: `xarray`, `matplotlib`, `netCDF4`, `numba`
-- Optional advanced radiation: Fortran-compiled RRTMG extensions
-
-### Install with pip
-- pip install climlab
-
-### Optional extras (as needed)
-- pip install xarray matplotlib netCDF4 numba
-
-### For development setup (from source)
-- git clone https://github.com/climlab/climlab
-- cd climlab
-- pip install -e .
-
----
-
-## 3) Quick Start
-
-### Typical MCP (Model Context Protocol) workflow
-1. Initialize the service runtime.
-2. Call model constructor endpoint (e.g., EBM or column model).
-3. Step model forward in time.
-4. Retrieve diagnostics/state fields.
-5. Optionally call utility endpoints (insolation, thermo, constants).
-
-### Minimal example flow
-- Create an EBM model instance
-- Integrate for N timesteps
-- Fetch temperature field and energy budget diagnostics
-- Compute reference insolation for given latitude/day
-- Compare model output against insolation/thermo helpers
-
----
-
-## 4) Available Tools and Endpoints List
-
-Recommended endpoint surface for this repository:
-
-- `models.create_ebm`
-  - Create `EBM`, `EBM_annual`, `EBM_seasonal`, or related variants.
-- `models.create_column`
-  - Create `GreyRadiationModel`, `RadiativeConvectiveModel`, or `BandRCModel`.
-- `models.step`
-  - Advance a model using `TimeDependentProcess` stepping.
-- `models.integrate`
-  - Run multi-step integration and return selected diagnostics.
-- `models.get_state`
-  - Return state variables (`Field`) with domain metadata.
-- `models.get_diagnostics`
-  - Return process diagnostics and energy-budget outputs.
-
-- `insolation.daily`
-  - Wrapper for daily insolation calculation.
-- `insolation.annual_mean`
-  - Wrapper for annual-mean insolation calculation.
-
-- `thermo.clausius_clapeyron`
-- `thermo.qsat`
-- `thermo.mixing_ratio_from_vapor_pressure`
-- `thermo.vapor_pressure_from_specific_humidity`
-  - Stateless thermodynamic utilities.
-
-- `constants.list`
-  - Enumerate available physical constants.
-- `constants.get`
-  - Fetch constant value by name.
-
-- `domain.describe`
-  - Summarize axes/domains (`Axis`, `Domain`, atmosphere/ocean slabs).
-- `health.check`
-  - Verify import/runtime readiness, including optional modules.
-
----
-
-## 5) Common Issues and Notes
-
-- RRTMG-related functionality may fail without compiled Fortran extensions.
-- Some scientific workflows expect `xarray` for richer labeled output.
-- Numerical performance can vary by grid size and subprocess complexity.
-- Insolation APIs exist in both `climlab.radiation.insolation` and `climlab.solar.insolation`; keep endpoint mapping explicit.
-- Keep model objects session-scoped; avoid unnecessary re-instantiation for repeated stepping.
-- If running in constrained environments, disable heavy optional endpoints first (RRTMG, plotting-related paths).
-
----
-
-## 6) Reference Links / Documentation
-
-- Repository: https://github.com/climlab/climlab
-- Package docs source: `docs/source` in repository
-- Core modules to review:
-  - `climlab/process/process.py`
-  - `climlab/process/time_dependent_process.py`
-  - `climlab/model/ebm.py`
-  - `climlab/model/column.py`
-  - `climlab/radiation/insolation.py`
-  - `climlab/utils/thermo.py`
-  - `climlab/utils/constants.py`
-- Tests for usage patterns:
-  - `climlab/tests/test_ebm.py`
-  - `climlab/tests/test_rcm.py`
-  - `climlab/tests/test_insolation.py`
-  - `climlab/tests/test_rrtm.py`
+# climlab MCP Plugin
+
+`climlab` 的 MCP 工具层，面向本地 `stdio` 与服务化 `http` 两种传输方式。
+
+## 已暴露工具
+
+### 1) `health_check()`
+- 描述：检查服务与关键依赖（`fastmcp`、`climlab`、`numpy`、`adapter`）可用性。
+- 返回：依赖状态、适配器加载统计、默认传输模式。
+
+示例：
+```json
+{
+  "name": "health_check",
+  "arguments": {}
+}
+```
+
+### 2) `get_version()`
+- 描述：获取已安装 `climlab` 的版本。
+- 参数：无。
+
+示例：
+```json
+{
+  "name": "get_version",
+  "arguments": {}
+}
+```
+
+### 3) `list_modules(include_failed=true)`
+- 描述：列出适配器发现并尝试导入的模块。
+- 参数：
+  - `include_failed` (bool, 默认 `true`)：是否返回失败模块及原因。
+
+示例：
+```json
+{
+  "name": "list_modules",
+  "arguments": {
+    "include_failed": true
+  }
+}
+```
+
+### 4) `list_symbols(module_name, include_private=false)`
+- 描述：查看指定模块符号列表。
+- 参数：
+  - `module_name` (str)：如 `climlab.solar.insolation`
+  - `include_private` (bool, 默认 `false`)
+
+示例：
+```json
+{
+  "name": "list_symbols",
+  "arguments": {
+    "module_name": "climlab.solar.insolation",
+    "include_private": false
+  }
+}
+```
+
+### 5) `compute_daily_insolation(lat, day, solar_constant=1365.2)`
+- 描述：计算指定纬度与日序的日平均顶层入射短波。
+- 参数：
+  - `lat` (float)：纬度（度）
+  - `day` (float)：年内日序
+  - `solar_constant` (float, 默认 `1365.2`)
+
+示例：
+```json
+{
+  "name": "compute_daily_insolation",
+  "arguments": {
+    "lat": 65.0,
+    "day": 172.0,
+    "solar_constant": 1365.2
+  }
+}
+```
+
+### 6) `run_ebm_simulation(years=1.0, num_lat=36, water_depth=10.0)`
+- 描述：构建并积分一个基础 `EBM`，返回全局平均诊断量。
+- 参数：
+  - `years` (float)
+  - `num_lat` (int)
+  - `water_depth` (float)
+
+示例：
+```json
+{
+  "name": "run_ebm_simulation",
+  "arguments": {
+    "years": 2.0,
+    "num_lat": 72,
+    "water_depth": 20.0
+  }
+}
+```
+
+### 7) `run_grey_radiation_column(num_lev=30, num_steps=10, water_depth=1.0, insolation=341.3)`
+- 描述：运行灰气体柱模式若干步并返回均值诊断。
+- 参数：
+  - `num_lev` (int)
+  - `num_steps` (int)
+  - `water_depth` (float)
+  - `insolation` (float)
+
+示例：
+```json
+{
+  "name": "run_grey_radiation_column",
+  "arguments": {
+    "num_lev": 30,
+    "num_steps": 20,
+    "water_depth": 1.0,
+    "insolation": 341.3
+  }
+}
+```
+
+### 8) `call_function(module_name, function_name, kwargs_json="{}")`
+- 描述：通过白名单调用函数（仅允许 `climlab.solar.*`、`climlab.model.*`、`climlab.utils.*`）。
+- 参数：
+  - `module_name` (str)
+  - `function_name` (str)
+  - `kwargs_json` (str)：JSON 对象字符串
+
+示例：
+```json
+{
+  "name": "call_function",
+  "arguments": {
+    "module_name": "climlab.solar.insolation",
+    "function_name": "daily_insolation",
+    "kwargs_json": "{\"lat\": 45, \"day\": 80}"
+  }
+}
+```
+
+## 统一返回格式
+
+所有工具返回统一结构：
+
+```json
+{
+  "success": true,
+  "result": {},
+  "error": null
+}
+```
+
+失败时：
+
+```json
+{
+  "success": false,
+  "result": null,
+  "error": "..."
+}
+```
+
+## 本地运行（stdio）
+
+```bash
+cd climlab/mcp_output
+python start_mcp.py
+```
+
+或显式指定：
+
+```bash
+MCP_TRANSPORT=stdio MCP_PORT=8000 python start_mcp.py
+```
+
+## HTTP 运行
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+默认情况下客户端连接 `http://<host>:<port>/mcp`。

climlab/mcp_output/mcp_plugin/adapter.py

@@ -1,321 +1,201 @@
-import os
-import sys
-import traceback
-import inspect
 import importlib
-from typing import Any, Dict, List, Optional
+import inspect
+import pkgutil
+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() and str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
 
 
 class Adapter:
-    """
-    MCP Import Mode Adapter for climlab repository.
-
-    This adapter prioritizes direct import execution against repository source code.
-    If import-based execution is unavailable, it gracefully degrades to fallback behavior
-    with actionable error guidance.
-    """
-
-    # -------------------------------------------------------------------------
-    # Initialization and Module Management
-    # -------------------------------------------------------------------------
-    def __init__(self) -> None:
-        self.mode = "import"
-        self._imports: Dict[str, Any] = {}
-        self._import_errors: Dict[str, str] = {}
-        self._modules_to_load = [
-            "climlab",
-            "climlab.convection.akmaev_adjustment",
-            "climlab.convection.convadj",
-            "climlab.convection.emanuel_convection",
-            "climlab.convection.simplified_betts_miller",
-            "climlab.domain.axis",
-            "climlab.domain.domain",
-            "climlab.domain.field",
-            "climlab.domain.initial",
-            "climlab.domain.xarray",
-            "climlab.dynamics.adv_diff_numerics",
-            "climlab.dynamics.advection_diffusion",
-            "climlab.dynamics.budyko_transport",
-            "climlab.dynamics.large_scale_condensation",
-            "climlab.dynamics.meridional_advection_diffusion",
-            "climlab.dynamics.meridional_heat_diffusion",
-            "climlab.dynamics.meridional_moist_diffusion",
-            "climlab.model.column",
-            "climlab.model.ebm",
-            "climlab.model.stommelbox",
-            "climlab.process.diagnostic",
-            "climlab.process.energy_budget",
-            "climlab.process.external_forcing",
-            "climlab.process.implicit",
-            "climlab.process.limiter",
-            "climlab.process.process",
-            "climlab.process.time_dependent_process",
-            "climlab.radiation.absorbed_shorwave",
-            "climlab.radiation.aplusbt",
-            "climlab.radiation.boltzmann",
-            "climlab.radiation.cam3",
-            "climlab.radiation.greygas",
-            "climlab.radiation.insolation",
-            "climlab.radiation.nband",
-            "climlab.radiation.radiation",
-            "climlab.radiation.rrtm.rrtmg",
-            "climlab.radiation.rrtm.rrtmg_lw",
-            "climlab.radiation.rrtm.rrtmg_sw",
-            "climlab.radiation.rrtm.utils",
-            "climlab.radiation.transmissivity",
-            "climlab.radiation.water_vapor",
-            "climlab.solar.insolation",
-            "climlab.solar.orbital.long",
-            "climlab.solar.orbital.table",
-            "climlab.solar.orbital_cycles",
-            "climlab.surface.albedo",
-            "climlab.surface.surface_radiation",
-            "climlab.surface.turbulent",
-            "climlab.utils.constants",
-            "climlab.utils.heat_capacity",
-            "climlab.utils.legendre",
-            "climlab.utils.thermo",
-            "climlab.utils.walk",
-        ]
+    def __init__(self, package_name: str = "climlab") -> None:
+        self.package_name = package_name
+        self.package = None
+        self.loaded_modules: dict[str, Any] = {}
+        self.failed_modules: dict[str, str] = {}
+        self.mode = "normal"
         self._load_modules()
 
-    def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]:
-        data = {"status": status}
-        data.update(kwargs)
-        return data
-
     def _load_modules(self) -> None:
-        for mod in self._modules_to_load:
-            try:
-                self._imports[mod] = importlib.import_module(mod)
-            except Exception as e:
-                self._import_errors[mod] = f"{type(e).__name__}: {e}"
-
-    def health(self) -> Dict[str, Any]:
-        """
-        Return adapter health and import readiness.
-
-        Returns:
-            dict: Unified status dictionary with mode, loaded modules, and import errors.
-        """
-        return self._result(
-            "ok" if len(self._import_errors) == 0 else "partial",
-            mode=self.mode,
-            loaded_count=len(self._imports),
-            failed_count=len(self._import_errors),
-            failed_modules=self._import_errors,
-            guidance=(
-                "Install required dependencies: numpy, scipy. "
-                "Optional: xarray, matplotlib, netCDF4, numba. "
-                "RRTMG modules may require Fortran-compiled extensions."
-            ),
-        )
-
-    # -------------------------------------------------------------------------
-    # Generic Reflection and Invocation Utilities
-    # -------------------------------------------------------------------------
-    def list_module_symbols(self, module_name: str) -> Dict[str, Any]:
-        """
-        List public symbols in a module.
-
-        Parameters:
-            module_name (str): Full module path, e.g., 'climlab.model.ebm'.
-
-        Returns:
-            dict: Status + module symbols or error details.
-        """
         try:
-            mod = self._imports.get(module_name) or importlib.import_module(module_name)
-            names = [n for n in dir(mod) if not n.startswith("_")]
-            return self._result("ok", module=module_name, symbols=names)
-        except Exception as e:
-            return self._result(
-                "error",
-                module=module_name,
-                error=f"{type(e).__name__}: {e}",
-                guidance="Verify module path and required dependencies.",
-            )
-
-    def create_instance(self, module_name: str, class_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create an instance from a class in the specified module.
-
-        Parameters:
-            module_name (str): Full module import path.
-            class_name (str): Class name to instantiate.
-            *args: Positional constructor arguments.
-            **kwargs: Keyword constructor arguments.
-
-        Returns:
-            dict: Status + created object or actionable error guidance.
-        """
-        try:
-            mod = self._imports.get(module_name) or importlib.import_module(module_name)
-            cls = getattr(mod, class_name)
-            instance = cls(*args, **kwargs)
-            return self._result("ok", module=module_name, class_name=class_name, instance=instance)
-        except Exception as e:
-            return self._result(
-                "error",
-                module=module_name,
-                class_name=class_name,
-                error=f"{type(e).__name__}: {e}",
-                traceback=traceback.format_exc(),
-                guidance="Check constructor arguments and optional compiled dependency requirements.",
-            )
-
-    def call_function(self, module_name: str, function_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call a function from the specified module.
-
-        Parameters:
-            module_name (str): Full module import path.
-            function_name (str): Function name to call.
-            *args: Positional function arguments.
-            **kwargs: Keyword function arguments.
-
-        Returns:
-            dict: Status + function result or clear error details.
-        """
-        try:
-            mod = self._imports.get(module_name) or importlib.import_module(module_name)
-            fn = getattr(mod, function_name)
-            if not callable(fn):
-                return self._result(
-                    "error",
-                    module=module_name,
-                    function_name=function_name,
-                    error="Attribute exists but is not callable.",
-                    guidance="Use list_module_symbols() to inspect callable APIs.",
-                )
-            result = fn(*args, **kwargs)
-            return self._result("ok", module=module_name, function_name=function_name, result=result)
-        except Exception as e:
-            return self._result(
-                "error",
-                module=module_name,
-                function_name=function_name,
-                error=f"{type(e).__name__}: {e}",
-                traceback=traceback.format_exc(),
-                guidance="Verify function signature and input types using describe_symbol().",
-            )
-
-    def describe_symbol(self, module_name: str, symbol_name: str) -> Dict[str, Any]:
-        """
-        Describe a symbol signature and docstring for safe invocation.
-
-        Parameters:
-            module_name (str): Full module path.
-            symbol_name (str): Name of class/function/attribute.
+            self.package = importlib.import_module(self.package_name)
+            self.loaded_modules[self.package_name] = self.package
+        except Exception as exc:
+            self.package = None
+            self.mode = "blackbox"
+            self.failed_modules[self.package_name] = str(exc)
+            return
+
+        package_path = getattr(self.package, "__path__", None)
+        if package_path is None:
+            self.mode = "blackbox"
+            return
+
+        for module_info in pkgutil.walk_packages(package_path, prefix=f"{self.package_name}."):
+            module_name = module_info.name
+            try:
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
+            except Exception as exc:
+                self.failed_modules[module_name] = str(exc)
+
+        if len(self.loaded_modules) <= 1:
+            self.mode = "blackbox"
+
+    def health(self) -> dict[str, Any]:
+        if self.package is None:
+            return {
+                "status": "fallback",
+                "mode": "blackbox",
+                "package": self.package_name,
+                "loaded_count": 0,
+                "failed_count": len(self.failed_modules),
+                "errors": self.failed_modules,
+            }
+
+        return {
+            "status": "ok" if self.mode == "normal" else "fallback",
+            "mode": self.mode,
+            "package": self.package_name,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+            "failed_examples": dict(list(self.failed_modules.items())[:10]),
+        }
+
+    def list_modules(self, include_failed: bool = True) -> dict[str, Any]:
+        return {
+            "status": "ok",
+            "mode": self.mode,
+            "loaded": sorted(self.loaded_modules.keys()),
+            "failed": self.failed_modules if include_failed else {},
+        }
+
+    def list_symbols(self, module_name: str, include_private: bool = False) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            try:
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
+            except Exception as exc:
+                return {
+                    "status": "error",
+                    "mode": self.mode,
+                    "module": module_name,
+                    "error": str(exc),
+                }
+
+        symbols: list[dict[str, str]] = []
+        for name, obj in inspect.getmembers(module):
+            if not include_private and name.startswith("_"):
+                continue
+            symbols.append({"name": name, "kind": type(obj).__name__})
+
+        return {
+            "status": "ok",
+            "mode": self.mode,
+            "module": module_name,
+            "count": len(symbols),
+            "symbols": symbols,
+        }
+
+    def call_function(self, module_name: str, function_name: str, kwargs: dict[str, Any]) -> dict[str, Any]:
+        if self.mode == "blackbox":
+            return {
+                "status": "fallback",
+                "mode": self.mode,
+                "error": "Adapter is in blackbox mode; no modules are available.",
+            }
+
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            try:
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
+            except Exception as exc:
+                return {
+                    "status": "error",
+                    "mode": self.mode,
+                    "module": module_name,
+                    "error": str(exc),
+                }
+
+        target = getattr(module, function_name, None)
+        if target is None or not callable(target):
+            return {
+                "status": "error",
+                "mode": self.mode,
+                "module": module_name,
+                "function": function_name,
+                "error": "Function not found or not callable.",
+            }
 
-        Returns:
-            dict: Status + symbol metadata.
-        """
         try:
-            mod = self._imports.get(module_name) or importlib.import_module(module_name)
-            sym = getattr(mod, symbol_name)
-            signature = None
-            if callable(sym):
-                try:
-                    signature = str(inspect.signature(sym))
-                except Exception:
-                    signature = "unavailable"
-            doc = inspect.getdoc(sym) or ""
-            return self._result(
-                "ok",
-                module=module_name,
-                symbol_name=symbol_name,
-                is_callable=callable(sym),
-                signature=signature,
-                doc=doc,
-                type=str(type(sym)),
-            )
-        except Exception as e:
-            return self._result(
-                "error",
-                module=module_name,
-                symbol_name=symbol_name,
-                error=f"{type(e).__name__}: {e}",
-                guidance="Confirm symbol exists and module imports correctly.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Bulk Operations for Full Repository Utilization
-    # -------------------------------------------------------------------------
-    def scan_all_modules(self) -> Dict[str, Any]:
-        """
-        Scan all configured modules and report available public classes and functions.
-
-        Returns:
-            dict: Status + catalog of discovered APIs across climlab modules.
-        """
-        catalog: Dict[str, Dict[str, List[str]]] = {}
-        errors: Dict[str, str] = {}
-        for mod_name in self._modules_to_load:
+            result = target(**kwargs)
+            return {
+                "status": "ok",
+                "mode": self.mode,
+                "module": module_name,
+                "function": function_name,
+                "result": result,
+            }
+        except Exception as exc:
+            return {
+                "status": "error",
+                "mode": self.mode,
+                "module": module_name,
+                "function": function_name,
+                "error": str(exc),
+            }
+
+    def create_instance(self, module_name: str, class_name: str, kwargs: dict[str, Any]) -> dict[str, Any]:
+        if self.mode == "blackbox":
+            return {
+                "status": "fallback",
+                "mode": self.mode,
+                "error": "Adapter is in blackbox mode; no modules are available.",
+            }
+
+        module = self.loaded_modules.get(module_name)
+        if module is None:
             try:
-                mod = self._imports.get(mod_name) or importlib.import_module(mod_name)
-                classes = []
-                functions = []
-                for name, obj in inspect.getmembers(mod):
-                    if name.startswith("_"):
-                        continue
-                    if inspect.isclass(obj):
-                        classes.append(name)
-                    elif inspect.isfunction(obj):
-                        functions.append(name)
-                catalog[mod_name] = {"classes": classes, "functions": functions}
-            except Exception as e:
-                errors[mod_name] = f"{type(e).__name__}: {e}"
-
-        return self._result(
-            "ok" if not errors else "partial",
-            catalog=catalog,
-            errors=errors,
-            guidance="Use create_instance() and call_function() for concrete execution.",
-        )
-
-    def invoke(self, module_name: str, symbol_name: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Unified invoke entrypoint.
-        - If symbol is a class: instantiate it.
-        - If symbol is callable: call it.
-
-        Parameters:
-            module_name (str): Full module path.
-            symbol_name (str): Symbol name in module.
-            *args: Positional args.
-            **kwargs: Keyword args.
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
+            except Exception as exc:
+                return {
+                    "status": "error",
+                    "mode": self.mode,
+                    "module": module_name,
+                    "error": str(exc),
+                }
+
+        target = getattr(module, class_name, None)
+        if target is None or not inspect.isclass(target):
+            return {
+                "status": "error",
+                "mode": self.mode,
+                "module": module_name,
+                "class": class_name,
+                "error": "Class not found.",
+            }
 
-        Returns:
-            dict: Unified status dictionary with invocation result.
-        """
         try:
-            mod = self._imports.get(module_name) or importlib.import_module(module_name)
-            sym = getattr(mod, symbol_name)
-            if inspect.isclass(sym):
-                return self.create_instance(module_name, symbol_name, *args, **kwargs)
-            if callable(sym):
-                return self.call_function(module_name, symbol_name, *args, **kwargs)
-            return self._result(
-                "error",
-                module=module_name,
-                symbol_name=symbol_name,
-                error="Symbol is not callable and not a class.",
-                guidance="Use describe_symbol() to inspect valid operations.",
-            )
-        except Exception as e:
-            return self._result(
-                "error",
-                module=module_name,
-                symbol_name=symbol_name,
-                error=f"{type(e).__name__}: {e}",
-                traceback=traceback.format_exc(),
-                guidance="Ensure correct module path and symbol name.",
-            )
+            instance = target(**kwargs)
+            return {
+                "status": "ok",
+                "mode": self.mode,
+                "module": module_name,
+                "class": class_name,
+                "instance_type": type(instance).__name__,
+                "repr": repr(instance),
+            }
+        except Exception as exc:
+            return {
+                "status": "error",
+                "mode": self.mode,
+                "module": module_name,
+                "class": class_name,
+                "error": str(exc),
+            }

climlab/mcp_output/mcp_plugin/main.py

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

climlab/mcp_output/mcp_plugin/mcp_service.py

@@ -1,292 +1,267 @@
+import json
 import os
 import sys
-from typing import Dict, List, Optional
+from pathlib import Path
+from typing import Any
+
+SOURCE_DIR = Path(__file__).resolve().parents[2] / "source"
+if SOURCE_DIR.exists() and str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
+
+try:
+    from fastmcp import FastMCP
+except Exception:
+    FastMCP = None
+
+try:
+    import numpy as np
+except Exception:
+    np = None
+
+try:
+    import climlab
+except Exception:
+    climlab = None
+
+try:
+    from .adapter import Adapter
+except Exception:
+    try:
+        from adapter import Adapter
+    except Exception:
+        Adapter = None
 
-source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
 
-from fastmcp import FastMCP
+class _FallbackMCP:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tools = []
 
-mcp = FastMCP("climlab_service")
+    def tool(self, name: str, description: str):
+        def decorator(func):
+            self.tools.append({"name": name, "description": description, "fn": func})
+            return func
 
+        return decorator
 
-def _ok(result):
-    return {"success": True, "result": result, "error": None}
+    def run(self, **_: Any) -> None:
+        raise RuntimeError("fastmcp is not installed; cannot run MCP service.")
 
 
-def _err(exc: Exception):
-    return {"success": False, "result": None, "error": str(exc)}
+mcp = FastMCP("climlab-mcp") if FastMCP is not None else _FallbackMCP("climlab-mcp")
+adapter = Adapter("climlab") if Adapter is not None else None
 
 
-@mcp.tool(name="climlab_version_info", description="Get version and basic availability information for climlab.")
-def climlab_version_info() -> Dict:
-    """
-    Return basic package metadata.
+def _response(success: bool, result: Any = None, error: str | None = None) -> dict[str, Any]:
+    return {"success": success, "result": result, "error": error}
 
-    Returns:
-        dict: Standard response dictionary with success/result/error fields.
-    """
-    try:
-        import climlab  # type: ignore
-
-        return _ok(
-            {
-                "version": getattr(climlab, "__version__", "unknown"),
-                "module": "climlab",
-            }
-        )
-    except Exception as exc:
-        return _err(exc)
 
+def _to_python_scalar(value: Any) -> Any:
+    if np is None:
+        return value
+    if isinstance(value, np.generic):
+        return value.item()
+    return value
 
-@mcp.tool(name="create_ebm_model", description="Create an Energy Balance Model (EBM) with configurable diffusion and grid.")
-def create_ebm_model(num_lat: int = 90, D: float = 0.55, water_depth: float = 10.0) -> Dict:
-    """
-    Create a climlab EBM model instance and summarize key diagnostics.
 
-    Args:
-        num_lat: Number of latitude points.
-        D: Diffusivity parameter for meridional heat transport.
-        water_depth: Slab ocean water depth in meters.
-
-    Returns:
-        dict: Standard response dictionary with model summary.
-    """
+def _safe_float(value: Any) -> Any:
     try:
-        from climlab.model.ebm import EBM  # type: ignore
+        return float(value)
+    except Exception:
+        return _to_python_scalar(value)
+
 
-        model = EBM(num_lat=num_lat, D=D, water_depth=water_depth)
+@mcp.tool(name="health_check", description="Check MCP service and dependency availability.")
+def health_check() -> dict[str, Any]:
+    """Return service health and runtime dependency status."""
+    try:
+        adapter_health = adapter.health() if adapter is not None else {"status": "fallback", "reason": "adapter unavailable"}
         result = {
-            "class": model.__class__.__name__,
-            "num_lat": num_lat,
-            "D": D,
-            "water_depth": water_depth,
-            "state_variables": list(model.state.keys()),
-            "diagnostics": list(model.diagnostics.keys()),
+            "service": "climlab-mcp",
+            "transport_default": os.getenv("MCP_TRANSPORT", "stdio"),
+            "dependencies": {
+                "fastmcp": FastMCP is not None,
+                "climlab": climlab is not None,
+                "numpy": np is not None,
+                "adapter": adapter is not None,
+            },
+            "adapter": adapter_health,
         }
-        return _ok(result)
+        return _response(True, result=result)
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-@mcp.tool(name="integrate_ebm", description="Integrate an EBM model forward in time and return global mean surface temperature.")
-def integrate_ebm(num_lat: int = 90, years: float = 1.0, D: float = 0.55, water_depth: float = 10.0) -> Dict:
-    """
-    Run a climlab EBM simulation.
-
-    Args:
-        num_lat: Number of latitude points.
-        years: Integration length in years.
-        D: Diffusivity parameter.
-        water_depth: Slab ocean water depth in meters.
+@mcp.tool(name="get_version", description="Get installed climlab package version.")
+def get_version() -> dict[str, Any]:
+    """Fetch the climlab package version.
 
     Returns:
-        dict: Standard response dictionary with time-integrated summary.
+        Standard MCP response with package name and version.
     """
     try:
-        import numpy as np  # type: ignore
-        from climlab.model.ebm import EBM  # type: ignore
+        if climlab is None:
+            return _response(False, error="climlab is not available")
+        version = getattr(climlab, "__version__", "unknown")
+        return _response(True, result={"package": "climlab", "version": version})
+    except Exception as exc:
+        return _response(False, error=str(exc))
 
-        model = EBM(num_lat=num_lat, D=D, water_depth=water_depth)
-        model.integrate_years(years)
 
-        ts = model.state.get("Ts")
-        if ts is None:
-            return _ok({"message": "Model integrated, but Ts state variable not found."})
-
-        global_mean_ts = float(np.mean(ts))
-        return _ok(
-            {
-                "years": years,
-                "num_lat": num_lat,
-                "global_mean_surface_temp": global_mean_ts,
-            }
-        )
-    except Exception as exc:
-        return _err(exc)
-
-
-@mcp.tool(name="compute_daily_insolation", description="Compute daily mean insolation for latitude/day with optional orbital parameters.")
-def compute_daily_insolation(
-    latitude: float,
-    day_of_year: int,
-    ecc: Optional[float] = None,
-    long_peri: Optional[float] = None,
-    obliquity: Optional[float] = None,
-    solar_constant: float = 1365.2,
-) -> Dict:
-    """
-    Compute daily insolation using climlab solar tools.
+@mcp.tool(name="list_modules", description="List loadable climlab modules discovered by adapter.")
+def list_modules(include_failed: bool = True) -> dict[str, Any]:
+    """List modules discovered by the adapter.
 
     Args:
-        latitude: Latitude in degrees.
-        day_of_year: Day of year (1-365/366).
-        ecc: Orbital eccentricity (optional).
-        long_peri: Longitude of perihelion in degrees (optional).
-        obliquity: Obliquity in degrees (optional).
-        solar_constant: Solar constant in W/m^2.
-
-    Returns:
-        dict: Standard response dictionary with insolation value(s).
+        include_failed: Whether to include failed imports in output.
     """
     try:
-        from climlab.solar.insolation import daily_insolation  # type: ignore
-
-        kwargs = {"S0": solar_constant}
-        if ecc is not None:
-            kwargs["ecc"] = ecc
-        if long_peri is not None:
-            kwargs["long_peri"] = long_peri
-        if obliquity is not None:
-            kwargs["obliquity"] = obliquity
-
-        value = daily_insolation(lat=latitude, day=day_of_year, **kwargs)
-        try:
-            output = float(value)
-        except Exception:
-            output = str(value)
-
-        return _ok(
-            {
-                "latitude": latitude,
-                "day_of_year": day_of_year,
-                "insolation": output,
-            }
-        )
+        if adapter is None:
+            return _response(False, error="adapter is not available")
+        return _response(True, result=adapter.list_modules(include_failed=include_failed))
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-@mcp.tool(name="compute_annual_mean_insolation_profile", description="Compute annual-mean insolation profile across latitude bands.")
-def compute_annual_mean_insolation_profile(
-    latitudes: List[float],
-    days_per_year: int = 365,
-    solar_constant: float = 1365.2,
-) -> Dict:
-    """
-    Compute annual-mean insolation for a list of latitudes.
+@mcp.tool(name="list_symbols", description="List symbols from a specific climlab module.")
+def list_symbols(module_name: str, include_private: bool = False) -> dict[str, Any]:
+    """Inspect a module and return symbol names.
 
     Args:
-        latitudes: List of latitude values in degrees.
-        days_per_year: Number of days for averaging.
-        solar_constant: Solar constant in W/m^2.
-
-    Returns:
-        dict: Standard response dictionary with latitude/insolation pairs.
+        module_name: Fully-qualified module path, e.g. 'climlab.solar.insolation'.
+        include_private: If true, include members starting with underscore.
     """
     try:
-        import numpy as np  # type: ignore
-        from climlab.solar.insolation import daily_insolation  # type: ignore
-
-        days = np.arange(1, days_per_year + 1)
-        profile = []
-        for lat in latitudes:
-            vals = daily_insolation(lat=lat, day=days, S0=solar_constant)
-            mean_val = float(np.mean(vals))
-            profile.append({"latitude": float(lat), "annual_mean_insolation": mean_val})
-        return _ok({"profile": profile})
+        if adapter is None:
+            return _response(False, error="adapter is not available")
+        return _response(True, result=adapter.list_symbols(module_name=module_name, include_private=include_private))
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-@mcp.tool(name="blackbody_olr", description="Compute outgoing longwave radiation using Stefan-Boltzmann relation.")
-def blackbody_olr(temperature: float, emissivity: float = 1.0) -> Dict:
-    """
-    Compute blackbody (or gray-body) outgoing longwave radiation.
+@mcp.tool(name="compute_daily_insolation", description="Compute daily top-of-atmosphere insolation for latitude/day.")
+def compute_daily_insolation(lat: float, day: float, solar_constant: float = 1365.2) -> dict[str, Any]:
+    """Compute daily-average incoming solar radiation.
 
     Args:
-        temperature: Temperature in Kelvin.
-        emissivity: Effective emissivity.
-
-    Returns:
-        dict: Standard response dictionary with OLR in W/m^2.
+        lat: Latitude in degrees (-90 to 90).
+        day: Day of year (calendar day if day_type=1).
+        solar_constant: Solar constant in W/m^2.
     """
     try:
-        from climlab.radiation.boltzmann import Boltzmann  # type: ignore
-
-        proc = Boltzmann(eps=emissivity)
-        olr = float(proc._compute_emission(temperature))
-        return _ok({"temperature": temperature, "emissivity": emissivity, "olr": olr})
+        if climlab is None:
+            return _response(False, error="climlab is not available")
+        values = climlab.solar.insolation.daily_insolation(lat=lat, day=day, S0=solar_constant)
+        arr = np.asarray(values) if np is not None else values
+        result = {
+            "lat": lat,
+            "day": day,
+            "solar_constant": solar_constant,
+            "shape": list(arr.shape) if np is not None else None,
+            "insolation_wm2": _safe_float(arr.squeeze() if np is not None else values),
+        }
+        return _response(True, result=result)
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-@mcp.tool(name="aplusbt_olr", description="Compute linearized OLR using A + B*T parameterization.")
-def aplusbt_olr(temperature: float, A: float = 210.0, B: float = 2.0) -> Dict:
-    """
-    Compute outgoing longwave radiation using A+BT relation.
+@mcp.tool(name="run_ebm_simulation", description="Build and integrate a basic climlab EBM model.")
+def run_ebm_simulation(years: float = 1.0, num_lat: int = 36, water_depth: float = 10.0) -> dict[str, Any]:
+    """Run an Energy Balance Model and return summary diagnostics.
 
     Args:
-        temperature: Temperature in Kelvin.
-        A: Intercept parameter.
-        B: Slope parameter.
-
-    Returns:
-        dict: Standard response dictionary with OLR.
+        years: Number of model years to integrate.
+        num_lat: Number of latitude grid points.
+        water_depth: Mixed-layer depth in meters.
     """
     try:
-        from climlab.radiation.aplusbt import AplusBT  # type: ignore
+        if climlab is None:
+            return _response(False, error="climlab is not available")
+        model = climlab.EBM(num_lat=num_lat, water_depth=water_depth)
+        model.integrate_years(years)
 
-        proc = AplusBT(A=A, B=B)
-        olr = float(A + B * temperature)
-        return _ok({"temperature": temperature, "A": A, "B": B, "olr": olr, "model": proc.__class__.__name__})
+        ts_global = climlab.global_mean(model.Ts)
+        net_global = climlab.global_mean(model.net_radiation)
+        result = {
+            "years": years,
+            "num_lat": num_lat,
+            "water_depth": water_depth,
+            "global_mean_surface_temp_c": _safe_float(ts_global),
+            "global_mean_net_radiation_wm2": _safe_float(net_global),
+            "elapsed_model_years": _safe_float(model.time.get("days_elapsed", 0.0) / 365.2422) if hasattr(model, "time") else None,
+        }
+        return _response(True, result=result)
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-@mcp.tool(name="moist_thermo_diagnostics", description="Compute core moist thermodynamic diagnostics from temperature and pressure.")
-def moist_thermo_diagnostics(temperature: float, pressure: float) -> Dict:
-    """
-    Compute selected thermodynamic diagnostics.
+@mcp.tool(name="run_grey_radiation_column", description="Run a grey-gas radiative column model for a few timesteps.")
+def run_grey_radiation_column(num_lev: int = 30, num_steps: int = 10, water_depth: float = 1.0, insolation: float = 341.3) -> dict[str, Any]:
+    """Run a simple radiative column model.
 
     Args:
-        temperature: Air temperature in Kelvin.
-        pressure: Pressure in hPa.
-
-    Returns:
-        dict: Standard response dictionary with saturation vapor pressure and specific humidity estimates.
+        num_lev: Number of atmospheric levels.
+        num_steps: Number of timesteps to integrate.
+        water_depth: Surface slab water depth (m).
+        insolation: Fixed insolation value Q (W/m^2).
     """
     try:
-        from climlab.utils.thermo import clausius_clapeyron, qsat  # type: ignore
-
-        es = float(clausius_clapeyron(temperature))
-        qsat_val = float(qsat(temperature, pressure))
-        return _ok(
-            {
-                "temperature": temperature,
-                "pressure_hPa": pressure,
-                "saturation_vapor_pressure_Pa": es,
-                "saturation_specific_humidity": qsat_val,
-            }
-        )
+        if climlab is None:
+            return _response(False, error="climlab is not available")
+
+        model = climlab.GreyRadiationModel(num_lev=num_lev, water_depth=water_depth, Q=insolation)
+        model.integrate_steps(num_steps)
+
+        olr = np.asarray(model.OLR).mean() if np is not None else model.OLR
+        asr = np.asarray(model.ASR).mean() if np is not None else model.ASR
+        ts = np.asarray(model.Ts).mean() if np is not None else model.Ts
+
+        result = {
+            "num_lev": num_lev,
+            "num_steps": num_steps,
+            "water_depth": water_depth,
+            "insolation": insolation,
+            "mean_olr_wm2": _safe_float(olr),
+            "mean_asr_wm2": _safe_float(asr),
+            "mean_surface_temp_c": _safe_float(ts),
+        }
+        return _response(True, result=result)
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-@mcp.tool(name="heat_capacity_ocean_slab", description="Compute areal heat capacity of an ocean slab.")
-def heat_capacity_ocean_slab(water_depth: float) -> Dict:
-    """
-    Compute heat capacity for a slab ocean.
+@mcp.tool(name="call_function", description="Call a whitelisted climlab function via adapter.")
+def call_function(module_name: str, function_name: str, kwargs_json: str = "{}") -> dict[str, Any]:
+    """Generic function invocation helper.
 
     Args:
-        water_depth: Slab depth in meters.
-
-    Returns:
-        dict: Standard response dictionary with heat capacity in J m^-2 K^-1.
+        module_name: Fully-qualified module name.
+        function_name: Function name inside the module.
+        kwargs_json: JSON object string with keyword arguments.
     """
     try:
-        from climlab.utils.heat_capacity import ocean  # type: ignore
+        if adapter is None:
+            return _response(False, error="adapter is not available")
+
+        allowed_prefixes = ("climlab.solar.", "climlab.model.", "climlab.utils.")
+        if not module_name.startswith(allowed_prefixes):
+            return _response(False, error="Module is not in whitelist.")
+
+        kwargs_obj = json.loads(kwargs_json)
+        if not isinstance(kwargs_obj, dict):
+            return _response(False, error="kwargs_json must decode to an object")
 
-        cap = float(ocean(water_depth))
-        return _ok({"water_depth": water_depth, "heat_capacity": cap})
+        call_result = adapter.call_function(module_name=module_name, function_name=function_name, kwargs=kwargs_obj)
+        if call_result.get("status") != "ok":
+            return _response(False, result=call_result, error=call_result.get("error", "call failed"))
+        return _response(True, result=call_result)
     except Exception as exc:
-        return _err(exc)
+        return _response(False, error=str(exc))
 
 
-def create_app() -> FastMCP:
+def create_app():
     return mcp
 
 
 if __name__ == "__main__":
-    mcp.run()
+    mcp.run()

climlab/mcp_output/requirements.txt

@@ -1,6 +1,6 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
+climlab
 numpy
 scipy
+xarray
+pooch

climlab/mcp_output/start_mcp.py

@@ -1,30 +1,33 @@
-
-"""
-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 str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
 
 from mcp_service import create_app
 
-def main():
-    """Start FastMCP service"""
+
+def main() -> None:
+    transport = os.getenv("MCP_TRANSPORT", "stdio").strip().lower()
+    port = int(os.getenv("MCP_PORT", "8000"))
+
     app = create_app()
-    # Use environment variable to configure port, default 8000
-    port = int(os.environ.get("MCP_PORT", "8000"))
-    
-    # Choose transport mode based on environment variable
-    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+
+    if transport == "stdio":
+        app.run(transport="stdio")
+        return
+
     if transport == "http":
-        app.run(transport="http", host="0.0.0.0", port=port)
-    else:
-        # Default to STDIO mode
-        app.run()
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port, path="/mcp")
+        except TypeError:
+            app.run(transport="http", host="0.0.0.0", port=port)
+        return
+
+    raise ValueError(f"Unsupported MCP_TRANSPORT: {transport}")
+
 
 if __name__ == "__main__":
     main()

port.json

@@ -1,5 +1 @@
-{
-  "repo": "climlab",
-  "port": 7864,
-  "timestamp": 1773384553
-}
+{"port": 7860}

requirements.txt

@@ -1,6 +1,8 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
+climlab
 numpy
 scipy
+xarray
+pooch
+fastapi
+uvicorn

run_docker.ps1

@@ -1,26 +1,7 @@
-cd $PSScriptRoot
 $ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "climlab" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7864/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "climlab-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
-docker build -t $imageName .
-docker run --rm -p 7864:7860 $imageName
+
+$port = (Get-Content -Raw "port.json" | ConvertFrom-Json).port
+$image = "climlab-mcp"
+
+docker build -t $image .
+docker run --rm -p "${port}:${port}" $image

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:-climlab}"
-mcp_entry_url="${MCP_ENTRY_URL:-http://localhost:7864/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 climlab-mcp .
-docker run --rm -p 7864:7860 climlab-mcp
+
+PORT=$(python3 -c 'import json; print(json.load(open("port.json"))["port"])')
+IMAGE="climlab-mcp"
+
+docker build -t "$IMAGE" .
+docker run --rm -p "${PORT}:${PORT}" "$IMAGE"