Upload 14 files

Dockerfile

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

README.md

@@ -1,10 +1,60 @@
 ---
-title: Rdkit
-emoji: 📊
-colorFrom: purple
-colorTo: blue
+title: rdkit 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
+# rdkit MCP Service
+
+This deployment package wraps RDKit with FastMCP and exposes core cheminformatics tools over MCP.
+
+## Available Tools
+
+- `rdkit_health`
+- `list_rdkit_modules`
+- `parse_smiles`
+- `compute_descriptors`
+- `substructure_match`
+- `tanimoto_similarity`
+- `morgan_fingerprint_bits`
+
+Detailed parameter documentation is in `rdkit/mcp_output/README_MCP.md`.
+
+## Local stdio (Claude Desktop / CLI)
+
+```bash
+cd rdkit/mcp_output
+python mcp_plugin/main.py
+```
+
+or
+
+```bash
+cd rdkit/mcp_output
+MCP_TRANSPORT=stdio python start_mcp.py
+```
+
+## HTTP client connection
+
+Run MCP in HTTP mode:
+
+```bash
+cd rdkit/mcp_output
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+MCP endpoint:
+
+`http://localhost:7860/mcp`
+
+In Docker / HuggingFace Spaces, this service is started by:
+
+```bash
+python rdkit/mcp_output/start_mcp.py
+```
+
+with `MCP_TRANSPORT=http` and `MCP_PORT=7860` preconfigured.

app.py

@@ -1,45 +1,62 @@
-from fastapi import FastAPI
+from __future__ import annotations
+
 import os
 import sys
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "rdkit", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+PLUGIN_DIR = Path(__file__).resolve().parent / "rdkit" / "mcp_output" / "mcp_plugin"
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
+
+app = FastAPI(title="rdkit MCP info app", version="1.0.0")
+PORT = int(os.getenv("PORT", "7860"))
 
