Upload 14 files

Dockerfile

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

README.md

@@ -1,10 +1,57 @@
 ---
-title: Deepchem
-emoji: 📈
-colorFrom: purple
-colorTo: purple
+title: deepchem 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
+# deepchem MCP Service
+
+This deployment packages a FastMCP wrapper around the DeepChem Python repository and exposes practical tools for molecular featurization, dataset loading, split generation, and metrics.
+
+## Available Tools
+
+- `health_check`
+- `list_modules`
+- `list_symbols`
+- `featurize_smiles`
+- `split_indices`
+- `classification_metrics`
+- `load_molnet_dataset`
+
+See detailed parameter and usage docs in `deepchem/mcp_output/README_MCP.md`.
+
+## Local stdio (Claude Desktop / CLI)
+
+```bash
+cd deepchem/mcp_output
+python start_mcp.py
+```
+
+Or run plugin entry directly:
+
+```bash
+cd deepchem/mcp_output/mcp_plugin
+python main.py
+```
+
+## HTTP MCP (Docker / remote)
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=8000 python deepchem/mcp_output/start_mcp.py
+```
+
+MCP endpoint:
+
+- `http://localhost:8000/mcp`
+
+## HuggingFace Spaces (Docker)
+
+This package is configured for HF Spaces Docker runtime:
+
+- service port: `7860`
+- Docker entrypoint: `python deepchem/mcp_output/start_mcp.py`
+- HTTP MCP endpoint: `/mcp`

app.py

@@ -1,45 +1,90 @@
-from fastapi import FastAPI
+from __future__ import annotations
+
 import os
 import sys
+import importlib
+from pathlib import Path
+from typing import Any, Dict, List
+
+try:
+    FastAPI = importlib.import_module("fastapi").FastAPI
+except Exception:
+    FastAPI = None
+
+PLUGIN_DIR = (Path(__file__).resolve().parent / "deepchem" / "mcp_output" / "mcp_plugin").resolve()
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
+
+if FastAPI is None:
+    raise RuntimeError("fastapi is required to run app.py. Install dependencies from requirements.txt")
+
+app = FastAPI(title="DeepChem MCP Info API", version="1.0.0")
+
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "deepchem", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+def _extract_tools(mcp_obj: Any) -> List[Dict[str, str]]:
+    tools: List[Dict[str, str]] = []
+
+    direct_tools = getattr(mcp_obj, "tools", None)
+    if isinstance(direct_tools, dict):
+        for key, tool_obj in direct_tools.items():
+            name = getattr(tool_obj, "name", None) or str(key)
+            description = getattr(tool_obj, "description", "")
+            tools.append({"name": str(name), "description": str(description)})
+    elif isinstance(direct_tools, (list, tuple, set)):
+        for tool_obj in direct_tools:
+            name = getattr(tool_obj, "name", None) or getattr(tool_obj, "__name__", "unknown")
+            description = getattr(tool_obj, "description", "") or getattr(tool_obj, "__doc__", "") or ""
+            tools.append({"name": str(name), "description": str(description).strip()})
+
+    if not tools:
+        list_tools_fn = getattr(mcp_obj, "list_tools", None)
+        if callable(list_tools_fn):
+            try:
+                listed = list_tools_fn()
+                if isinstance(listed, (list, tuple)):
+                    for tool_obj in listed:
+                        if isinstance(tool_obj, dict):
+                            tools.append(
+                                {
+                                    "name": str(tool_obj.get("name", "unknown")),
+                                    "description": str(tool_obj.get("description", "")),
+                                }
+                            )
+                        else:
+                            name = getattr(tool_obj, "name", None) or getattr(tool_obj, "__name__", "unknown")
+                            description = getattr(tool_obj, "description", "")
+                            tools.append({"name": str(name), "description": str(description)})
+            except Exception:
+                pass
+
+    dedup: Dict[str, Dict[str, str]] = {}
+    for item in tools:
+        dedup[item["name"]] = item
+    return list(dedup.values())
 