-app = FastAPI(
-    title="Rdkit MCP Service",
-    description="Auto-generated MCP service for rdkit",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def root() -> dict[str, Any]:
     return {
-        "service": "Rdkit MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "rdkit-mcp-service",
+        "description": "Supplementary API for MCP service metadata (not MCP transport endpoint).",
+        "mcp_transport": os.getenv("MCP_TRANSPORT", "stdio"),
+        "mcp_port": os.getenv("MCP_PORT", "8000"),
+        "info_app_port": PORT,
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "rdkit MCP"}
+def health() -> dict[str, str]:
+    return {"status": "healthy"}
+
+
+def _extract_tools(mcp_obj: Any) -> list[dict[str, str | None]]:
+    tool_entries = getattr(mcp_obj, "tools", None)
+    if tool_entries is None:
+        return []
+
+    tools: list[dict[str, str | None]] = []
+    if isinstance(tool_entries, dict):
+        iterator = tool_entries.items()
+        for name, tool in iterator:
+            description = getattr(tool, "description", None)
+            tools.append({"name": str(name), "description": description})
+    elif isinstance(tool_entries, list):
+        for tool in tool_entries:
+            name = getattr(tool, "name", str(tool))
+            description = getattr(tool, "description", None)
+            tools.append({"name": name, "description": description})
+
+    return tools
+
 
 @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 list_tools() -> dict[str, Any]:
+    from mcp_service import create_app
+
+    mcp = create_app()
+    return {
+        "count": len(_extract_tools(mcp)),
+        "tools": _extract_tools(mcp),
+    }

port.json

@@ -1,5 +1 @@
-{
-  "repo": "rdkit",
-  "port": 7914,
-  "timestamp": 1773264143
-}
+{"port": 7860}

rdkit/mcp_output/README_MCP.md

@@ -1,128 +1,101 @@
-# RDKit MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This project provides an MCP (Model Context Protocol) service wrapper around RDKit for cheminformatics workflows.  
-It is intended for LLM/tooling integrations that need molecule parsing, descriptor calculation, fingerprinting, similarity, substructure matching, and rendering.
-
-Typical use cases:
-- SMILES/InChI/mol block conversion and validation
-- Molecular descriptors (2D/3D, QED, Lipinski, etc.)
-- Fingerprint generation and similarity search
-- Substructure and MCS matching
-- Conformer/geometry operations
-- Optional utilities for database workflows and feature extraction
-
----
-
-## 2) Installation Method
-
-### System requirements
-- Python 3.10+ recommended
-- RDKit installed with compiled C++ extensions
-- `numpy` (required)
-- Optional: `Pillow`, `pandas`, `scipy`, `matplotlib`, `IPython`, drawing backends (Cairo/Qt), InChI libs
-
-### Recommended install (Conda)
-- conda create -n rdkit-mcp -c conda-forge python=3.11 rdkit numpy
-- conda activate rdkit-mcp
-
-### Optional extras
-- pip install pillow pandas scipy matplotlib ipython
-
-### Verify installation
-- python -c "from rdkit import Chem; print(Chem.MolFromSmiles('CCO') is not None)"
-
----
-
-## 3) Quick Start
-
-### Basic molecule operations
-- Parse: `Chem.MolFromSmiles(...)`
-- Canonicalize: `Chem.CanonSmiles(...)`
-- Substructure: `mol.HasSubstructMatch(query)`
-- Descriptors: `Descriptors.CalcMolDescriptors(mol)`
-- Fingerprints + similarity: `DataStructs.FingerprintSimilarity(fp1, fp2)`
-- Draw: `Draw.MolToImage(mol)`
-
-### Typical MCP (Model Context Protocol) service flow
-1. Client sends molecule input (SMILES/InChI/mol block).
-2. Service validates and normalizes structure.
-3. Service executes requested operation (descriptor/fingerprint/search/render/etc.).
-4. Service returns structured JSON (result, warnings, errors).
-
----
-
-## 4) Available Tools and Endpoints List
-
-Suggested MCP (Model Context Protocol) service endpoints/tools:
-
-- `parse_molecule`
-  - Input: SMILES/InChI/mol block
-  - Output: normalized molecule metadata, canonical SMILES, validation status
-
-- `compute_descriptors`
-  - Output: selected descriptors (e.g., MolWt, LogP, TPSA, QED, counts)
-
-- `generate_fingerprint`
-  - Output: RDKit/Morgan/AtomPair/Torsion fingerprints (configurable params)
-
-- `similarity`
-  - Output: Tanimoto/Dice/Cosine similarity between two molecules/fingerprints
-
-- `substructure_search`
-  - Input: target + SMARTS query
-  - Output: match boolean, atom/bond match indices
-
-- `find_mcs`
-  - Output: maximum common substructure (SMARTS, atom/bond counts)
-
-- `enumerate_stereoisomers`
-  - Output: stereoisomer set and count
-
-- `enumerate_heterocycles`
-  - Output: transformed heterocycle variants
-
-- `standardize_molecule`
-  - Output: cleaned/neutralized/tautomer-ordered form (MolStandardize)
-
-- `draw_molecule`
-  - Output: PNG/SVG payload or file reference
-
-- `reaction_enumeration` (optional)
-  - Output: products from reaction + building blocks
-
-- `feature_finder_cli_bridge` (optional)
-  - Bridges RDKit FeatFinderCLI-style functionality
-
-- `db_create` / `db_search` (optional)
-  - Wraps `Projects/DbCLI/CreateDb.py` and `SearchDb.py` workflows
-
----
-
-## 5) Common Issues and Notes
-
-- RDKit build/runtime mismatch:
-  - Ensure the Python environment uses the same RDKit binary installation.
-- Missing optional drawing deps:
-  - Install Pillow/Cairo/Qt backends for image generation reliability.
-- InChI failures:
-  - Confirm InChI support is present in your RDKit build.
-- Large batch performance:
-  - Prefer batched calls; avoid per-molecule process startup.
-  - Cache parsed molecules/fingerprints when possible.
-- Threading:
-  - Some operations are CPU-heavy; use process pools for throughput-critical services.
-- Error handling:
-  - Return clear parse/validation errors rather than failing silently.
-
----
-
-## 6) Reference Links or Documentation
-
-- RDKit repository: https://github.com/rdkit/rdkit
-- Main README: https://github.com/rdkit/rdkit/blob/master/README.md
-- RDKit Book / docs: https://github.com/rdkit/rdkit/tree/master/Docs/Book
-- Installation guide: https://github.com/rdkit/rdkit/blob/master/Docs/Book/Install.md
-- C++/Python getting started: https://github.com/rdkit/rdkit/blob/master/Docs/Book/GettingStartedInC%2B%2B.md
-- Contrib utilities: https://github.com/rdkit/rdkit/tree/master/Contrib
+# RDKit MCP Tools
+
+This package exposes core RDKit capabilities through an MCP server implemented with FastMCP.
+
+## Exposed Tools
+
+### 1) `rdkit_health`
+- **Purpose**: Returns adapter/module loading health.
+- **Parameters**: none
+
+### 2) `list_rdkit_modules`
+- **Purpose**: Lists loaded and failed RDKit modules.
+- **Parameters**: none
+
+### 3) `parse_smiles`
+- **Purpose**: Parse a SMILES and compute canonical/basic properties.
+- **Parameters**:
+  - `smiles` (str): input SMILES
+  - `sanitize` (bool, default `true`): sanitize molecule on parse
+
+### 4) `compute_descriptors`
+- **Purpose**: Compute common descriptors (MolWt, LogP, TPSA, H-bond counts, rings).
+- **Parameters**:
+  - `smiles` (str): input SMILES
+
+### 5) `substructure_match`
+- **Purpose**: Search SMARTS in target molecule.
+- **Parameters**:
+  - `smiles` (str): target molecule
+  - `smarts` (str): SMARTS query
+  - `uniquify` (bool, default `true`): keep unique matches only
+  - `max_matches` (int, default `100`): upper limit on returned matches
+
+### 6) `tanimoto_similarity`
+- **Purpose**: Compute Tanimoto similarity with Morgan fingerprints.
+- **Parameters**:
+  - `smiles_a` (str): first molecule
+  - `smiles_b` (str): second molecule
+  - `radius` (int, default `2`): Morgan radius
+  - `n_bits` (int, default `2048`): fingerprint bit size
+
+### 7) `morgan_fingerprint_bits`
+- **Purpose**: Return active bit indices from Morgan fingerprint.
+- **Parameters**:
+  - `smiles` (str): input molecule
+  - `radius` (int, default `2`)
+  - `n_bits` (int, default `2048`)
+  - `max_bits` (int, default `256`): max returned bit indices
+
+All tools return:
+
+```json
+{
+  "success": true,
+  "result": {},
+  "error": null
+}
+```
+
+or
+
+```json
+{
+  "success": false,
+  "result": null,
+  "error": "error message"
+}
+```
+
+## Local stdio run
+
+```bash
+python mcp_plugin/main.py
+```
+
+or
+
+```bash
+MCP_TRANSPORT=stdio python start_mcp.py
+```
+
+## HTTP run
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+MCP endpoint is served at:
+
+`http://127.0.0.1:7860/mcp`
+
+## Example tool invocation payload
+
+```json
+{
+  "name": "compute_descriptors",
+  "arguments": {
+    "smiles": "CCO"
+  }
+}
+```

rdkit/mcp_output/mcp_plugin/adapter.py

@@ -1,406 +1,190 @@
-import os
-import sys
+from __future__ import annotations
+
 import importlib
 import inspect
-from typing import Any, Dict, Optional, List
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Any
 
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-sys.path.insert(0, source_path)
+SOURCE_DIR = Path(__file__).resolve().parent.parent.parent / "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 RDKit repository modules discovered via analysis.
-
-    This adapter attempts direct module imports first ("import" mode). If imports fail,
-    it gracefully falls back to "fallback" mode and returns actionable guidance.
-    All public methods return a unified dictionary payload with a required `status` field.
-    """
-
     def __init__(self) -> None:
-        self.mode = "import"
-        self._modules: Dict[str, Optional[Any]] = {}
-        self._import_errors: Dict[str, str] = {}
+        self._target_modules = [
+            "rdkit",
+            "rdkit.Chem",
+            "rdkit.Chem.AllChem",
+            "rdkit.Chem.Descriptors",
+            "rdkit.Chem.rdMolDescriptors",
+            "rdkit.DataStructs",
+        ]
+        self.loaded_modules: dict[str, ModuleType] = {}
+        self.failed_modules: dict[str, str] = {}
+        self.mode = "normal"
         self._load_modules()
 
-    # ==========================================================================
-    # Core utilities
-    # ==========================================================================
+    def _load_modules(self) -> None:
+        for module_name in self._target_modules:
+            try:
+                self.loaded_modules[module_name] = importlib.import_module(module_name)
+            except Exception as exc:
+                self.failed_modules[module_name] = str(exc)
 
-    def _result(
-        self,
-        status: str,
-        message: str,
-        data: Optional[Any] = None,
-        error: Optional[str] = None,
-        guidance: Optional[str] = None,
-    ) -> Dict[str, Any]:
+        if not self.loaded_modules:
+            self.mode = "blackbox"
+
+    def health(self) -> dict[str, Any]:
         return {
-            "status": status,
+            "status": "ok" if self.loaded_modules else "fallback",
             "mode": self.mode,
-            "message": message,
-            "data": data,
-            "error": error,
-            "guidance": guidance,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+            "loaded_modules": sorted(self.loaded_modules.keys()),
+            "failed_modules": self.failed_modules,
+            "source_dir": str(SOURCE_DIR),
+            "source_dir_exists": SOURCE_DIR.exists(),
         }
 
-    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._modules[module_path] = None
-            self._import_errors[module_path] = (
-                f"Failed to import '{module_path}': {exc}"
-            )
-            return None
-
-    def _load_modules(self) -> None:
-        target_modules = [
-            "Regress.Scripts.new_timings",
-            "Web.RDExtras.MolImage",
-            "Web.RDExtras.MolDepict",
-            "Projects.DbCLI.CreateDb",
-            "Projects.DbCLI.SearchDb",
-            "Code.DataManip.MetricMatrixCalc.Wrap.testMatricCalc",
-            "Code.DataStructs.Wrap.testBV",
-            "Code.DataStructs.Wrap.testSparseIntVect",
-            "rdkit.Chem.FeatFinderCLI",
-            "Contrib.MolVS.molvs_cli",
-        ]
-        for module_path in target_modules:
-            self._import_module(module_path)
-
-        if all(self._modules.get(m) is None for m in target_modules):
-            self.mode = "fallback"
-
-    def health(self) -> Dict[str, Any]:
-        """
-        Return adapter import health status.
-
-        Returns:
-            dict: Unified status dict including loaded modules and import errors.
-        """
-        loaded = [k for k, v in self._modules.items() if v is not None]
-        failed = {k: e for k, e in self._import_errors.items()}
-        return self._result(
-            status="ok" if loaded else "degraded",
-            message="Adapter health check completed.",
-            data={"loaded_modules": loaded, "failed_modules": failed},
-            guidance=(
-                "If critical modules failed, ensure C++ extension-backed RDKit build artifacts "
-                "are available under the source tree and required runtime deps are installed."
-            ),
-        )
+    def list_modules(self) -> dict[str, Any]:
+        return {
+            "status": "ok" if self.loaded_modules else "fallback",
+            "mode": self.mode,
+            "loaded": sorted(self.loaded_modules.keys()),
+            "failed": self.failed_modules,
+        }
 
-    def _call_function(
-        self, module_path: str, func_name: str, *args: Any, **kwargs: Any
-    ) -> Dict[str, Any]:
-        module = self._modules.get(module_path)
+    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:
-            return self._result(
-                status="error",
-                message=f"Module '{module_path}' is not available.",
-                error=self._import_errors.get(module_path, "Unknown import failure."),
-                guidance=(
-                    "Verify repository source path injection and local build artifacts. "
-                    "For RDKit modules, ensure compiled extensions and numpy are available."
-                ),
-            )
-        try:
-            func = getattr(module, func_name, None)
-            if func is None or not callable(func):
-                available = [n for n, o in inspect.getmembers(module) if callable(o)]
-                return self._result(
-                    status="error",
-                    message=f"Function '{func_name}' not found in '{module_path}'.",
-                    error="Missing callable in target module.",
-                    data={"available_callables_sample": available[:25]},
-                    guidance="Check function name spelling and module version compatibility.",
+            return {
+                "status": "error",
+                "error": f"module not loaded: {module_name}",
+                "available_modules": sorted(self.loaded_modules.keys()),
+            }
+
+        symbols = []
+        for symbol_name in dir(module):
+            if not include_private and symbol_name.startswith("_"):
+                continue
+            try:
+                obj = getattr(module, symbol_name)
+                symbols.append(
+                    {
+                        "name": symbol_name,
+                        "kind": self._symbol_kind(obj),
+                    }
                 )
-            result = func(*args, **kwargs)
-            return self._result(
-                status="ok",
-                message=f"Function '{func_name}' executed successfully.",
-                data=result,
-            )
-        except Exception as exc:
-            return self._result(
-                status="error",
-                message=f"Function '{func_name}' execution failed.",
-                error=str(exc),
-                guidance=(
-                    "Validate arguments and required environment. "
-                    "If the callable depends on RDKit backend libs, ensure they are compiled."
-                ),
-            )
-
-    # ==========================================================================
-    # Regress.Scripts.new_timings
-    # ==========================================================================
-
-    def call_new_timings_data(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Regress.Scripts.new_timings.data.
-
-        Parameters:
-            *args: Positional arguments forwarded to data().
-            **kwargs: Keyword arguments forwarded to data().
-
-        Returns:
-            dict: Unified status response with callable result or actionable error.
-        """
-        return self._call_function("Regress.Scripts.new_timings", "data", *args, **kwargs)
-
-    # ==========================================================================
-    # Web.RDExtras.MolImage
-    # ==========================================================================
-
-    def call_molimage_gif(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Web.RDExtras.MolImage.gif.
-
-        Parameters:
-            *args: Positional arguments for gif().
-            **kwargs: Keyword arguments for gif().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Web.RDExtras.MolImage", "gif", *args, **kwargs)
-
-    def call_molimage_svg(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Web.RDExtras.MolImage.svg.
-
-        Parameters:
-            *args: Positional arguments for svg().
-            **kwargs: Keyword arguments for svg().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Web.RDExtras.MolImage", "svg", *args, **kwargs)
-
-    # ==========================================================================
-    # Web.RDExtras.MolDepict
-    # ==========================================================================
-
-    def call_moldepict_page(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Web.RDExtras.MolDepict.page.
-
-        Parameters:
-            *args: Positional arguments for page().
-            **kwargs: Keyword arguments for page().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Web.RDExtras.MolDepict", "page", *args, **kwargs)
-
-    # ==========================================================================
-    # Projects.DbCLI.CreateDb
-    # ==========================================================================
-
-    def call_createdb_createdb(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Projects.DbCLI.CreateDb.CreateDb.
+            except Exception:
+                continue
 
-        Parameters:
-            *args: Positional arguments for CreateDb().
-            **kwargs: Keyword arguments for CreateDb().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Projects.DbCLI.CreateDb", "CreateDb", *args, **kwargs)
-
-    def call_createdb_initparser(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Projects.DbCLI.CreateDb.initParser.
-
-        Parameters:
-            *args: Positional arguments for initParser().
-            **kwargs: Keyword arguments for initParser().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Projects.DbCLI.CreateDb", "initParser", *args, **kwargs)
-
-    # ==========================================================================
-    # Projects.DbCLI.SearchDb
-    # ==========================================================================
-
-    def call_searchdb_get_mols_from_sdfile(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Projects.DbCLI.SearchDb.GetMolsFromSDFile.
-
-        Parameters:
-            *args: Positional arguments for GetMolsFromSDFile().
-            **kwargs: Keyword arguments for GetMolsFromSDFile().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Projects.DbCLI.SearchDb", "GetMolsFromSDFile", *args, **kwargs)
-
-    def call_searchdb_get_mols_from_smiles_file(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Projects.DbCLI.SearchDb.GetMolsFromSmilesFile.
-
-        Parameters:
-            *args: Positional arguments for GetMolsFromSmilesFile().
-            **kwargs: Keyword arguments for GetMolsFromSmilesFile().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Projects.DbCLI.SearchDb", "GetMolsFromSmilesFile", *args, **kwargs)
-
-    def call_searchdb_get_neighbor_lists(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Projects.DbCLI.SearchDb.GetNeighborLists.
-
-        Parameters:
-            *args: Positional arguments for GetNeighborLists().
-            **kwargs: Keyword arguments for GetNeighborLists().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Projects.DbCLI.SearchDb", "GetNeighborLists", *args, **kwargs)
-
-    # ==========================================================================
-    # Code.DataManip.MetricMatrixCalc.Wrap.testMatricCalc
-    # ==========================================================================
-
-    def call_testmatriccalc_feq(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Code.DataManip.MetricMatrixCalc.Wrap.testMatricCalc.feq.
-
-        Parameters:
-            *args: Positional arguments for feq().
-            **kwargs: Keyword arguments for feq().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function(
-            "Code.DataManip.MetricMatrixCalc.Wrap.testMatricCalc", "feq", *args, **kwargs
-        )
-
-    # ==========================================================================
-    # Code.DataStructs.Wrap.testBV
-    # ==========================================================================
-
-    def call_testbv_feq(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Code.DataStructs.Wrap.testBV.feq.
-
-        Parameters:
-            *args: Positional arguments for feq().
-            **kwargs: Keyword arguments for feq().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Code.DataStructs.Wrap.testBV", "feq", *args, **kwargs)
-
-    # ==========================================================================
-    # Code.DataStructs.Wrap.testSparseIntVect
-    # ==========================================================================
-
-    def call_testsparseintvect_feq(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Code.DataStructs.Wrap.testSparseIntVect.feq.
-
-        Parameters:
-            *args: Positional arguments for feq().
-            **kwargs: Keyword arguments for feq().
-
-        Returns:
-            dict: Unified status response.
-        """
-        return self._call_function("Code.DataStructs.Wrap.testSparseIntVect", "feq", *args, **kwargs)
-
-    # ==========================================================================
-    # CLI-oriented helper wrappers (from analysis)
-    # ==========================================================================
-
-    def call_featfindercli_module(self, argv: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Execute rdkit.Chem.FeatFinderCLI entry-style behavior if available.
-
-        Parameters:
-            argv: Optional argument list. If omitted, module defaults are used.
+        return {
+            "status": "ok",
+            "module": module_name,
+            "count": len(symbols),
+            "symbols": symbols,
+        }
 
-        Returns:
-            dict: Unified status response.
-        """
-        module_path = "rdkit.Chem.FeatFinderCLI"
-        module = self._modules.get(module_path)
+    def call_function(
+        self,
+        module_name: str,
+        function_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
         if module is None:
-            return self._result(
-                status="error",
-                message="FeatFinderCLI module is unavailable.",
-                error=self._import_errors.get(module_path, "Unknown import failure."),
-                guidance="Confirm RDKit Python modules and compiled backends are importable.",
-            )
+            return {
+                "status": "error",
+                "error": f"module not loaded: {module_name}",
+            }
+
+        if not hasattr(module, function_name):
+            return {
+                "status": "error",
+                "error": f"function not found: {module_name}.{function_name}",
+            }
+
+        fn = getattr(module, function_name)
+        if not callable(fn):
+            return {
+                "status": "error",
+                "error": f"symbol is not callable: {module_name}.{function_name}",
+            }
+
         try:
-            if hasattr(module, "main") and callable(module.main):
-                result = module.main(argv) if argv is not None else module.main()
-                return self._result("ok", "FeatFinderCLI executed.", data=result)
-            return self._result(
-                status="error",
-                message="No callable main() found in FeatFinderCLI.",
-                guidance="Inspect module API and call exported functions directly.",
-            )
+            call_args = args if args is not None else []
+            call_kwargs = kwargs if kwargs is not None else {}
+            result = fn(*call_args, **call_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "function": function_name,
+                "result": result,
+            }
         except Exception as exc:
-            return self._result(
-                status="error",
-                message="FeatFinderCLI execution failed.",
-                error=str(exc),
-                guidance="Check CLI arguments and required feature definition inputs.",
-            )
-
-    def call_molvs_cli_module(self, argv: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Execute Contrib.MolVS.molvs_cli entry-style behavior if available.
-
-        Parameters:
-            argv: Optional argument list for CLI-like execution.
-
-        Returns:
-            dict: Unified status response.
-        """
-        module_path = "Contrib.MolVS.molvs_cli"
-        module = self._modules.get(module_path)
+            return {
+                "status": "error",
+                "error": str(exc),
+                "module": module_name,
+                "function": function_name,
+            }
+
+    def create_instance(
+        self,
+        module_name: str,
+        class_name: str,
+        args: list[Any] | None = None,
+        kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
         if module is None:
-            return self._result(
-                status="error",
-                message="molvs_cli module is unavailable.",
-                error=self._import_errors.get(module_path, "Unknown import failure."),
-                guidance="Ensure Contrib modules exist in source path and dependencies are installed.",
-            )
+            return {
+                "status": "error",
+                "error": f"module not loaded: {module_name}",
+            }
+
+        if not hasattr(module, class_name):
+            return {
+                "status": "error",
+                "error": f"class not found: {module_name}.{class_name}",
+            }
+
+        cls = getattr(module, class_name)
+        if not inspect.isclass(cls):
+            return {
+                "status": "error",
+                "error": f"symbol is not a class: {module_name}.{class_name}",
+            }
+
         try:
-            if hasattr(module, "main") and callable(module.main):
-                result = module.main(argv) if argv is not None else module.main()
-                return self._result("ok", "molvs_cli executed.", data=result)
-            return self._result(
-                status="error",
-                message="No callable main() found in molvs_cli.",
-                guidance="Inspect module for alternate callable entry points.",
-            )
+            call_args = args if args is not None else []
+            call_kwargs = kwargs if kwargs is not None else {}
+            instance = cls(*call_args, **call_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "class": class_name,
+                "instance_type": type(instance).__name__,
+                "instance_repr": repr(instance),
+            }
         except Exception as exc:
-            return self._result(
-                status="error",
-                message="molvs_cli execution failed.",
-                error=str(exc),
-                guidance="Validate CLI arguments and molecule input format.",
-            )
+            return {
+                "status": "error",
+                "error": str(exc),
+                "module": module_name,
+                "class": class_name,
+            }
+
+    @staticmethod
+    def _symbol_kind(obj: Any) -> str:
+        if inspect.isclass(obj):
+            return "class"
+        if inspect.ismodule(obj):
+            return "module"
+        if callable(obj):
+            return "callable"
+        return "value"

rdkit/mcp_output/mcp_plugin/main.py

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

rdkit/mcp_output/mcp_plugin/mcp_service.py

@@ -1,149 +1,308 @@
-import os
-import sys
+from __future__ import annotations
 
-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)
+import sys
+from pathlib import Path
+from typing import Any
 
 from fastmcp import FastMCP
 
-from Regress.Scripts.new_timings import data
-from Web.RDExtras.MolImage import svg, gif
-from Web.RDExtras.MolDepict import page
-from Projects.DbCLI.CreateDb import initParser, CreateDb
-from Projects.DbCLI.SearchDb import GetMolsFromSDFile, GetNeighborLists, GetMolsFromSmilesFile
-from Code.DataManip.MetricMatrixCalc.Wrap.testMatricCalc import feq
-from Code.DataStructs.Wrap.testBV import feq
-from Code.DataStructs.Wrap.testSparseIntVect import feq
+from adapter import Adapter
 
-mcp = FastMCP("unknown_service")
+SOURCE_DIR = Path(__file__).resolve().parent.parent.parent / "source"
+if SOURCE_DIR.exists() and str(SOURCE_DIR) not in sys.path:
+    sys.path.insert(0, str(SOURCE_DIR))
 
+adapter = Adapter()
+mcp = FastMCP("rdkit-mcp-service")
 
-@mcp.tool(name="data", description="Auto-wrapped function data")
-def data(payload: dict):
-    try:
-        if data is None:
-            return {"success": False, "result": None, "error": "Function data is not available"}
-        result = data(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="gif", description="Auto-wrapped function gif")
-def gif(payload: dict):
-    try:
-        if gif is None:
-            return {"success": False, "result": None, "error": "Function gif is not available"}
-        result = gif(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="svg", description="Auto-wrapped function svg")
-def svg(payload: dict):
-    try:
-        if svg is None:
-            return {"success": False, "result": None, "error": "Function svg is not available"}
-        result = svg(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="page", description="Auto-wrapped function page")
-def page(payload: dict):
-    try:
-        if page is None:
-            return {"success": False, "result": None, "error": "Function page is not available"}
-        result = page(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="CreateDb", description="Auto-wrapped function CreateDb")
-def CreateDb(payload: dict):
-    try:
-        if CreateDb is None:
-            return {"success": False, "result": None, "error": "Function CreateDb is not available"}
-        result = CreateDb(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="initParser", description="Auto-wrapped function initParser")
-def initParser(payload: dict):
+
+def _ok(result: Any) -> dict[str, Any]:
+    return {"success": True, "result": result, "error": None}
+
+
+def _err(message: str) -> dict[str, Any]:
+    return {"success": False, "result": None, "error": message}
+
+
+def _safe_smiles_to_mol(smiles: str, sanitize: bool = True):
+    status = adapter.call_function(
+        "rdkit.Chem",
+        "MolFromSmiles",
+        args=[smiles],
+        kwargs={"sanitize": sanitize},
+    )
+    if status["status"] != "ok":
+        raise ValueError(status.get("error", "failed to parse SMILES"))
+    return status["result"]
+
+
+@mcp.tool(name="rdkit_health", description="Get MCP adapter health and module loading status")
+def rdkit_health() -> dict[str, Any]:
+    """Return adapter health information.
+
+    Returns:
+        Standardized response with mode, loaded modules, and failures.
+    """
     try:
-        if initParser is None:
-            return {"success": False, "result": None, "error": "Function initParser is not available"}
-        result = initParser(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="GetMolsFromSDFile", description="Auto-wrapped function GetMolsFromSDFile")
-def GetMolsFromSDFile(payload: dict):
+        return _ok(adapter.health())
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="list_rdkit_modules", description="List loaded and failed RDKit modules")
+def list_rdkit_modules() -> dict[str, Any]:
+    """List module import outcomes.
+
+    Returns:
+        Standardized response containing loaded and failed module lists.
+    """
     try:
-        if GetMolsFromSDFile is None:
-            return {"success": False, "result": None, "error": "Function GetMolsFromSDFile is not available"}
-        result = GetMolsFromSDFile(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="GetMolsFromSmilesFile", description="Auto-wrapped function GetMolsFromSmilesFile")
-def GetMolsFromSmilesFile(payload: dict):
+        return _ok(adapter.list_modules())
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="parse_smiles", description="Parse SMILES and return canonical structure metadata")
+def parse_smiles(smiles: str, sanitize: bool = True) -> dict[str, Any]:
+    """Parse a SMILES string into an RDKit molecule and compute basic properties.
+
+    Args:
+        smiles: Input SMILES string.
+        sanitize: Whether to sanitize molecule during parsing.
+
+    Returns:
+        Canonical SMILES, formula, exact mass, atom count, and bond count.
+    """
     try:
-        if GetMolsFromSmilesFile is None:
-            return {"success": False, "result": None, "error": "Function GetMolsFromSmilesFile is not available"}
-        result = GetMolsFromSmilesFile(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="GetNeighborLists", description="Auto-wrapped function GetNeighborLists")
-def GetNeighborLists(payload: dict):
+        mol = _safe_smiles_to_mol(smiles=smiles, sanitize=sanitize)
+        if mol is None:
+            return _err("invalid SMILES")
+
+        canon = adapter.call_function(
+            "rdkit.Chem",
+            "MolToSmiles",
+            args=[mol],
+            kwargs={"canonical": True},
+        )
+        formula = adapter.call_function("rdkit.Chem.rdMolDescriptors", "CalcMolFormula", args=[mol])
+        exact_wt = adapter.call_function("rdkit.Chem.rdMolDescriptors", "CalcExactMolWt", args=[mol])
+        atom_count = mol.GetNumAtoms()
+        bond_count = mol.GetNumBonds()
+
+        result = {
+            "input_smiles": smiles,
+            "canonical_smiles": canon.get("result") if canon["status"] == "ok" else None,
+            "molecular_formula": formula.get("result") if formula["status"] == "ok" else None,
+            "exact_molecular_weight": exact_wt.get("result") if exact_wt["status"] == "ok" else None,
+            "num_atoms": atom_count,
+            "num_bonds": bond_count,
+        }
+        return _ok(result)
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="compute_descriptors", description="Compute common RDKit molecular descriptors")
+def compute_descriptors(smiles: str) -> dict[str, Any]:
+    """Compute common descriptors for a molecule.
+
+    Args:
+        smiles: Input SMILES string.
+
+    Returns:
+        Dictionary of standard descriptors such as MolWt, LogP, TPSA and H-bond counts.
+    """
     try:
-        if GetNeighborLists is None:
-            return {"success": False, "result": None, "error": "Function GetNeighborLists is not available"}
-        result = GetNeighborLists(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="feq", description="Auto-wrapped function feq")
-def feq(payload: dict):
+        mol = _safe_smiles_to_mol(smiles=smiles, sanitize=True)
+        if mol is None:
+            return _err("invalid SMILES")
+
+        descriptors = {}
+        descriptor_calls = {
+            "MolWt": ("rdkit.Chem.Descriptors", "MolWt"),
+            "ExactMolWt": ("rdkit.Chem.rdMolDescriptors", "CalcExactMolWt"),
+            "LogP": ("rdkit.Chem.Descriptors", "MolLogP"),
+            "TPSA": ("rdkit.Chem.rdMolDescriptors", "CalcTPSA"),
+            "NumHDonors": ("rdkit.Chem.rdMolDescriptors", "CalcNumHBD"),
+            "NumHAcceptors": ("rdkit.Chem.rdMolDescriptors", "CalcNumHBA"),
+            "NumRotatableBonds": ("rdkit.Chem.rdMolDescriptors", "CalcNumRotatableBonds"),
+            "RingCount": ("rdkit.Chem.rdMolDescriptors", "CalcNumRings"),
+        }
+
+        for key, (module_name, function_name) in descriptor_calls.items():
+            call = adapter.call_function(module_name, function_name, args=[mol])
+            descriptors[key] = call.get("result") if call["status"] == "ok" else None
+
+        return _ok({"smiles": smiles, "descriptors": descriptors})
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="substructure_match", description="Run SMARTS substructure search on a target molecule")
+def substructure_match(
+    smiles: str,
+    smarts: str,
+    uniquify: bool = True,
+    max_matches: int = 100,
+) -> dict[str, Any]:
+    """Search for SMARTS pattern matches in a molecule.
+
+    Args:
+        smiles: Target molecule SMILES.
+        smarts: SMARTS query.
+        uniquify: Return unique matches only when True.
+        max_matches: Maximum number of matches to return.
+
+    Returns:
+        Match count and atom index tuples.
+    """
     try:
-        if feq is None:
-            return {"success": False, "result": None, "error": "Function feq is not available"}
-        result = feq(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="feq", description="Auto-wrapped function feq")
-def feq(payload: dict):
+        target = _safe_smiles_to_mol(smiles=smiles, sanitize=True)
+        query_status = adapter.call_function("rdkit.Chem", "MolFromSmarts", args=[smarts])
+        if query_status["status"] != "ok":
+            return _err(query_status.get("error", "failed to parse SMARTS"))
+
+        query = query_status["result"]
+        if query is None:
+            return _err("invalid SMARTS")
+
+        matches = [
+            list(match)
+            for match in target.GetSubstructMatches(query, uniquify=uniquify, maxMatches=max_matches)
+        ]
+        return _ok(
+            {
+                "smiles": smiles,
+                "smarts": smarts,
+                "match_count": len(matches),
+                "matches": matches,
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="tanimoto_similarity", description="Compute Tanimoto similarity between two molecules")
+def tanimoto_similarity(
+    smiles_a: str,
+    smiles_b: str,
+    radius: int = 2,
+    n_bits: int = 2048,
+) -> dict[str, Any]:
+    """Calculate Tanimoto similarity between Morgan fingerprints.
+
+    Args:
+        smiles_a: First molecule SMILES.
+        smiles_b: Second molecule SMILES.
+        radius: Morgan fingerprint radius.
+        n_bits: Morgan fingerprint bit vector size.
+
+    Returns:
+        Similarity score and canonicalized SMILES for both molecules.
+    """
     try:
-        if feq is None:
-            return {"success": False, "result": None, "error": "Function feq is not available"}
-        result = feq(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-@mcp.tool(name="feq", description="Auto-wrapped function feq")
-def feq(payload: dict):
+        mol_a = _safe_smiles_to_mol(smiles=smiles_a, sanitize=True)
+        mol_b = _safe_smiles_to_mol(smiles=smiles_b, sanitize=True)
+        if mol_a is None or mol_b is None:
+            return _err("one or both SMILES are invalid")
+
+        fp_a = adapter.call_function(
+            "rdkit.Chem.AllChem",
+            "GetMorganFingerprintAsBitVect",
+            args=[mol_a, radius],
+            kwargs={"nBits": n_bits},
+        )
+        fp_b = adapter.call_function(
+            "rdkit.Chem.AllChem",
+            "GetMorganFingerprintAsBitVect",
+            args=[mol_b, radius],
+            kwargs={"nBits": n_bits},
+        )
+        if fp_a["status"] != "ok" or fp_b["status"] != "ok":
+            return _err("failed to compute fingerprints")
+
+        sim = adapter.call_function(
+            "rdkit.DataStructs",
+            "TanimotoSimilarity",
+            args=[fp_a["result"], fp_b["result"]],
+        )
+        if sim["status"] != "ok":
+            return _err(sim.get("error", "failed to compute similarity"))
+
+        canon_a = adapter.call_function("rdkit.Chem", "MolToSmiles", args=[mol_a], kwargs={"canonical": True})
+        canon_b = adapter.call_function("rdkit.Chem", "MolToSmiles", args=[mol_b], kwargs={"canonical": True})
+
+        return _ok(
+            {
+                "smiles_a": smiles_a,
+                "smiles_b": smiles_b,
+                "canonical_smiles_a": canon_a.get("result") if canon_a["status"] == "ok" else None,
+                "canonical_smiles_b": canon_b.get("result") if canon_b["status"] == "ok" else None,
+                "radius": radius,
+                "n_bits": n_bits,
+                "tanimoto_similarity": sim["result"],
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+@mcp.tool(name="morgan_fingerprint_bits", description="Generate Morgan fingerprint and return active bit indices")
+def morgan_fingerprint_bits(
+    smiles: str,
+    radius: int = 2,
+    n_bits: int = 2048,
+    max_bits: int = 256,
+) -> dict[str, Any]:
+    """Generate a Morgan fingerprint bit vector and return active bit indices.
+
+    Args:
+        smiles: Input SMILES string.
+        radius: Morgan fingerprint radius.
+        n_bits: Fingerprint bit vector length.
+        max_bits: Maximum active bit indices to return.
+
+    Returns:
+        Active bit indices and count.
+    """
     try:
-        if feq is None:
-            return {"success": False, "result": None, "error": "Function feq is not available"}
-        result = feq(**payload)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        mol = _safe_smiles_to_mol(smiles=smiles, sanitize=True)
+        if mol is None:
+            return _err("invalid SMILES")
 
+        fp_status = adapter.call_function(
+            "rdkit.Chem.AllChem",
+            "GetMorganFingerprintAsBitVect",
+            args=[mol, radius],
+            kwargs={"nBits": n_bits},
+        )
+        if fp_status["status"] != "ok":
+            return _err(fp_status.get("error", "failed to compute fingerprint"))
 
+        fp = fp_status["result"]
+        bits_status = adapter.call_function("rdkit.DataStructs", "BitVectToText", args=[fp])
+        if bits_status["status"] != "ok":
+            return _err(bits_status.get("error", "failed to serialize fingerprint"))
 
-def create_app():
-    """Create and return FastMCP application instance"""
+        bitstring = bits_status["result"]
+        active_bits = [idx for idx, value in enumerate(bitstring) if value == "1"]
+        return _ok(
+            {
+                "smiles": smiles,
+                "radius": radius,
+                "n_bits": n_bits,
+                "active_bit_count": len(active_bits),
+                "active_bits": active_bits[:max_bits],
+                "truncated": len(active_bits) > max_bits,
+            }
+        )
+    except Exception as exc:
+        return _err(str(exc))
+
+
+def create_app() -> FastMCP:
     return mcp
 
+
 if __name__ == "__main__":
-    mcp.run(transport="http", host="0.0.0.0", port=8000)
+    mcp.run()

rdkit/mcp_output/requirements.txt

@@ -1,6 +1,3 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-rdkit compiled Python package (C++ extension modules)
+rdkit
 numpy

rdkit/mcp_output/start_mcp.py

@@ -1,30 +1,29 @@
+from __future__ import annotations
 
-"""
-MCP Service Startup Entry
-"""
-import sys
 import os
+import sys
+from pathlib import Path
 
-project_root = os.path.dirname(os.path.abspath(__file__))
-mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
-if mcp_plugin_dir not in sys.path:
-    sys.path.insert(0, mcp_plugin_dir)
+PLUGIN_DIR = Path(__file__).resolve().parent / "mcp_plugin"
+if 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 == "http":
-        app.run(transport="http", host="0.0.0.0", port=port)
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port)
+        except TypeError:
+            app.run(transport="http", port=port)
     else:
-        # Default to STDIO mode
-        app.run()
+        app.run(transport="stdio")
+
 
 if __name__ == "__main__":
     main()

requirements.txt

@@ -1,6 +1,5 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
 rdkit
 numpy
+fastapi
+uvicorn

run_docker.ps1

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

run_docker.sh

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