-app = FastAPI(
-    title="Deepchem MCP Service",
-    description="Auto-generated MCP service for deepchem",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def info() -> Dict[str, Any]:
     return {
-        "service": "Deepchem MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "deepchem-mcp",
+        "description": "Supplementary FastAPI info service for the DeepChem MCP deployment.",
+        "mcp_endpoint": "/mcp",
+        "transport_env": os.getenv("MCP_TRANSPORT", "stdio"),
+        "default_port": int(os.getenv("PORT", "7860")),
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "deepchem 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)
+        create_app = importlib.import_module("mcp_service").create_app
+
+        mcp_obj = create_app()
+        return {"status": "ok", "tools": _extract_tools(mcp_obj)}
+    except Exception as exc:
+        return {"status": "error", "tools": [], "error": str(exc)}

deepchem/mcp_output/README_MCP.md

@@ -1,118 +1,149 @@
-# DeepChem MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This MCP (Model Context Protocol) service wraps core DeepChem capabilities for molecular ML workflows, including:
-
-- Dataset loading and preprocessing (CSV/SDF/JSON/image/biological sequence)
-- Featurization (ECFP, graph, SMILES/token, protein/complex features)
-- Model training/inference (Torch, TensorFlow, JAX, sklearn, XGBoost)
-- Benchmarking via MolNet loaders and benchmark runners
-- Evaluation, metrics, splitting, transforms, and utility workflows
-
-Repository: https://github.com/deepchem/deepchem
-
----
-
-## 2) Installation
-
-### Base requirements
-- Python 3.8+ (recommended 3.10/3.11)
-- Core libs: `numpy scipy pandas scikit-learn joblib tqdm`
-
-Install core package:
-- `pip install deepchem`
-
-Install optional stacks as needed:
-- Chemistry: `rdkit`
-- Deep learning: `torch` or `tensorflow` or `jax`
-- Extras: `pytorch-lightning transformers dgl torch-geometric xgboost lightgbm pyscf`
-
-Practical setup pattern:
-1. Create a fresh virtual environment
-2. Install `deepchem`
-3. Add only the backend/features you need (Torch/TensorFlow/JAX + RDKit)
-
----
-
-## 3) Quick Start
-
-### Typical MCP (Model Context Protocol) flow
-1. Load dataset from MolNet (e.g., Tox21, Delaney, QM9)
-2. Apply featurizer and split strategy
-3. Train selected model
-4. Evaluate with DeepChem metrics
-5. Return scores/predictions via MCP (Model Context Protocol) response
-
-### Example task patterns
-- Classification benchmark: use `deepchem.molnet.run_benchmark`
-- Low-data benchmark: use `deepchem.molnet.run_benchmark_low_data`
-- Programmatic loading: use `deepchem.molnet.load_function.*`
-- Data ingest: `deepchem.data.*` loaders
-- Feature extraction: `deepchem.feat.*`
-- Training APIs: `deepchem.models.*` / `deepchem.models.torch_models.*`
-- Evaluation: `deepchem.metrics.*`, `deepchem.utils.evaluate`
-
----
-
-## 4) Available Tools and Endpoints
-
-Recommended MCP (Model Context Protocol) service endpoints:
-
-- `health_check`
-  - Verify runtime, backend availability, and import status.
-
-- `list_capabilities`
-  - Return installed backends/features (Torch/TF/JAX/RDKit, etc.).
-
-- `load_dataset`
-  - Load datasets via MolNet (`load_tox21`, `load_delaney`, `load_qm9`, etc.) or file loaders.
-
-- `featurize_data`
-  - Apply selected featurizer (ECFP, graph conv, SMILES tokenizer, protein/complex, material).
-
-- `split_dataset`
-  - Apply splitters (random, scaffold, stratified, time/PDBBind, task-based).
-
-- `train_model`
-  - Train model families (GraphConv, MPNN, GCN/GAT, multitask MLP, sklearn, GBDT).
-
-- `predict`
-  - Run inference on prepared datasets.
-
-- `evaluate_model`
-  - Compute metrics (ROC-AUC, PRC-AUC, RMSE, MAE, Pearson R², etc.).
-
-- `run_benchmark`
-  - Execute MolNet benchmark workflow using selected model/split/featurizer.
-
-- `run_low_data_benchmark`
-  - Execute low-data benchmark variants.
-
-- `export_results`
-  - Save predictions, scores, and metadata to disk/artifact storage.
-
----
-
-## 5) Common Issues and Notes
-
-- Dependency complexity is medium/high; install only required optional stacks.
-- RDKit is essential for many molecule features and loaders.
-- Torch/TF/JAX features are backend-specific; missing backend causes import/runtime failures.
-- Some benchmark datasets require downloading large files; expect longer setup times.
-- GPU acceleration depends on correct CUDA/backend build compatibility.
-- DGL/PyG-based models need matching versions with your PyTorch installation.
-- For reproducibility, set random seeds and pin package versions.
-
----
-
-## 6) References
-
-- DeepChem repository: https://github.com/deepchem/deepchem
-- Main package docs (in repo): `README.md`, `docs/`
-- Examples: `examples/`
-- MolNet loaders: `deepchem/molnet/load_function/`
-- Benchmarks:  
-  - `python -m deepchem.molnet.run_benchmark`  
-  - `python -m deepchem.molnet.run_benchmark_low_data`
-- Contribution guide: `CONTRIBUTING.md`
+# DeepChem MCP Plugin
+
+This directory contains the MCP service layer for DeepChem.
+
+## Exposed MCP Tools
+
+### 1) `health_check`
+- **Description**: Report availability of runtime dependencies and adapter load status.
+- **Parameters**: none
+- **Example**:
+```json
+{
+  "tool": "health_check",
+  "arguments": {}
+}
+```
+
+### 2) `list_modules`
+- **Description**: List DeepChem-related modules loaded by the adapter.
+- **Parameters**:
+  - `state` (`str`, optional): `all`, `loaded`, or `failed`.
+- **Example**:
+```json
+{
+  "tool": "list_modules",
+  "arguments": {"state": "all"}
+}
+```
+
+### 3) `list_symbols`
+- **Description**: List public symbols in a loaded module.
+- **Parameters**:
+  - `module_name` (`str`, required): for example `deepchem.feat`
+  - `pattern` (`str`, optional): regex filter
+  - `limit` (`int`, optional)
+- **Example**:
+```json
+{
+  "tool": "list_symbols",
+  "arguments": {
+    "module_name": "deepchem.feat",
+    "pattern": "Featurizer",
+    "limit": 50
+  }
+}
+```
+
+### 4) `featurize_smiles`
+- **Description**: Featurize SMILES strings with selected DeepChem featurizer.
+- **Parameters**:
+  - `smiles` (`list[str]`, required)
+  - `featurizer` (`str`, optional): `circular`, `molgraph`, `convmol`
+  - `size` (`int`, optional): fingerprint size for `circular`
+  - `radius` (`int`, optional): fingerprint radius for `circular`
+- **Example**:
+```json
+{
+  "tool": "featurize_smiles",
+  "arguments": {
+    "smiles": ["CCO", "c1ccccc1"],
+    "featurizer": "circular",
+    "size": 1024,
+    "radius": 2
+  }
+}
+```
+
+### 5) `split_indices`
+- **Description**: Generate deterministic train/valid/test split indices.
+- **Parameters**:
+  - `n_samples` (`int`, required)
+  - `frac_train` (`float`, optional)
+  - `frac_valid` (`float`, optional)
+  - `seed` (`int`, optional)
+- **Example**:
+```json
+{
+  "tool": "split_indices",
+  "arguments": {
+    "n_samples": 100,
+    "frac_train": 0.8,
+    "frac_valid": 0.1,
+    "seed": 123
+  }
+}
+```
+
+### 6) `classification_metrics`
+- **Description**: Compute binary classification metrics.
+- **Parameters**:
+  - `y_true` (`list[int]`, required)
+  - `y_score` (`list[float]`, required)
+  - `threshold` (`float`, optional)
+- **Example**:
+```json
+{
+  "tool": "classification_metrics",
+  "arguments": {
+    "y_true": [1, 0, 1, 1],
+    "y_score": [0.9, 0.2, 0.4, 0.7],
+    "threshold": 0.5
+  }
+}
+```
+
+### 7) `load_molnet_dataset`
+- **Description**: Load a DeepChem MolNet dataset using the corresponding loader.
+- **Parameters**:
+  - `dataset_name` (`str`, required): e.g. `delaney`, `tox21`
+  - `featurizer` (`str`, optional)
+  - `splitter` (`str`, optional)
+  - `reload` (`bool`, optional)
+- **Example**:
+```json
+{
+  "tool": "load_molnet_dataset",
+  "arguments": {
+    "dataset_name": "delaney",
+    "featurizer": "ECFP",
+    "splitter": "random",
+    "reload": false
+  }
+}
+```
+
+## Run Locally (stdio)
+
+```bash
+cd deepchem/mcp_output
+python start_mcp.py
+```
+
+Or:
+
+```bash
+cd deepchem/mcp_output/mcp_plugin
+python main.py
+```
+
+## Run as HTTP MCP Service
+
+```bash
+cd deepchem/mcp_output
+MCP_TRANSPORT=http MCP_PORT=8000 python start_mcp.py
+```
+
+MCP HTTP endpoint will be available at:
+
+- `http://localhost:8000/mcp`

deepchem/mcp_output/mcp_plugin/adapter.py

@@ -1,481 +1,235 @@
-import os
-import sys
-import importlib
-from typing import Any, Dict, List, Optional, Tuple
-
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-sys.path.insert(0, source_path)
-
+from __future__ import annotations
 
-class Adapter:
-    """
-    Import-mode adapter for selected DeepChem repository modules.
-
-    This adapter attempts to import and call concrete implementations discovered
-    in repository analysis. It exposes:
-    - Function wrappers for identified callable functions.
-    - Class instance constructors for identified classes.
-    - CLI fallback helpers when import path execution is not available.
+import importlib
+import inspect
+import re
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
 
-    All methods return a unified dictionary with at least:
-    {
-        "status": "success" | "error" | "fallback",
-        ...
-    }
-    """
+SOURCE_DIR = (Path(__file__).resolve().parent / ".." / ".." / "source").resolve()
+if str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
 
-    def __init__(self) -> None:
-        self.mode = "import"
-        self._modules: Dict[str, Any] = {}
-        self._class_instances: Dict[str, Any] = {}
-        self._import_errors: Dict[str, str] = {}
-        self._load_modules()
+CURRENT_PATH = Path(__file__).resolve()
+for parent in CURRENT_PATH.parents:
+    candidate = parent / "source"
+    if candidate.is_dir() and str(candidate) not in sys.path:
+        sys.path.insert(0, str(candidate))
+        break
 
-    # -------------------------------------------------------------------------
-    # Internal utilities
-    # -------------------------------------------------------------------------
-    def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]:
-        payload = {"status": status}
-        payload.update(kwargs)
-        return payload
+try:
+    import deepchem as _deepchem_probe  # type: ignore
+except Exception:
+    _deepchem_probe = None
 
-    def _import_module(self, module_path: str) -> Optional[Any]:
-        try:
-            module = importlib.import_module(module_path)
-            self._modules[module_path] = module
-            return module
-        except Exception as exc:
-            self._import_errors[module_path] = (
-                f"Failed to import '{module_path}'. "
-                f"Verify dependencies and source path. Details: {exc}"
-            )
-            return None
 
-    def _load_modules(self) -> None:
-        module_paths = [
-            "datasets.construct_pdbbind_df",
-            "docs.source.conf",
-            "contrib.visualization.utils",
-            "contrib.DeepMHC.bd13_datasets",
-            "contrib.DeepMHC.deepmhc",
-            "contrib.dragonn.models",
+class Adapter:
+    """Dynamic adapter for loading and invoking target library symbols."""
+
+    def __init__(self, module_candidates: Optional[List[str]] = None) -> None:
+        self.module_candidates = module_candidates or [
+            "deepchem",
+            "deepchem.data",
+            "deepchem.feat",
+            "deepchem.metrics",
+            "deepchem.models",
+            "deepchem.molnet",
+            "deepchem.splits",
+            "deepchem.trans",
+            "deepchem.utils",
+            "deepchem.dock",
+            "deepchem.hyper",
+            "deepchem.rl",
+            "deepchem.metalearning",
         ]
-        for mp in module_paths:
-            self._import_module(mp)
-
-    def health_check(self) -> Dict[str, Any]:
-        """
-        Report adapter readiness and import status.
-
-        Returns:
-            Dict with loaded modules and import errors.
-        """
-        return self._result(
-            "success",
-            mode=self.mode,
-            loaded_modules=sorted(self._modules.keys()),
-            import_errors=self._import_errors,
-            guidance=(
-                "Install optional scientific dependencies (e.g., rdkit, tensorflow, torch) "
-                "if specific modules fail to import."
-            ),
-        )
+        self.loaded_modules: Dict[str, Any] = {}
+        self.failed_modules: Dict[str, str] = {}
+        self.mode = "normal"
+        self.load_modules()
+
+    def load_modules(self) -> Dict[str, Any]:
+        """Load configured modules via importlib with graceful fallbacks."""
+        self.loaded_modules = {}
+        self.failed_modules = {}
+
+        for module_name in self.module_candidates:
+            try:
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
+            except Exception as exc:
+                self.failed_modules[module_name] = str(exc)
+
+        self.mode = "normal" if self.loaded_modules else "blackbox"
+        status = "ok" if self.loaded_modules else "fallback"
+        return {
+            "status": status,
+            "mode": self.mode,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+        }
+
+    def health(self) -> Dict[str, Any]:
+        """Return module loading health and operating mode."""
+        status = "ok" if self.loaded_modules else "fallback"
+        return {
+            "status": status,
+            "mode": self.mode,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+            "loaded_modules": sorted(self.loaded_modules.keys()),
+            "failed_modules": self.failed_modules,
+        }
+
+    def list_modules(self, state: str = "all") -> Dict[str, Any]:
+        """List loaded and/or failed modules.
+
+        Parameters
+        ----------
+        state: str
+            One of ``all``, ``loaded``, or ``failed``.
+        """
+        state = (state or "all").lower()
+        if state not in {"all", "loaded", "failed"}:
+            return {
+                "status": "error",
+                "error": "state must be one of: all, loaded, failed",
+            }
+
+        payload: Dict[str, Any] = {
+            "status": "ok",
+            "mode": self.mode,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+        }
+        if state in {"all", "loaded"}:
+            payload["loaded_modules"] = sorted(self.loaded_modules.keys())
+        if state in {"all", "failed"}:
+            payload["failed_modules"] = self.failed_modules
+        return payload
 
-    def _call_function(
+    def list_symbols(
         self,
-        module_path: str,
-        function_name: str,
-        *args: Any,
-        **kwargs: Any,
+        module_name: str,
+        pattern: str = "",
+        limit: int = 200,
     ) -> Dict[str, Any]:
-        module = self._modules.get(module_path)
-        if module is None:
-            msg = self._import_errors.get(
-                module_path,
-                f"Module '{module_path}' is not available.",
-            )
-            return self._result(
-                "fallback",
-                error=msg,
-                guidance=(
-                    f"Cannot call '{function_name}' because import failed. "
-                    "Check Python path and install missing dependencies."
-                ),
-            )
-        fn = getattr(module, function_name, None)
-        if fn is None:
-            return self._result(
-                "error",
-                error=f"Function '{function_name}' not found in module '{module_path}'.",
-                guidance="Verify repository version and function name.",
-            )
+        """List public symbols in a loaded module, optionally filtered by regex."""
+        if module_name not in self.loaded_modules:
+            return {
+                "status": "error",
+                "error": f"module not loaded: {module_name}",
+            }
+
         try:
-            data = fn(*args, **kwargs)
-            return self._result(
-                "success",
-                module=module_path,
-                function=function_name,
-                data=data,
-            )
+            module = self.loaded_modules[module_name]
+            names = [name for name in dir(module) if not name.startswith("_")]
+            if pattern:
+                matcher = re.compile(pattern)
+                names = [name for name in names if matcher.search(name)]
+            names = sorted(names)[:max(1, limit)]
+            return {
+                "status": "ok",
+                "module": module_name,
+                "count": len(names),
+                "symbols": names,
+            }
         except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Function call failed: {exc}",
-                guidance="Validate function parameters and input data format.",
-            )
+            return {
+                "status": "error",
+                "module": module_name,
+                "error": str(exc),
+            }
 
-    def _create_instance(
+    def call_function(
         self,
-        module_path: str,
-        class_name: str,
-        instance_key: Optional[str] = None,
-        *args: Any,
-        **kwargs: Any,
+        module_name: str,
+        function_name: str,
+        kwargs: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
-        module = self._modules.get(module_path)
-        if module is None:
-            msg = self._import_errors.get(
-                module_path,
-                f"Module '{module_path}' is not available.",
-            )
-            return self._result(
-                "fallback",
-                error=msg,
-                guidance=(
-                    f"Cannot instantiate '{class_name}' because import failed. "
-                    "Check dependency installation."
-                ),
-            )
-        cls = getattr(module, class_name, None)
-        if cls is None:
-            return self._result(
-                "error",
-                error=f"Class '{class_name}' not found in module '{module_path}'.",
-                guidance="Verify repository version and class name.",
-            )
+        """Call a function from a loaded module using keyword arguments only."""
+        kwargs = kwargs or {}
+
+        if self.mode == "blackbox":
+            return {
+                "status": "fallback",
+                "mode": self.mode,
+                "error": "adapter is in blackbox mode; no modules loaded",
+            }
+
+        if module_name not in self.loaded_modules:
+            return {
+                "status": "error",
+                "error": f"module not loaded: {module_name}",
+            }
+
         try:
-            instance = cls(*args, **kwargs)
-            key = instance_key or f"{module_path}.{class_name}"
-            self._class_instances[key] = instance
-            return self._result(
-                "success",
-                module=module_path,
-                class_name=class_name,
-                instance_key=key,
-            )
+            module = self.loaded_modules[module_name]
+            fn = getattr(module, function_name, None)
+            if fn is None or not callable(fn):
+                return {
+                    "status": "error",
+                    "error": f"function not found or not callable: {function_name}",
+                }
+
+            result = fn(**kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "function": function_name,
+                "result": result,
+            }
         except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Class instantiation failed: {exc}",
-                guidance="Check constructor arguments and required runtime dependencies.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Functions: datasets.construct_pdbbind_df
-    # -------------------------------------------------------------------------
-    def call_construct_df(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call datasets.construct_pdbbind_df.construct_df.
-
-        Parameters:
-            *args: Positional arguments forwarded to construct_df.
-            **kwargs: Keyword arguments forwarded to construct_df.
-
-        Returns:
-            Unified status dictionary with function output in 'data' on success.
-        """
-        return self._call_function("datasets.construct_pdbbind_df", "construct_df", *args, **kwargs)
-
-    def call_extract_labels(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call datasets.construct_pdbbind_df.extract_labels.
-
-        Parameters:
-            *args: Positional arguments forwarded to extract_labels.
-            **kwargs: Keyword arguments forwarded to extract_labels.
-
-        Returns:
-            Unified status dictionary with function output in 'data' on success.
-        """
-        return self._call_function("datasets.construct_pdbbind_df", "extract_labels", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # Functions: docs.source.conf
-    # -------------------------------------------------------------------------
-    def call_linkcode_resolve(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call docs.source.conf.linkcode_resolve.
-
-        Parameters:
-            *args: Positional arguments forwarded to linkcode_resolve.
-            **kwargs: Keyword arguments forwarded to linkcode_resolve.
-
-        Returns:
-            Unified status dictionary with resolved link info in 'data' on success.
-        """
-        return self._call_function("docs.source.conf", "linkcode_resolve", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # Functions: contrib.visualization.utils
-    # -------------------------------------------------------------------------
-    def call_combine_mdtraj(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call contrib.visualization.utils.combine_mdtraj.
-
-        Parameters:
-            *args: Positional arguments forwarded to combine_mdtraj.
-            **kwargs: Keyword arguments forwarded to combine_mdtraj.
-
-        Returns:
-            Unified status dictionary containing result in 'data' on success.
-        """
-        return self._call_function("contrib.visualization.utils", "combine_mdtraj", *args, **kwargs)
-
-    def call_convert_lines_to_mdtraj(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call contrib.visualization.utils.convert_lines_to_mdtraj.
-
-        Parameters:
-            *args: Positional arguments forwarded to convert_lines_to_mdtraj.
-            **kwargs: Keyword arguments forwarded to convert_lines_to_mdtraj.
-
-        Returns:
-            Unified status dictionary containing result in 'data' on success.
-        """
-        return self._call_function("contrib.visualization.utils", "convert_lines_to_mdtraj", *args, **kwargs)
-
-    def call_display_images(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call contrib.visualization.utils.display_images.
-
-        Parameters:
-            *args: Positional arguments forwarded to display_images.
-            **kwargs: Keyword arguments forwarded to display_images.
-
-        Returns:
-            Unified status dictionary containing result in 'data' on success.
-        """
-        return self._call_function("contrib.visualization.utils", "display_images", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # Functions: contrib.DeepMHC.bd13_datasets
-    # -------------------------------------------------------------------------
-    def call_featurize(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call contrib.DeepMHC.bd13_datasets.featurize.
-
-        Parameters:
-            *args: Positional arguments forwarded to featurize.
-            **kwargs: Keyword arguments forwarded to featurize.
-
-        Returns:
-            Unified status dictionary containing featurized output in 'data' on success.
-        """
-        return self._call_function("contrib.DeepMHC.bd13_datasets", "featurize", *args, **kwargs)
-
-    def call_load_bd2013_human(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call contrib.DeepMHC.bd13_datasets.load_bd2013_human.
-
-        Parameters:
-            *args: Positional arguments forwarded to load_bd2013_human.
-            **kwargs: Keyword arguments forwarded to load_bd2013_human.
-
-        Returns:
-            Unified status dictionary with loaded dataset artifacts in 'data' on success.
-        """
-        return self._call_function("contrib.DeepMHC.bd13_datasets", "load_bd2013_human", *args, **kwargs)
-
-    def call_to_one_hot_array(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call contrib.DeepMHC.bd13_datasets.to_one_hot_array.
-
-        Parameters:
-            *args: Positional arguments forwarded to to_one_hot_array.
-            **kwargs: Keyword arguments forwarded to to_one_hot_array.
-
-        Returns:
-            Unified status dictionary with encoded array in 'data' on success.
-        """
-        return self._call_function("contrib.DeepMHC.bd13_datasets", "to_one_hot_array", *args, **kwargs)
-
-    # -------------------------------------------------------------------------
-    # Classes: contrib.DeepMHC.deepmhc.DeepMHC
-    # -------------------------------------------------------------------------
-    def create_deepmhc(self, *args: Any, instance_key: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Instantiate contrib.DeepMHC.deepmhc.DeepMHC.
-
-        Parameters:
-            *args: Positional constructor args.
-            instance_key: Optional storage key for later retrieval.
-            **kwargs: Keyword constructor args.
-
-        Returns:
-            Unified status dictionary with 'instance_key' on success.
-        """
-        return self._create_instance(
-            "contrib.DeepMHC.deepmhc",
-            "DeepMHC",
-            instance_key,
-            *args,
-            **kwargs,
-        )
-
-    # -------------------------------------------------------------------------
-    # Classes: contrib.dragonn.models
-    # -------------------------------------------------------------------------
-    def create_motif_score_rnn(self, *args: Any, instance_key: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Instantiate contrib.dragonn.models.MotifScoreRNN.
-
-        Parameters:
-            *args: Positional constructor args.
-            instance_key: Optional storage key for later retrieval.
-            **kwargs: Keyword constructor args.
-
-        Returns:
-            Unified status dictionary with 'instance_key' on success.
-        """
-        return self._create_instance(
-            "contrib.dragonn.models",
-            "MotifScoreRNN",
-            instance_key,
-            *args,
-            **kwargs,
-        )
-
-    def create_gkmsvm(self, *args: Any, instance_key: Optional[str] = None, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Instantiate contrib.dragonn.models.gkmSVM.
-
-        Parameters:
-            *args: Positional constructor args.
-            instance_key: Optional storage key for later retrieval.
-            **kwargs: Keyword constructor args.
-
-        Returns:
-            Unified status dictionary with 'instance_key' on success.
-        """
-        return self._create_instance(
-            "contrib.dragonn.models",
-            "gkmSVM",
-            instance_key,
-            *args,
-            **kwargs,
-        )
-
-    # -------------------------------------------------------------------------
-    # Instance management
-    # -------------------------------------------------------------------------
-    def list_instances(self) -> Dict[str, Any]:
-        """
-        List cached class instances created by this adapter.
-
-        Returns:
-            Unified status dictionary containing instance keys.
-        """
-        return self._result("success", instances=sorted(self._class_instances.keys()))
-
-    def call_instance_method(
+            return {
+                "status": "error",
+                "module": module_name,
+                "function": function_name,
+                "error": str(exc),
+            }
+
+    def create_instance(
         self,
-        instance_key: str,
-        method_name: str,
-        *args: Any,
-        **kwargs: Any,
+        module_name: str,
+        class_name: str,
+        kwargs: Optional[Dict[str, Any]] = None,
     ) -> Dict[str, Any]:
-        """
-        Invoke a method on a previously created instance.
-
-        Parameters:
-            instance_key: Key returned by create_* method.
-            method_name: Target method name on the instance.
-            *args: Positional arguments for the instance method.
-            **kwargs: Keyword arguments for the instance method.
+        """Create a class instance from a loaded module using keyword arguments."""
+        kwargs = kwargs or {}
+
+        if self.mode == "blackbox":
+            return {
+                "status": "fallback",
+                "mode": self.mode,
+                "error": "adapter is in blackbox mode; no modules loaded",
+            }
+
+        if module_name not in self.loaded_modules:
+            return {
+                "status": "error",
+                "error": f"module not loaded: {module_name}",
+            }
 
-        Returns:
-            Unified status dictionary with method result in 'data' on success.
-        """
-        inst = self._class_instances.get(instance_key)
-        if inst is None:
-            return self._result(
-                "error",
-                error=f"Instance '{instance_key}' not found.",
-                guidance="Create the instance first using the matching create_* method.",
-            )
-        method = getattr(inst, method_name, None)
-        if method is None or not callable(method):
-            return self._result(
-                "error",
-                error=f"Method '{method_name}' not found on instance '{instance_key}'.",
-                guidance="Check available methods with dir(instance).",
-            )
         try:
-            data = method(*args, **kwargs)
-            return self._result("success", instance_key=instance_key, method=method_name, data=data)
+            module = self.loaded_modules[module_name]
+            cls = getattr(module, class_name, None)
+            if cls is None or not inspect.isclass(cls):
+                return {
+                    "status": "error",
+                    "error": f"class not found: {class_name}",
+                }
+
+            instance = cls(**kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "class": class_name,
+                "instance_type": type(instance).__name__,
+                "instance_repr": repr(instance),
+            }
         except Exception as exc:
-            return self._result(
-                "error",
-                error=f"Instance method call failed: {exc}",
-                guidance="Validate method parameters and ensure model state is initialized.",
-            )
-
-    # -------------------------------------------------------------------------
-    # CLI fallback helpers
-    # -------------------------------------------------------------------------
-    def cli_run_benchmark(self, extra_args: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Provide CLI fallback guidance for MolNet benchmark execution.
-
-        Parameters:
-            extra_args: Optional CLI args to append.
-
-        Returns:
-            Unified status dictionary with a suggested command.
-        """
-        cmd = ["python", "-m", "source.deepchem.molnet.run_benchmark"] + (extra_args or [])
-        return self._result(
-            "fallback",
-            command=cmd,
-            guidance=(
-                "Use this command in a shell when import-mode execution is unavailable. "
-                "Ensure dependencies are installed and run from project root."
-            ),
-        )
-
-    def cli_run_benchmark_low_data(self, extra_args: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Provide CLI fallback guidance for low-data benchmark workflow.
-
-        Parameters:
-            extra_args: Optional CLI args to append.
-
-        Returns:
-            Unified status dictionary with a suggested command.
-        """
-        cmd = ["python", "-m", "source.deepchem.molnet.run_benchmark_low_data"] + (extra_args or [])
-        return self._result(
-            "fallback",
-            command=cmd,
-            guidance="Run in shell as fallback. Verify low-data benchmark options before execution.",
-        )
-
-    def cli_run_example_benchmark(self, extra_args: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Provide CLI fallback guidance for example benchmark runner.
-
-        Parameters:
-            extra_args: Optional CLI args to append.
-
-        Returns:
-            Unified status dictionary with a suggested command.
-        """
-        cmd = ["python", "-m", "source.examples.benchmark"] + (extra_args or [])
-        return self._result(
-            "fallback",
-            command=cmd,
-            guidance="This is a demo-oriented runner and may be less stable than core benchmark scripts.",
-        )
+            return {
+                "status": "error",
+                "module": module_name,
+                "class": class_name,
+                "error": str(exc),
+            }

deepchem/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
+from .mcp_service import create_app
 
+# Local stdio entry point for Claude Desktop / CLI only.
 if __name__ == "__main__":
-    app = main()
-    app.run()
+    app = create_app()
+    app.run()

deepchem/mcp_output/mcp_plugin/mcp_service.py

@@ -1,240 +1,373 @@
+from __future__ import annotations
+
 import os
 import sys
+from pathlib import Path
+from typing import Any, Dict, List
 
-source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
+SOURCE_DIR = (Path(__file__).resolve().parent / ".." / ".." / "source").resolve()
+if str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
 
-from fastmcp import FastMCP
+CURRENT_PATH = Path(__file__).resolve()
+for parent in CURRENT_PATH.parents:
+    candidate = parent / "source"
+    if candidate.is_dir() and str(candidate) not in sys.path:
+        sys.path.insert(0, str(candidate))
+        break
 
-from datasets.construct_pdbbind_df import construct_df, extract_labels
-from docs.source.conf import linkcode_resolve
-from contrib.visualization.utils import combine_mdtraj, display_images, convert_lines_to_mdtraj
-from contrib.DeepMHC.bd13_datasets import load_bd2013_human, to_one_hot_array, featurize
-from contrib.DeepMHC.deepmhc import DeepMHC
-from contrib.dragonn.models import MotifScoreRNN, gkmSVM
+try:
+    from fastmcp import FastMCP  # type: ignore
+except Exception:
+    FastMCP = None
 
-mcp = FastMCP("unknown_service")
+try:
+    import deepchem as dc  # type: ignore
+except Exception:
+    dc = None
 
+try:
+    import numpy as np  # type: ignore
+except Exception:
+    np = None
+
+try:
+    import pandas as pd  # type: ignore
+except Exception:
+    pd = None
+
+try:
+    import sklearn  # type: ignore
+except Exception:
+    sklearn = None
+
+try:
+    import rdkit  # type: ignore
+except Exception:
+    rdkit = None
+
+from .adapter import Adapter
+
+
+class _FallbackMCP:
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.tools: List[Any] = []
+
+    def tool(self, name: str, description: str):
+        def decorator(fn):
+            fn.name = name
+            fn.description = description
+            self.tools.append(fn)
+            return fn
+
+        return decorator
+
+    def run(self, **_: Any) -> None:
+        raise RuntimeError("fastmcp is not installed. Please install fastmcp to run this service.")
+
+
+mcp = FastMCP("deepchem-mcp-service") if FastMCP is not None else _FallbackMCP("deepchem-mcp-service")
+adapter = Adapter()
+
+
+def _response(success: bool, result: Any = None, error: str | None = None) -> Dict[str, Any]:
+    return {"success": success, "result": result, "error": error}
+
+
+@mcp.tool(name="health_check", description="Report availability of dependencies and adapter health.")
+def health_check() -> Dict[str, Any]:
+    """Get health status for dependencies and dynamic module loader.
+
+    Returns
+    -------
+    dict
+        Standard MCP response with dependency availability and adapter diagnostics.
+    """
+    result = {
+        "service": "deepchem-mcp-service",
+        "transport_default": os.getenv("MCP_TRANSPORT", "stdio"),
+        "dependencies": {
+            "fastmcp": FastMCP is not None,
+            "deepchem": dc is not None,
+            "numpy": np is not None,
+            "pandas": pd is not None,
+            "scikit-learn": sklearn is not None,
+            "rdkit": rdkit is not None,
+        },
+        "adapter": adapter.health(),
+    }
+    return _response(True, result=result, error=None)
+
+
+@mcp.tool(name="list_modules", description="List deepchem-related modules loaded by the adapter.")
+def list_modules(state: str = "all") -> Dict[str, Any]:
+    """List loaded and failed modules.
+
+    Parameters
+    ----------
+    state: str
+        Filter output by module state: ``all``, ``loaded``, or ``failed``.
+    """
+    payload = adapter.list_modules(state=state)
+    if payload.get("status") == "error":
+        return _response(False, result=None, error=payload.get("error", "unknown error"))
+    return _response(True, result=payload, error=None)
+
+
+@mcp.tool(name="list_symbols", description="List public symbols from a loaded deepchem module.")
+def list_symbols(module_name: str, pattern: str = "", limit: int = 120) -> Dict[str, Any]:
+    """List symbol names in a module.
+
+    Parameters
+    ----------
+    module_name: str
+        Fully qualified module name, for example ``deepchem.feat``.
+    pattern: str
+        Optional regular expression to filter symbol names.
+    limit: int
+        Maximum number of symbols to return.
+    """
+    payload = adapter.list_symbols(module_name=module_name, pattern=pattern, limit=limit)
+    if payload.get("status") == "error":
+        return _response(False, result=None, error=payload.get("error", "unknown error"))
+    return _response(True, result=payload, error=None)
+
+
+@mcp.tool(name="featurize_smiles", description="Generate DeepChem features for SMILES strings.")
+def featurize_smiles(
+    smiles: List[str],
+    featurizer: str = "circular",
+    size: int = 1024,
+    radius: int = 2,
+) -> Dict[str, Any]:
+    """Featurize a list of SMILES strings.
+
+    Parameters
+    ----------
+    smiles: list[str]
+        Input SMILES strings.
+    featurizer: str
+        One of ``circular``, ``molgraph``, or ``convmol``.
+    size: int
+        Fingerprint size when using circular fingerprints.
+    radius: int
+        Fingerprint radius when using circular fingerprints.
+    """
+    if dc is None:
+        return _response(False, result=None, error="deepchem is not available")
+
+    if not smiles:
+        return _response(False, result=None, error="smiles cannot be empty")
 
-@mcp.tool(name="construct_df", description="Auto-wrapped function construct_df")
-def construct_df(payload: dict):
-    try:
-        if construct_df is None:
-            return {"success": False, "result": None, "error": "Function construct_df is not available"}
-        result = construct_df(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="extract_labels", description="Auto-wrapped function extract_labels")
-def extract_labels(payload: dict):
-    try:
-        if extract_labels is None:
-            return {"success": False, "result": None, "error": "Function extract_labels is not available"}
-        result = extract_labels(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="linkcode_resolve", description="Auto-wrapped function linkcode_resolve")
-def linkcode_resolve(payload: dict):
-    try:
-        if linkcode_resolve is None:
-            return {"success": False, "result": None, "error": "Function linkcode_resolve is not available"}
-        result = linkcode_resolve(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="combine_mdtraj", description="Auto-wrapped function combine_mdtraj")
-def combine_mdtraj(payload: dict):
-    try:
-        if combine_mdtraj is None:
-            return {"success": False, "result": None, "error": "Function combine_mdtraj is not available"}
-        result = combine_mdtraj(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="convert_lines_to_mdtraj", description="Auto-wrapped function convert_lines_to_mdtraj")
-def convert_lines_to_mdtraj(payload: dict):
-    try:
-        if convert_lines_to_mdtraj is None:
-            return {"success": False, "result": None, "error": "Function convert_lines_to_mdtraj is not available"}
-        result = convert_lines_to_mdtraj(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="display_images", description="Auto-wrapped function display_images")
-def display_images(payload: dict):
-    try:
-        if display_images is None:
-            return {"success": False, "result": None, "error": "Function display_images is not available"}
-        result = display_images(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="featurize", description="Auto-wrapped function featurize")
-def featurize(payload: dict):
-    try:
-        if featurize is None:
-            return {"success": False, "result": None, "error": "Function featurize is not available"}
-        result = featurize(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="load_bd2013_human", description="Auto-wrapped function load_bd2013_human")
-def load_bd2013_human(payload: dict):
-    try:
-        if load_bd2013_human is None:
-            return {"success": False, "result": None, "error": "Function load_bd2013_human is not available"}
-        result = load_bd2013_human(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="to_one_hot_array", description="Auto-wrapped function to_one_hot_array")
-def to_one_hot_array(payload: dict):
     try:
-        if to_one_hot_array is None:
-            return {"success": False, "result": None, "error": "Function to_one_hot_array is not available"}
-        result = to_one_hot_array(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="deepmhc", description="DeepMHC class")
-def deepmhc(*args, **kwargs):
-    """DeepMHC class"""
+        choice = featurizer.lower().strip()
+        if choice == "circular":
+            feat = dc.feat.CircularFingerprint(size=size, radius=radius)
+        elif choice == "molgraph":
+            feat = dc.feat.MolGraphConvFeaturizer()
+        elif choice == "convmol":
+            feat = dc.feat.ConvMolFeaturizer()
+        else:
+            return _response(False, result=None, error="featurizer must be one of: circular, molgraph, convmol")
+
+        values = feat.featurize(smiles)
+        feature_types = [type(item).__name__ for item in values]
+        return _response(
+            True,
+            result={
+                "n_inputs": len(smiles),
+                "n_outputs": len(values),
+                "featurizer": choice,
+                "feature_types": feature_types,
+            },
+            error=None,
+        )
+    except Exception as exc:
+        return _response(False, result=None, error=str(exc))
+
+
+@mcp.tool(name="split_indices", description="Create randomized train/valid/test index splits.")
+def split_indices(
+    n_samples: int,
+    frac_train: float = 0.8,
+    frac_valid: float = 0.1,
+    seed: int = 123,
+) -> Dict[str, Any]:
+    """Create deterministic shuffled indices for dataset splitting.
+
+    Parameters
+    ----------
+    n_samples: int
+        Number of samples in the dataset.
+    frac_train: float
+        Fraction of samples assigned to train.
+    frac_valid: float
+        Fraction assigned to validation.
+    seed: int
+        Random seed for reproducible splits.
+    """
+    if np is None:
+        return _response(False, result=None, error="numpy is not available")
+
+    if n_samples <= 0:
+        return _response(False, result=None, error="n_samples must be positive")
+
+    if frac_train <= 0 or frac_valid < 0 or frac_train + frac_valid >= 1:
+        return _response(False, result=None, error="fractions must satisfy: frac_train > 0, frac_valid >= 0, frac_train + frac_valid < 1")
+
     try:
-        if DeepMHC is None:
-            return {"success": False, "result": None, "error": "Class DeepMHC is not available, path may need adjustment"}
-        
-        # MCP parameter type conversion
-        converted_args = []
-        converted_kwargs = kwargs.copy()
-        
-        # Handle position argument type conversion
-        for arg in args:
-            if isinstance(arg, str):
-                # Try to convert to numeric type
-                try:
-                    if '.' in arg:
-                        converted_args.append(float(arg))
-                    else:
-                        converted_args.append(int(arg))
-                except ValueError:
-                    converted_args.append(arg)
-            else:
-                converted_args.append(arg)
-        
-        # Handle keyword argument type conversion
-        for key, value in converted_kwargs.items():
-            if isinstance(value, str):
-                try:
-                    if '.' in value:
-                        converted_kwargs[key] = float(value)
-                    else:
-                        converted_kwargs[key] = int(value)
-                except ValueError:
-                    pass
-        
-        instance = DeepMHC(*converted_args, **converted_kwargs)
-        return {"success": True, "result": str(instance), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="motifscorernn", description="MotifScoreRNN class")
-def motifscorernn(*args, **kwargs):
-    """MotifScoreRNN class"""
+        rng = np.random.default_rng(seed)
+        indices = np.arange(n_samples)
+        rng.shuffle(indices)
+
+        train_end = int(n_samples * frac_train)
+        valid_end = train_end + int(n_samples * frac_valid)
+
+        train_idx = indices[:train_end].tolist()
+        valid_idx = indices[train_end:valid_end].tolist()
+        test_idx = indices[valid_end:].tolist()
+
+        return _response(
+            True,
+            result={
+                "n_samples": n_samples,
+                "counts": {
+                    "train": len(train_idx),
+                    "valid": len(valid_idx),
+                    "test": len(test_idx),
+                },
+                "indices": {
+                    "train": train_idx,
+                    "valid": valid_idx,
+                    "test": test_idx,
+                },
+            },
+            error=None,
+        )
+    except Exception as exc:
+        return _response(False, result=None, error=str(exc))
+
+
+@mcp.tool(name="classification_metrics", description="Compute basic binary classification metrics.")
+def classification_metrics(
+    y_true: List[int],
+    y_score: List[float],
+    threshold: float = 0.5,
+) -> Dict[str, Any]:
+    """Compute accuracy, precision, recall, and F1 for binary predictions.
+
+    Parameters
+    ----------
+    y_true: list[int]
+        Ground-truth binary labels (0 or 1).
+    y_score: list[float]
+        Predicted scores or probabilities.
+    threshold: float
+        Decision threshold converting scores to class labels.
+    """
+    if np is None:
+        return _response(False, result=None, error="numpy is not available")
+
+    if len(y_true) != len(y_score):
+        return _response(False, result=None, error="y_true and y_score must have the same length")
+
+    if not y_true:
+        return _response(False, result=None, error="input arrays cannot be empty")
+
     try:
-        if MotifScoreRNN is None:
-            return {"success": False, "result": None, "error": "Class MotifScoreRNN is not available, path may need adjustment"}
-        
-        # MCP parameter type conversion
-        converted_args = []
-        converted_kwargs = kwargs.copy()
-        
-        # Handle position argument type conversion
-        for arg in args:
-            if isinstance(arg, str):
-                # Try to convert to numeric type
-                try:
-                    if '.' in arg:
-                        converted_args.append(float(arg))
-                    else:
-                        converted_args.append(int(arg))
-                except ValueError:
-                    converted_args.append(arg)
-            else:
-                converted_args.append(arg)
-        
-        # Handle keyword argument type conversion
-        for key, value in converted_kwargs.items():
-            if isinstance(value, str):
-                try:
-                    if '.' in value:
-                        converted_kwargs[key] = float(value)
-                    else:
-                        converted_kwargs[key] = int(value)
-                except ValueError:
-                    pass
-        
-        instance = MotifScoreRNN(*converted_args, **converted_kwargs)
-        return {"success": True, "result": str(instance), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="gkmsvm", description="gkmSVM class")
-def gkmsvm(*args, **kwargs):
-    """gkmSVM class"""
+        y_true_arr = np.array(y_true, dtype=int)
+        y_pred_arr = (np.array(y_score, dtype=float) >= threshold).astype(int)
+
+        tp = int(np.sum((y_true_arr == 1) & (y_pred_arr == 1)))
+        tn = int(np.sum((y_true_arr == 0) & (y_pred_arr == 0)))
+        fp = int(np.sum((y_true_arr == 0) & (y_pred_arr == 1)))
+        fn = int(np.sum((y_true_arr == 1) & (y_pred_arr == 0)))
+
+        total = len(y_true_arr)
+        accuracy = float((tp + tn) / total)
+        precision = float(tp / (tp + fp)) if (tp + fp) > 0 else 0.0
+        recall = float(tp / (tp + fn)) if (tp + fn) > 0 else 0.0
+        f1 = float(2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0
+
+        return _response(
+            True,
+            result={
+                "threshold": threshold,
+                "confusion_matrix": {"tp": tp, "tn": tn, "fp": fp, "fn": fn},
+                "metrics": {
+                    "accuracy": accuracy,
+                    "precision": precision,
+                    "recall": recall,
+                    "f1": f1,
+                },
+            },
+            error=None,
+        )
+    except Exception as exc:
+        return _response(False, result=None, error=str(exc))
+
+
+@mcp.tool(name="load_molnet_dataset", description="Load a DeepChem MolNet dataset by loader name.")
+def load_molnet_dataset(
+    dataset_name: str,
+    featurizer: str = "ECFP",
+    splitter: str = "random",
+    reload: bool = False,
+) -> Dict[str, Any]:
+    """Load a MolNet dataset from DeepChem.
+
+    Parameters
+    ----------
+    dataset_name: str
+        MolNet dataset key, for example ``delaney`` or ``tox21``.
+    featurizer: str
+        Featurizer string accepted by the corresponding MolNet loader.
+    splitter: str
+        Split strategy accepted by the loader.
+    reload: bool
+        Whether to use/reuse cached dataset artifacts.
+    """
+    if dc is None:
+        return _response(False, result=None, error="deepchem is not available")
+
     try:
-        if gkmSVM is None:
-            return {"success": False, "result": None, "error": "Class gkmSVM is not available, path may need adjustment"}
-        
-        # MCP parameter type conversion
-        converted_args = []
-        converted_kwargs = kwargs.copy()
-        
-        # Handle position argument type conversion
-        for arg in args:
-            if isinstance(arg, str):
-                # Try to convert to numeric type
-                try:
-                    if '.' in arg:
-                        converted_args.append(float(arg))
-                    else:
-                        converted_args.append(int(arg))
-                except ValueError:
-                    converted_args.append(arg)
-            else:
-                converted_args.append(arg)
-        
-        # Handle keyword argument type conversion
-        for key, value in converted_kwargs.items():
-            if isinstance(value, str):
-                try:
-                    if '.' in value:
-                        converted_kwargs[key] = float(value)
-                    else:
-                        converted_kwargs[key] = int(value)
-                except ValueError:
-                    pass
-        
-        instance = gkmSVM(*converted_args, **converted_kwargs)
-        return {"success": True, "result": str(instance), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        loader_name = f"load_{dataset_name.strip().lower()}"
+        loader = getattr(dc.molnet, loader_name, None)
+        if loader is None:
+            return _response(False, result=None, error=f"MolNet loader not found: {loader_name}")
 
+        tasks, datasets, transformers = loader(
+            featurizer=featurizer,
+            splitter=splitter,
+            reload=reload,
+        )
+
+        train_dataset, valid_dataset, test_dataset = datasets
+
+        return _response(
+            True,
+            result={
+                "loader": loader_name,
+                "n_tasks": len(tasks),
+                "task_sample": tasks[:10],
+                "dataset_sizes": {
+                    "train": int(len(train_dataset)),
+                    "valid": int(len(valid_dataset)),
+                    "test": int(len(test_dataset)),
+                },
+                "n_transformers": len(transformers),
+            },
+            error=None,
+        )
+    except Exception as exc:
+        return _response(False, result=None, error=str(exc))
 
 
 def create_app():
-    """Create and return FastMCP application instance"""
+    """Create and return the module-level FastMCP app instance."""
     return mcp
 
+
 if __name__ == "__main__":
-    mcp.run(transport="http", host="0.0.0.0", port=8000)
+    mcp.run()

deepchem/mcp_output/requirements.txt

@@ -1,13 +1,6 @@
-fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-joblib
-numpy<2
+fastmcp>=2.0.0
+deepchem
+numpy
 pandas
 scikit-learn
-sympy
-scipy>=1.10.1
-rdkit
-numpy
-tqdm
+rdkit-pypi

deepchem/mcp_output/start_mcp.py

@@ -1,30 +1,45 @@
+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").resolve()
+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 _safe_port(value: str, default: int = 8000) -> int:
+    try:
+        return int(value)
+    except Exception:
+        return default
+
+
+def main() -> None:
+    transport = os.getenv("MCP_TRANSPORT", "stdio").strip().lower()
+    port = _safe_port(os.getenv("MCP_PORT", "8000"), default=8000)
+
     app = create_app()
-    # Use environment variable to configure port, default 8000
-    port = int(os.environ.get("MCP_PORT", "8000"))
-    
-    # Choose transport mode based on environment variable
-    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+
+    if transport == "stdio":
+        try:
+            app.run(transport="stdio")
+        except TypeError:
+            app.run()
+        return
+
     if transport == "http":
-        app.run(transport="http", host="0.0.0.0", port=port)
-    else:
-        # Default to STDIO mode
-        app.run()
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port)
+        except TypeError:
+            app.run(transport="http", port=port)
+        return
+
+    raise ValueError(f"Unsupported MCP_TRANSPORT: {transport}. Use 'stdio' or 'http'.")
+
 
 if __name__ == "__main__":
     main()

port.json

@@ -1,5 +1 @@
-{
-  "repo": "deepchem",
-  "port": 7928,
-  "timestamp": 1773460115
-}
+{"port": 7860}

requirements.txt

@@ -1,13 +1,8 @@
-fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-joblib
-numpy<2
+fastmcp>=2.0.0
+deepchem
+numpy
 pandas
 scikit-learn
-sympy
-scipy>=1.10.1
-rdkit
-numpy
-tqdm
+rdkit-pypi
+fastapi
+uvicorn

run_docker.ps1

@@ -1,26 +1,10 @@
-cd $PSScriptRoot
 $ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "deepchem" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7928/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "deepchem-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 7928:7860 $imageName
+
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$PortConfig = Get-Content -Raw (Join-Path $ScriptDir "port.json") | ConvertFrom-Json
+$Port = [int]$PortConfig.port
+$ImageName = "deepchem-mcp"
+
+Set-Location $ScriptDir
+docker build -t $ImageName .
+docker run --rm -p "${Port}:7860" $ImageName

run_docker.sh

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