Upload 14 files

Dockerfile

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

README.md

@@ -1,10 +1,54 @@
 ---
-title: Molmass
-emoji: 🏆
-colorFrom: indigo
-colorTo: red
+title: molmass 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
+# molmass MCP Service
+
+This deployment package exposes selected `molmass` capabilities as MCP tools using FastMCP.
+
+## Available tools
+
+- `health_check`
+- `analyze_formula`
+- `formula_summary`
+- `composition_table`
+- `isotopic_spectrum`
+- `element_lookup`
+- `formula_from_fractions`
+- `list_modules`
+
+Detailed tool parameter documentation and examples are in `molmass/mcp_output/README_MCP.md`.
+
+## Local stdio usage
+
+Use this for Claude Desktop / CLI style local MCP connections:
+
+```bash
+cd molmass/mcp_output
+python -m mcp_plugin.main
+```
+
+## HTTP usage (Docker / HF Spaces)
+
+The Docker entry point is `python molmass/mcp_output/start_mcp.py`.
+
+- Transport is controlled by `MCP_TRANSPORT` (`http` in Docker).
+- Port is controlled by `MCP_PORT` (`7860` for HF Spaces).
+- MCP HTTP endpoint is served at `/mcp`.
+
+Example local HTTP run:
+
+```bash
+cd molmass/mcp_output
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+Client connection URL pattern:
+
+- `https://<host>/mcp`

app.py

@@ -1,45 +1,61 @@
-from fastapi import FastAPI
+from __future__ import annotations
+
 import os
 import sys
+import importlib
+from pathlib import Path
+from typing import Any
+
+try:
+    _fastapi = importlib.import_module("fastapi")
+    FastAPI = getattr(_fastapi, "FastAPI", None)
+except Exception:
+    FastAPI = None
+
+CURRENT_DIR = Path(__file__).resolve().parent
+PLUGIN_DIR = CURRENT_DIR / "molmass" / "mcp_output" / "mcp_plugin"
+if str(PLUGIN_DIR) not in sys.path:
+    sys.path.insert(0, str(PLUGIN_DIR))
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "molmass", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
+if FastAPI is None:
+    raise RuntimeError("fastapi is required to run app.py")
+
+app = FastAPI(title="molmass MCP Info API", version="1.0.0")
 
-app = FastAPI(
-    title="Molmass MCP Service",
-    description="Auto-generated MCP service for molmass",
-    version="1.0.0"
-)
 
 @app.get("/")
-def root():
+def root() -> dict[str, Any]:
     return {
-        "service": "Molmass MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "molmass-mcp",
+        "description": "Supplementary info API for local development.",
+        "mcp_entrypoint": "molmass/mcp_output/start_mcp.py",
+        "mcp_http_path": "/mcp",
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "molmass MCP"}
+def health() -> dict[str, str]:
+    return {"status": "healthy"}
+
 
 @app.get("/tools")
-def list_tools():
-    try:
-        from mcp_service import create_app
-        mcp_app = create_app()
-        tools = []
-        for tool_name, tool_func in mcp_app.tools.items():
-            tools.append({
-                "name": tool_name,
-                "description": tool_func.__doc__ or "No description available"
-            })
-        return {"tools": tools}
-    except Exception as e:
-        return {"error": f"Failed to load tools: {str(e)}"}
+def tools() -> dict[str, Any]:
+    create_app = importlib.import_module("mcp_service").create_app
+
+    mcp = create_app()
+    tool_items = []
+    for tool in getattr(mcp, "tools", []):
+        tool_items.append(
+            {
+                "name": getattr(tool, "name", getattr(tool, "__name__", "unknown")),
+                "description": getattr(tool, "description", ""),
+            }
+        )
+    return {"count": len(tool_items), "tools": tool_items}
+
 
 if __name__ == "__main__":
     import uvicorn
-    port = int(os.environ.get("PORT", 7860))
+
+    port = int(os.getenv("PORT", "7860"))
     uvicorn.run(app, host="0.0.0.0", port=port)

molmass/mcp_output/README_MCP.md

@@ -1,128 +1,133 @@
-# molmass MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This service wraps the `molmass` chemistry engine to provide mass/formula analysis through MCP (Model Context Protocol).  
-It is designed for developer use cases such as:
-
-- Molecular formula parsing and validation
-- Monoisotopic, average, and nominal mass calculation
-- Elemental composition reporting
-- Isotopic spectrum generation
-- Sequence/oligo/peptide-derived formula conversion
-
-Primary integration target: `source.molmass.molmass` (or `deployment.molmass.source.molmass` in alternate runtime layouts).
-
----
-
-## 2) Installation
-
-### Requirements
-- Python 3.x
-- Standard library only for core functionality
-- Optional:
-  - `tkinter` for GUI module (`elements_gui.py`)
-  - CGI/web runtime for `web.py`
-
-### Install from PyPI
-pip install molmass
-
-### Install from source
-git clone https://github.com/cgohlke/molmass.git  
-cd molmass  
-pip install .
-
----
-
-## 3) Quick Start
-
-### Recommended imports
-from source.molmass.molmass import analyze, Formula, from_string, from_sequence, from_peptide, from_oligo
-
-### Typical usage patterns
-- Parse and analyze a formula string:
-  - `analyze("C8H10N4O2")`
-- Create a formula object and compute masses/composition:
-  - `Formula("H2O")`
-- Build formulas from biological sequences:
-  - `from_sequence(...)`, `from_peptide(...)`, `from_oligo(...)`
-- Build from generic text input:
-  - `from_string(...)`
-
-### CLI execution
-python -m source.molmass
-
-(Depending on packaging/runtime, module path may be `molmass` or `deployment.molmass.source.molmass`.)
-
----
-
-## 4) Available Tools and Endpoints
-
-For MCP (Model Context Protocol) service design, expose these practical endpoints:
-
-- `analyze_formula`
-  - Backed by: `analyze`, `Formula`
-  - Input: formula string
-  - Output: parsed formula details, masses, composition, optional spectrum summary
-
-- `parse_formula`
-  - Backed by: `read_formula`, `split_formula`, `split_parts`, `split_charge`
-  - Input: formula string
-  - Output: normalized/parsed structure, charge handling, validation errors
-
-- `calculate_mass`
-  - Backed by: `Formula` properties/methods
-  - Input: formula string
-  - Output: monoisotopic/average/nominal masses
-
-- `composition_from_formula`
-  - Backed by: `Formula`, `Composition`
-  - Input: formula string
-  - Output: element counts and relative contributions
-
-- `spectrum_from_formula`
-  - Backed by: `Spectrum`, `SpectrumEntry`
-  - Input: formula string, optional limits/precision
-  - Output: isotope peaks and intensities
-
-- `formula_from_sequence`
-  - Backed by: `from_sequence`, `from_peptide`, `from_oligo`
-  - Input: sequence + mode/options
-  - Output: derived molecular formula and optional mass results
-
-- `formula_from_elements_or_fractions`
-  - Backed by: `from_elements`, `from_fractions`
-  - Input: element map or mass fractions
-  - Output: reconstructed/estimated formula
-
----
-
-## 5) Common Issues and Notes
-
-- Import path differences:
-  - Prefer `source.molmass.*`
-  - Fallback to `deployment.molmass.source.*` if required by environment
-
-- Error handling:
-  - Catch `FormulaError` for invalid syntax or unsupported input
-
-- Precision/output formatting:
-  - Use helper behavior such as `precision_digits`, `join_charge`, `hill_sorted` where needed for consistent output
-
-- Optional modules:
-  - `elements_gui.py` requires GUI support (`tkinter`)
-  - `web.py` is useful as interface reference but not the preferred core MCP (Model Context Protocol) hook
-
-- Performance:
-  - Core operations are lightweight for typical formula queries
-  - Isotopic spectrum generation can be heavier for large molecules
-
----
-
-## 6) Reference Links
-
-- Repository: https://github.com/cgohlke/molmass
-- Core engine module: `molmass/molmass.py`
-- Element data: `molmass/elements.py`
-- Web adapter reference: `molmass/web.py`
-- Tests/examples: `tests/test_molmass.py`
+# molmass MCP Plugin
+
+This directory contains an MCP wrapper around the `molmass` Python package.
+
+## Exposed Tools
+
+1. **health_check**
+   - Parameters: none
+   - Returns dependency and adapter health status.
+   - Example:
+     ```json
+     {"name": "health_check", "arguments": {}}
+     ```
+
+2. **analyze_formula**
+   - Parameters:
+     - `formula: str`
+     - `maxatoms: int = 512`
+     - `min_intensity: float = 0.0001`
+     - `debug: bool = false`
+   - Returns text report (formula, masses, composition, spectrum summary).
+   - Example:
+     ```json
+     {
+       "name": "analyze_formula",
+       "arguments": {"formula": "C8H10N4O2", "min_intensity": 0.01}
+     }
+     ```
+
+3. **formula_summary**
+   - Parameters:
+     - `formula: str`
+     - `allow_empty: bool = false`
+   - Returns key notation and mass fields.
+   - Example:
+     ```json
+     {
+       "name": "formula_summary",
+       "arguments": {"formula": "H2O"}
+     }
+     ```
+
+4. **composition_table**
+   - Parameters:
+     - `formula: str`
+     - `isotopic: bool = true`
+   - Returns composition rows (`element`, `count`, `relative_mass`, `fraction`).
+   - Example:
+     ```json
+     {
+       "name": "composition_table",
+       "arguments": {"formula": "C2H6O"}
+     }
+     ```
+
+5. **isotopic_spectrum**
+   - Parameters:
+     - `formula: str`
+     - `min_fraction: float = 1e-9`
+     - `min_intensity: float = 1e-9`
+     - `max_peaks: int = 30`
+   - Returns isotopic peak list.
+   - Example:
+     ```json
+     {
+       "name": "isotopic_spectrum",
+       "arguments": {"formula": "C2H6O", "max_peaks": 6}
+     }
+     ```
+
+6. **element_lookup**
+   - Parameters:
+     - `identifier: str` (symbol, name, or atomic number)
+   - Returns periodic element properties.
+   - Example:
+     ```json
+     {
+       "name": "element_lookup",
+       "arguments": {"identifier": "C"}
+     }
+     ```
+
+7. **formula_from_fractions**
+   - Parameters:
+     - `fractions: dict[str, float]`
+     - `maxcount: int = 10`
+     - `precision: float = 0.0001`
+   - Returns inferred formula from elemental mass fractions.
+   - Example:
+     ```json
+     {
+       "name": "formula_from_fractions",
+       "arguments": {"fractions": {"H": 0.112, "O": 0.888}}
+     }
+     ```
+
+8. **list_modules**
+   - Parameters:
+     - `include_failed: bool = true`
+   - Returns modules discovered by adapter.
+   - Example:
+     ```json
+     {
+       "name": "list_modules",
+       "arguments": {"include_failed": true}
+     }
+     ```
+
+All tools return this shape:
+
+```json
+{
+  "success": true,
+  "result": {},
+  "error": null
+}
+```
+
+## Local stdio run
+
+```bash
+cd molmass/mcp_output
+python -m mcp_plugin.main
+```
+
+## HTTP transport run
+
+```bash
+cd molmass/mcp_output
+MCP_TRANSPORT=http MCP_PORT=7860 python start_mcp.py
+```
+
+The MCP HTTP endpoint is served at `/mcp`.

molmass/mcp_output/mcp_plugin/__init__.py

@@ -0,0 +1 @@
+

molmass/mcp_output/mcp_plugin/adapter.py

@@ -1,467 +1,179 @@
-import os
+from __future__ import annotations
+
+import importlib
+import pkgutil
 import sys
-import inspect
-import traceback
-from typing import Any, Dict, Optional, List
+from pathlib import Path
+from typing import Any
 
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-sys.path.insert(0, source_path)
+CURRENT_DIR = Path(__file__).resolve().parent
+SOURCE_DIR = CURRENT_DIR.parents[1] / "source"
+ALT_SOURCE_DIR = CURRENT_DIR.parents[5] / "workspace" / "molmass" / "source"
+for candidate in (SOURCE_DIR, ALT_SOURCE_DIR):
+    if candidate.exists() and str(candidate) not in sys.path:
+        sys.path.insert(0, str(candidate))
 
 
 class Adapter:
-    """
-    MCP Import Mode Adapter for molmass repository.
-
-    This adapter prioritizes direct module import and provides graceful CLI fallback.
-    It exposes dedicated methods for discovered entry points:
-      - source.molmass.__main__ (module execution dispatcher)
-      - source.molmass.molmass.main (core CLI handler)
-      - source.molmass.web.main (web/CGI-style entrypoint)
-
-    All public methods return a unified dictionary format:
-      {
-        "status": "success" | "error" | "fallback",
-        ...
-      }
-    """
-
-    # -------------------------------------------------------------------------
-    # Initialization and module management
-    # -------------------------------------------------------------------------
-
-    def __init__(self) -> None:
-        """
-        Initialize adapter state, import mode, and lazy-load targets.
+    """Dynamic module adapter for the target package."""
 
-        Attributes:
-            mode (str): Adapter operation mode, fixed to "import".
-            modules (dict): Loaded module references.
-            functions (dict): Loaded callable references.
-            import_errors (list): Detailed import errors.
-        """
-        self.mode: str = "import"
-        self.modules: Dict[str, Any] = {}
-        self.functions: Dict[str, Any] = {}
-        self.import_errors: List[Dict[str, str]] = []
-        self._initialize_imports()
+    def __init__(self, package_name: str) -> None:
+        self.package_name = package_name
+        self.mode = "normal"
+        self.loaded_modules: dict[str, Any] = {}
+        self.failed_modules: dict[str, str] = {}
+        self._load_all_modules()
 
-    def _initialize_imports(self) -> None:
-        """
-        Attempt to import all identified modules and function entrypoints.
-
-        Uses full package paths from analysis and stores detailed errors for
-        graceful fallback behavior.
-        """
-        import_targets = [
-            ("source.molmass.__main__", None),
-            ("source.molmass.molmass", "main"),
-            ("source.molmass.web", "main"),
-        ]
-
-        for module_path, function_name in import_targets:
+    def _load_all_modules(self) -> None:
+        try:
+            root_module = importlib.import_module(self.package_name)
+            self.loaded_modules[self.package_name] = root_module
+        except Exception as exc:
+            self.failed_modules[self.package_name] = f"{type(exc).__name__}: {exc}"
+            self.mode = "blackbox"
+            return
+
+        package = self.loaded_modules[self.package_name]
+        package_paths = getattr(package, "__path__", None)
+        if not package_paths:
+            if len(self.loaded_modules) == 0:
+                self.mode = "blackbox"
+            return
+
+        prefix = f"{self.package_name}."
+        for module_info in pkgutil.walk_packages(package_paths, prefix=prefix):
+            module_name = module_info.name
             try:
-                module = __import__(module_path, fromlist=["*"])
-                self.modules[module_path] = module
-                if function_name:
-                    func = getattr(module, function_name, None)
-                    if callable(func):
-                        self.functions[f"{module_path}.{function_name}"] = func
-                    else:
-                        self.import_errors.append(
-                            {
-                                "module": module_path,
-                                "error": f"Function '{function_name}' not found or not callable.",
-                            }
-                        )
+                self.loaded_modules[module_name] = importlib.import_module(module_name)
             except Exception as exc:
-                self.import_errors.append(
-                    {
-                        "module": module_path,
-                        "error": f"{type(exc).__name__}: {exc}",
-                    }
-                )
+                self.failed_modules[module_name] = f"{type(exc).__name__}: {exc}"
 
-    def health_check(self) -> Dict[str, Any]:
-        """
-        Report adapter health and import readiness.
+        if len(self.loaded_modules) == 0:
+            self.mode = "blackbox"
 
-        Returns:
-            dict: Unified status dictionary with loaded modules/functions and import diagnostics.
-        """
-        try:
+    def health(self) -> dict[str, Any]:
+        status = "ok" if self.loaded_modules else "fallback"
+        return {
+            "status": status,
+            "mode": self.mode,
+            "package": self.package_name,
+            "loaded_count": len(self.loaded_modules),
+            "failed_count": len(self.failed_modules),
+        }
+
+    def list_modules(self, include_failed: bool = True) -> dict[str, Any]:
+        result: dict[str, Any] = {
+            "status": "ok" if self.loaded_modules else "fallback",
+            "mode": self.mode,
+            "loaded": sorted(self.loaded_modules.keys()),
+        }
+        if include_failed:
+            result["failed"] = self.failed_modules
+        return result
+
+    def list_symbols(
+        self,
+        module_name: str,
+        public_only: bool = True,
+        limit: int = 100,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
             return {
-                "status": "success",
-                "mode": self.mode,
-                "loaded_modules": sorted(self.modules.keys()),
-                "loaded_functions": sorted(self.functions.keys()),
-                "import_errors": self.import_errors,
-                "ready": len(self.functions) > 0 or len(self.modules) > 0,
+                "status": "error",
+                "message": f"Module not loaded: {module_name}",
+                "module": module_name,
             }
-        except Exception as exc:
-            return self._error_response(
-                message="Failed to run health check.",
-                error=exc,
-                guidance="Inspect adapter initialization and module import paths.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Internal helpers
-    # -------------------------------------------------------------------------
-
-    def _success_response(self, **payload: Any) -> Dict[str, Any]:
-        """
-        Build a standardized success response.
-
-        Args:
-            **payload: Additional response fields.
-
-        Returns:
-            dict: Success response with status field.
-        """
-        data = {"status": "success"}
-        data.update(payload)
-        return data
-
-    def _fallback_response(self, **payload: Any) -> Dict[str, Any]:
-        """
-        Build a standardized fallback response.
 
-        Args:
-            **payload: Additional response fields.
+        symbols = dir(module)
+        if public_only:
+            symbols = [name for name in symbols if not name.startswith("_")]
 
-        Returns:
-            dict: Fallback response with status field.
-        """
-        data = {"status": "fallback"}
-        data.update(payload)
-        return data
-
-    def _error_response(self, message: str, error: Exception, guidance: str) -> Dict[str, Any]:
-        """
-        Build a standardized error response.
-
-        Args:
-            message: Human-readable high-level error.
-            error: Caught exception instance.
-            guidance: Actionable next step in English.
-
-        Returns:
-            dict: Error response with detailed diagnostics.
-        """
+        safe_limit = max(1, limit)
         return {
-            "status": "error",
-            "message": message,
-            "error_type": type(error).__name__,
-            "error": str(error),
-            "guidance": guidance,
-            "traceback": traceback.format_exc(),
+            "status": "ok",
+            "module": module_name,
+            "count": len(symbols),
+            "symbols": sorted(symbols)[:safe_limit],
         }
 
-    def _invoke_callable(self, func: Any, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Safely invoke a callable with flexible argument support.
-
-        If invocation fails because of incompatible signature, a secondary attempt
-        is made without arguments for zero-arg CLI-style entrypoints.
-
-        Args:
-            func: Callable target.
-            *args: Positional arguments.
-            **kwargs: Keyword arguments.
-
-        Returns:
-            dict: Unified result dictionary.
-        """
-        try:
-            result = func(*args, **kwargs)
-            return self._success_response(result=result, callable_name=getattr(func, "__name__", str(func)))
-        except TypeError:
-            try:
-                result = func()
-                return self._success_response(
-                    result=result,
-                    callable_name=getattr(func, "__name__", str(func)),
-                    note="Called without arguments due to signature mismatch.",
-                )
-            except Exception as exc:
-                return self._error_response(
-                    message="Callable invocation failed after retry.",
-                    error=exc,
-                    guidance="Check function signature and provide compatible arguments.",
-                )
-        except Exception as exc:
-            return self._error_response(
-                message="Callable invocation failed.",
-                error=exc,
-                guidance="Verify input values and runtime context required by the target function.",
-            )
-
-    def _run_cli_fallback(self, module_name: str, argv: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Execute module through subprocess fallback mode.
-
-        Args:
-            module_name: Python module name for `python -m`.
-            argv: Optional CLI arguments list.
-
-        Returns:
-            dict: Unified fallback/success/error response.
-        """
-        try:
-            import subprocess
-
-            cmd = [sys.executable, "-m", module_name]
-            if argv:
-                cmd.extend(argv)
-
-            proc = subprocess.run(cmd, capture_output=True, text=True)
-            status = "success" if proc.returncode == 0 else "fallback"
+    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 {
-                "status": status,
-                "mode": "cli_fallback",
-                "command": cmd,
-                "returncode": proc.returncode,
-                "stdout": proc.stdout,
-                "stderr": proc.stderr,
-                "guidance": (
-                    "Import mode failed or was unavailable; CLI fallback was used."
-                    if status == "fallback"
-                    else "CLI fallback executed successfully."
-                ),
+                "status": "error",
+                "message": f"Module not loaded: {module_name}",
             }
-        except Exception as exc:
-            return self._error_response(
-                message="CLI fallback execution failed.",
-                error=exc,
-                guidance="Ensure Python runtime can execute the target module and verify module name.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Entry point wrappers: source.molmass.__main__
-    # -------------------------------------------------------------------------
 
-    def instance_source_molmass___main__(self) -> Dict[str, Any]:
-        """
-        Return imported module instance for source.molmass.__main__.
-
-        Returns:
-            dict: Contains module reference metadata when available.
-        """
-        try:
-            key = "source.molmass.__main__"
-            module = self.modules.get(key)
-            if module is None:
-                return self._fallback_response(
-                    message="Module source.molmass.__main__ is not available in import mode.",
-                    guidance="Use run_module_execution_fallback() to execute via python -m molmass.__main__.",
-                    import_errors=self.import_errors,
-                )
-            return self._success_response(
-                module_key=key,
-                module_name=getattr(module, "__name__", key),
-                attributes=sorted([a for a in dir(module) if not a.startswith("_")]),
-            )
-        except Exception as exc:
-            return self._error_response(
-                message="Failed to get module instance for source.molmass.__main__.",
-                error=exc,
-                guidance="Check import configuration and source path mapping.",
-            )
-
-    def call_source_molmass___main__(self, args: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Execute source.molmass.__main__ behavior.
-
-        Because __main__ modules often dispatch through side effects or imported main(),
-        this method attempts:
-          1) direct call of module.main if available
-          2) fallback to subprocess module execution
-
-        Args:
-            args: Optional CLI-like argument list for fallback execution.
-
-        Returns:
-            dict: Unified status dictionary with execution details.
-        """
-        try:
-            module = self.modules.get("source.molmass.__main__")
-            if module is not None and hasattr(module, "main") and callable(getattr(module, "main")):
-                return self._invoke_callable(getattr(module, "main"), args or [])
-            return self._run_cli_fallback("molmass.__main__", argv=args or [])
-        except Exception as exc:
-            return self._error_response(
-                message="Failed to execute source.molmass.__main__ entrypoint.",
-                error=exc,
-                guidance="Use call_source_molmass_molmass_main() as primary CLI handler when available.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Entry point wrappers: source.molmass.molmass.main
-    # -------------------------------------------------------------------------
-
-    def instance_source_molmass_molmass_main(self) -> Dict[str, Any]:
-        """
-        Return function metadata for source.molmass.molmass.main.
-
-        Returns:
-            dict: Function signature/doc info when available.
-        """
-        try:
-            key = "source.molmass.molmass.main"
-            func = self.functions.get(key)
-            if func is None:
-                return self._fallback_response(
-                    message="Function source.molmass.molmass.main is unavailable in import mode.",
-                    guidance="Use call_source_molmass___main__() or run_module_execution_fallback().",
-                    import_errors=self.import_errors,
-                )
-            return self._success_response(
-                function_key=key,
-                function_name=func.__name__,
-                signature=str(inspect.signature(func)),
-                doc=(inspect.getdoc(func) or ""),
-            )
-        except Exception as exc:
-            return self._error_response(
-                message="Failed to get function instance for source.molmass.molmass.main.",
-                error=exc,
-                guidance="Confirm module source.molmass.molmass is importable and intact.",
-            )
-
-    def call_source_molmass_molmass_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call core CLI handler: source.molmass.molmass.main.
-
-        Args:
-            *args: Positional arguments forwarded to molmass.main.
-            **kwargs: Keyword arguments forwarded to molmass.main.
-
-        Returns:
-            dict: Unified result dictionary.
-        """
-        try:
-            key = "source.molmass.molmass.main"
-            func = self.functions.get(key)
-            if func is None:
-                return self._run_cli_fallback("molmass", argv=list(args) if args else None)
-            return self._invoke_callable(func, *args, **kwargs)
-        except Exception as exc:
-            return self._error_response(
-                message="Failed to execute source.molmass.molmass.main.",
-                error=exc,
-                guidance="Verify argument compatibility with molmass.main signature.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Entry point wrappers: source.molmass.web.main
-    # -------------------------------------------------------------------------
-
-    def instance_source_molmass_web_main(self) -> Dict[str, Any]:
-        """
-        Return function metadata for source.molmass.web.main.
-
-        Returns:
-            dict: Function signature/doc info when available.
-        """
-        try:
-            key = "source.molmass.web.main"
-            func = self.functions.get(key)
-            if func is None:
-                return self._fallback_response(
-                    message="Function source.molmass.web.main is unavailable in import mode.",
-                    guidance="Use call_source_molmass_molmass_main() for non-web usage or configure web runtime.",
-                    import_errors=self.import_errors,
-                )
-            return self._success_response(
-                function_key=key,
-                function_name=func.__name__,
-                signature=str(inspect.signature(func)),
-                doc=(inspect.getdoc(func) or ""),
-            )
-        except Exception as exc:
-            return self._error_response(
-                message="Failed to get function instance for source.molmass.web.main.",
-                error=exc,
-                guidance="Confirm source.molmass.web imports correctly in current environment.",
-            )
-
-    def call_source_molmass_web_main(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call web/CGI-style entrypoint: source.molmass.web.main.
+        func = getattr(module, function_name, None)
+        if func is None or not callable(func):
+            return {
+                "status": "error",
+                "message": f"Function not found: {module_name}.{function_name}",
+            }
 
-        Args:
-            *args: Positional arguments forwarded to web.main.
-            **kwargs: Keyword arguments forwarded to web.main.
+        call_args = args if args is not None else []
+        call_kwargs = kwargs if kwargs is not None else {}
 
-        Returns:
-            dict: Unified result dictionary.
-        """
         try:
-            key = "source.molmass.web.main"
-            func = self.functions.get(key)
-            if func is None:
-                return self._fallback_response(
-                    message="Web entrypoint unavailable in import mode.",
-                    guidance="Configure web server/CGI context or verify source.molmass.web import path.",
-                    import_errors=self.import_errors,
-                )
-            return self._invoke_callable(func, *args, **kwargs)
+            value = func(*call_args, **call_kwargs)
+            return {
+                "status": "ok",
+                "module": module_name,
+                "function": function_name,
+                "result": value,
+            }
         except Exception as exc:
-            return self._error_response(
-                message="Failed to execute source.molmass.web.main.",
-                error=exc,
-                guidance="Ensure required web runtime context variables are provided.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Generic utility methods for MCP orchestration
-    # -------------------------------------------------------------------------
-
-    def run_module_execution_fallback(self, module_name: str, argv: Optional[List[str]] = None) -> Dict[str, Any]:
-        """
-        Public utility to execute any target module with subprocess fallback.
+            return {
+                "status": "error",
+                "message": f"{type(exc).__name__}: {exc}",
+                "module": module_name,
+                "function": function_name,
+            }
 
-        Args:
-            module_name: Module name usable with `python -m`.
-            argv: Optional command arguments list.
+    def create_instance(
+        self,
+        module_name: str,
+        class_name: str,
+        init_args: list[Any] | None = None,
+        init_kwargs: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return {
+                "status": "error",
+                "message": f"Module not loaded: {module_name}",
+            }
 
-        Returns:
-            dict: Unified execution response.
-        """
-        return self._run_cli_fallback(module_name=module_name, argv=argv)
+        cls = getattr(module, class_name, None)
+        if cls is None:
+            return {
+                "status": "error",
+                "message": f"Class not found: {module_name}.{class_name}",
+            }
 
-    def list_capabilities(self) -> Dict[str, Any]:
-        """
-        List adapter-exposed capabilities and recommended use order.
+        args = init_args if init_args is not None else []
+        kwargs = init_kwargs if init_kwargs is not None else {}
 
-        Returns:
-            dict: Capability inventory and usage hints.
-        """
         try:
-            return self._success_response(
-                mode=self.mode,
-                capabilities=[
-                    "instance_source_molmass___main__",
-                    "call_source_molmass___main__",
-                    "instance_source_molmass_molmass_main",
-                    "call_source_molmass_molmass_main",
-                    "instance_source_molmass_web_main",
-                    "call_source_molmass_web_main",
-                    "run_module_execution_fallback",
-                    "health_check",
-                ],
-                recommended_order=[
-                    "call_source_molmass_molmass_main",
-                    "call_source_molmass___main__",
-                    "call_source_molmass_web_main",
-                ],
-            )
+            instance = cls(*args, **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._error_response(
-                message="Failed to list adapter capabilities.",
-                error=exc,
-                guidance="Reinitialize adapter and retry.",
-            )
+            return {
+                "status": "error",
+                "message": f"{type(exc).__name__}: {exc}",
+                "module": module_name,
+                "class": class_name,
+            }

molmass/mcp_output/mcp_plugin/main.py

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

molmass/mcp_output/mcp_plugin/mcp_service.py

@@ -1,239 +1,331 @@
-import os
+from __future__ import annotations
+
 import sys
-from typing import Optional, Dict, Any
+from pathlib import Path
+from typing import Any
 
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
+CURRENT_DIR = Path(__file__).resolve().parent
+SOURCE_DIR = CURRENT_DIR.parents[1] / "source"
+ALT_SOURCE_DIR = CURRENT_DIR.parents[5] / "workspace" / "molmass" / "source"
+for candidate in (SOURCE_DIR, ALT_SOURCE_DIR):
+    if candidate.exists() and str(candidate) not in sys.path:
+        sys.path.insert(0, str(candidate))
+
+try:
+    from fastmcp import FastMCP
+except Exception:
+    FastMCP = None
+
+try:
+    import molmass as molmass_pkg
+except Exception:
+    molmass_pkg = None
+
+try:
+    from molmass import ELEMENTS
+except Exception:
+    ELEMENTS = None
+
+try:
+    from molmass import Formula
+except Exception:
+    Formula = None
+
+try:
+    from molmass import analyze
+except Exception:
+    analyze = None
+
+try:
+    from molmass import from_fractions
+except Exception:
+    from_fractions = None
 
-from fastmcp import FastMCP
-from molmass.molmass import Formula, from_string, analyze
-from molmass.elements import ELEMENTS
+try:
+    from .adapter import Adapter
+except Exception:
+    from adapter import Adapter
 
-mcp = FastMCP("molmass_service")
 
+class _FallbackMCP:
+    def __init__(self, name: str, description: str) -> None:
+        self.name = name
+        self.description = description
+        self.tools: list[Any] = []
 
-@mcp.tool(
-    name="parse_formula",
-    description="Parse a chemical formula string into a canonical representation.",
+    def tool(self, name: str, description: str):
+        def decorator(func):
+            setattr(func, "name", name)
+            setattr(func, "description", description)
+            self.tools.append(func)
+            return func
+
+        return decorator
+
+    def run(self, transport: str = "stdio", host: str = "127.0.0.1", port: int = 8000) -> None:
+        raise RuntimeError("fastmcp is not installed. Install dependencies first.")
+
+
+mcp = (
+    FastMCP(name="molmass-mcp", description="MCP wrapper for molecular mass and element utilities")
+    if FastMCP is not None
+    else _FallbackMCP(
+        name="molmass-mcp", description="MCP wrapper for molecular mass and element utilities"
+    )
 )
-def parse_formula(formula: str) -> Dict[str, Any]:
+
+adapter = Adapter(package_name="molmass")
+
+
+def _success(result: Any) -> dict[str, Any]:
+    return {"success": True, "result": result, "error": None}
+
+
+def _failure(error: str) -> dict[str, Any]:
+    return {"success": False, "result": None, "error": error}
+
+
+@mcp.tool(name="health_check", description="Report FastMCP, molmass and adapter health")
+def health_check() -> dict[str, Any]:
+    """Check runtime dependency availability and adapter loading state.
+
+    Returns:
+        Standardized health payload with dependency and module loading details.
     """
-    Parse a chemical formula string and return normalized/canonical details.
+    dependencies = {
+        "fastmcp": FastMCP is not None,
+        "molmass": molmass_pkg is not None,
+        "Formula": Formula is not None,
+        "ELEMENTS": ELEMENTS is not None,
+        "analyze": analyze is not None,
+        "from_fractions": from_fractions is not None,
+    }
+    return _success({"dependencies": dependencies, "adapter": adapter.health()})
+
 
-    Parameters:
-        formula: Chemical formula string, e.g. 'C8H10N4O2'.
+@mcp.tool(name="analyze_formula", description="Analyze a chemical formula as formatted text report")
+def analyze_formula(
+    formula: str,
+    maxatoms: int = 512,
+    min_intensity: float = 0.0001,
+    debug: bool = False,
+) -> dict[str, Any]:
+    """Compute a textual analysis report for a chemical formula.
+
+    Args:
+        formula: Input chemical formula string such as ``C8H10N4O2``.
+        maxatoms: Atom-count threshold above which spectrum calculation is skipped.
+        min_intensity: Minimum peak intensity included in generated spectrum text.
+        debug: If true, backend parser errors are raised by molmass internals.
 
     Returns:
-        A dictionary with:
-        - success: bool indicating operation status
-        - result: parsed formula details when successful
-        - error: error message when unsuccessful
+        Standardized response containing the report text.
     """
+    if analyze is None:
+        return _failure("molmass.analyze is unavailable")
     try:
-        parsed = from_string(formula)
-        f = Formula(parsed)
-        result = {
-            "input": formula,
-            "parsed": parsed,
-            "expanded": f.expanded,
-            "atoms": int(f.atoms),
-            "formula": str(f.formula),
-        }
-        return {"success": True, "result": result, "error": None}
+        report = analyze(
+            formula,
+            maxatoms=maxatoms,
+            min_intensity=min_intensity,
+            debug=debug,
+        )
+        return _success({"formula": formula, "analysis": report})
     except Exception as exc:
-        return {"success": False, "result": None, "error": str(exc)}
+        return _failure(f"{type(exc).__name__}: {exc}")
 
 
-@mcp.tool(
-    name="formula_mass",
-    description="Compute molecular mass properties for a chemical formula.",
-)
-def formula_mass(formula: str) -> Dict[str, Any]:
-    """
-    Compute average and monoisotopic mass information for a chemical formula.
+@mcp.tool(name="formula_summary", description="Return key mass and notation fields for a formula")
+def formula_summary(formula: str, allow_empty: bool = False) -> dict[str, Any]:
+    """Create a summary of formula notation and masses.
 
-    Parameters:
+    Args:
         formula: Chemical formula string.
+        allow_empty: Whether empty formula input is accepted.
 
     Returns:
-        A dictionary with:
-        - success: bool indicating operation status
-        - result: mass-related properties
-        - error: error message when unsuccessful
+        Standardized response with notation, mass, charge and isotope summary values.
     """
+    if Formula is None:
+        return _failure("molmass.Formula is unavailable")
+
     try:
-        f = Formula(from_string(formula))
-        result = {
-            "formula": str(f.formula),
-            "empirical": str(f.empirical),
-            "atoms": int(f.atoms),
-            "mass": float(f.mass),
-            "isotope_mass": float(f.isotope.mass),
-            "isotope_abundance": float(f.isotope.abundance),
-            "nominal_mass": int(f.isotope.massnumber),
+        f = Formula(formula, allow_empty=allow_empty)
+        payload = {
+            "input": formula,
+            "formula": f.formula,
+            "empirical": f.empirical,
+            "expanded": f.expanded,
+            "atoms": f.atoms,
+            "charge": f.charge,
+            "average_mass": f.mass,
+            "monoisotopic_mass": f.monoisotopic_mass,
+            "nominal_mass": f.nominal_mass,
+            "mz": f.mz,
+            "isotope": {
+                "mass": f.isotope.mass,
+                "massnumber": f.isotope.massnumber,
+                "abundance": f.isotope.abundance,
+            },
         }
-        return {"success": True, "result": result, "error": None}
+        return _success(payload)
     except Exception as exc:
-        return {"success": False, "result": None, "error": str(exc)}
+        return _failure(f"{type(exc).__name__}: {exc}")
 
 
-@mcp.tool(
-    name="formula_composition",
-    description="Get elemental composition for a chemical formula.",
-)
-def formula_composition(formula: str, isotopic: bool = True) -> Dict[str, Any]:
-    """
-    Return elemental composition entries for a formula.
+@mcp.tool(name="composition_table", description="Return elemental composition table for a formula")
+def composition_table(formula: str, isotopic: bool = True) -> dict[str, Any]:
+    """Compute the elemental composition rows for a formula.
 
-    Parameters:
+    Args:
         formula: Chemical formula string.
-        isotopic: Whether to include isotopic composition detail when available.
+        isotopic: Whether to preserve isotope-specific rows when available.
 
     Returns:
-        A dictionary with:
-        - success: bool indicating operation status
-        - result: list of composition rows
-        - error: error message when unsuccessful
+        Standardized response containing composition tuples.
     """
+    if Formula is None:
+        return _failure("molmass.Formula is unavailable")
+
     try:
-        f = Formula(from_string(formula))
-        comp = f.composition(isotopic=isotopic)
+        f = Formula(formula)
+        composition = f.composition(isotopic=isotopic)
         rows = []
-        for item in comp.astuple():
-            symbol, count, mass, fraction = item
+        for item in composition.astuple():
             rows.append(
                 {
-                    "symbol": symbol,
-                    "count": int(count),
-                    "mass": float(mass),
-                    "fraction": float(fraction),
+                    "element": item[0],
+                    "count": item[1],
+                    "relative_mass": item[2],
+                    "fraction": item[3],
                 }
             )
-        return {"success": True, "result": rows, "error": None}
+        return _success({"formula": f.formula, "isotopic": isotopic, "rows": rows})
     except Exception as exc:
-        return {"success": False, "result": None, "error": str(exc)}
+        return _failure(f"{type(exc).__name__}: {exc}")
 
 
-@mcp.tool(
-    name="formula_spectrum",
-    description="Calculate mass distribution (spectrum) for a chemical formula.",
-)
-def formula_spectrum(formula: str, min_fraction: float = 1e-12) -> Dict[str, Any]:
-    """
-    Calculate isotopic mass spectrum for a chemical formula.
+@mcp.tool(name="isotopic_spectrum", description="Return isotopic spectrum peaks for a formula")
+def isotopic_spectrum(
+    formula: str,
+    min_fraction: float = 1e-09,
+    min_intensity: float = 1e-09,
+    max_peaks: int = 30,
+) -> dict[str, Any]:
+    """Calculate isotopic mass distribution peaks.
 
-    Parameters:
+    Args:
         formula: Chemical formula string.
-        min_fraction: Minimum fraction threshold for peaks included by backend behavior.
+        min_fraction: Minimum fractional abundance for peak generation.
+        min_intensity: Minimum relative intensity threshold.
+        max_peaks: Maximum number of peaks returned.
 
     Returns:
-        A dictionary with:
-        - success: bool indicating operation status
-        - result: peak list and related summary
-        - error: error message when unsuccessful
+        Standardized response containing spectrum rows.
     """
+    if Formula is None:
+        return _failure("molmass.Formula is unavailable")
+
     try:
-        f = Formula(from_string(formula))
-        spectrum = f.spectrum(min_fraction=min_fraction)
-        peaks = []
-        for mass_number, peak in spectrum.items():
+        f = Formula(formula)
+        spectrum = f.spectrum(min_fraction=min_fraction, min_intensity=min_intensity)
+        peaks: list[dict[str, Any]] = []
+        for mass_number, entry in sorted(spectrum.items())[: max(1, max_peaks)]:
             peaks.append(
                 {
-                    "mass_number": int(mass_number),
-                    "mass": float(peak.mass),
-                    "fraction": float(peak.fraction),
-                    "intensity": float(peak.intensity),
-                    "mz": float(peak.mz),
+                    "mass_number": mass_number,
+                    "mass": entry.mass,
+                    "fraction": entry.fraction,
+                    "intensity": entry.intensity,
+                    "mz": entry.mz,
                 }
             )
-        result = {
-            "formula": str(f.formula),
-            "peak_count": len(peaks),
-            "peaks": peaks,
-        }
-        return {"success": True, "result": result, "error": None}
+        return _success(
+            {
+                "formula": f.formula,
+                "peak_count": len(peaks),
+                "mean": spectrum.mean,
+                "peaks": peaks,
+            }
+        )
     except Exception as exc:
-        return {"success": False, "result": None, "error": str(exc)}
+        return _failure(f"{type(exc).__name__}: {exc}")
 
 
-@mcp.tool(
-    name="analyze_formula_text",
-    description="Run molmass textual analysis report for a formula.",
-)
-def analyze_formula_text(formula: str, maxatoms: int = 512) -> Dict[str, Any]:
-    """
-    Generate the standard textual analysis output produced by molmass.
+@mcp.tool(name="element_lookup", description="Lookup periodic element properties by symbol, name or atomic number")
+def element_lookup(identifier: str) -> dict[str, Any]:
+    """Retrieve element data for symbol, English name, or atomic number.
 
-    Parameters:
-        formula: Chemical formula string.
-        maxatoms: Maximum number of atoms allowed during analysis.
+    Args:
+        identifier: Element symbol (e.g. ``C``), name (e.g. ``Carbon``), or atomic number string.
 
     Returns:
-        A dictionary with:
-        - success: bool indicating operation status
-        - result: text report string
-        - error: error message when unsuccessful
+        Standardized response with key physicochemical properties and isotope count.
     """
+    if ELEMENTS is None:
+        return _failure("molmass.ELEMENTS is unavailable")
+
     try:
-        report = analyze(formula, maxatoms=maxatoms)
-        return {"success": True, "result": report, "error": None}
+        key: str | int
+        cleaned = identifier.strip()
+        key = int(cleaned) if cleaned.isdigit() else cleaned
+        element = ELEMENTS[key]
+        result = {
+            "number": element.number,
+            "symbol": element.symbol,
+            "name": element.name,
+            "mass": element.mass,
+            "group": element.group,
+            "period": element.period,
+            "block": element.block,
+            "series": element.series,
+            "description": element.description,
+            "isotope_count": len(element.isotopes),
+        }
+        return _success(result)
     except Exception as exc:
-        return {"success": False, "result": None, "error": str(exc)}
+        return _failure(f"{type(exc).__name__}: {exc}")
 
 
-@mcp.tool(
-    name="get_element",
-    description="Fetch periodic table metadata for an element by symbol.",
-)
-def get_element(symbol: str) -> Dict[str, Any]:
-    """
-    Retrieve element metadata from molmass periodic table data.
+@mcp.tool(name="formula_from_fractions", description="Infer empirical-style formula from elemental mass fractions")
+def formula_from_fractions(fractions: dict[str, float], maxcount: int = 10, precision: float = 0.0001) -> dict[str, Any]:
+    """Generate a formula from elemental mass fractions.
 
-    Parameters:
-        symbol: Element symbol, e.g. 'C', 'H', 'Na'.
+    Args:
+        fractions: Mapping from element symbol (or isotope notation) to mass fraction.
+        maxcount: Maximum count to consider per element while solving the ratio.
+        precision: Error tolerance used in ratio approximation.
 
     Returns:
-        A dictionary with:
-        - success: bool indicating operation status
-        - result: selected element properties
-        - error: error message when unsuccessful
+        Standardized response containing generated formula.
     """
+    if from_fractions is None:
+        return _failure("molmass.from_fractions is unavailable")
+
     try:
-        normalized = symbol.strip().capitalize()
-        element = ELEMENTS[normalized]
-        isotopes = []
-        for mass_number, iso in element.isotopes.items():
-            isotopes.append(
-                {
-                    "mass_number": int(mass_number),
-                    "mass": float(iso.mass),
-                    "abundance": float(iso.abundance),
-                    "charge": int(iso.charge),
-                }
-            )
-        result = {
-            "symbol": str(element.symbol),
-            "name": str(element.name),
-            "number": int(element.number),
-            "group": int(element.group),
-            "period": int(element.period),
-            "block": str(element.block),
-            "series": int(element.series),
-            "mass": float(element.mass),
-            "isotopes": isotopes,
-        }
-        return {"success": True, "result": result, "error": None}
+        formula = from_fractions(fractions, maxcount=maxcount, precision=precision)
+        return _success({"fractions": fractions, "formula": formula})
     except Exception as exc:
-        return {"success": False, "result": None, "error": str(exc)}
+        return _failure(f"{type(exc).__name__}: {exc}")
+
+
+@mcp.tool(name="list_modules", description="List importable modules discovered by the adapter")
+def list_modules(include_failed: bool = True) -> dict[str, Any]:
+    """List modules loaded by the dynamic adapter.
+
+    Args:
+        include_failed: Whether failed imports should be included in the output.
+
+    Returns:
+        Standardized response with loaded and failed module names.
+    """
+    return _success(adapter.list_modules(include_failed=include_failed))
 
 
-def create_app() -> FastMCP:
+def create_app() -> Any:
+    """Return the module-level MCP application instance."""
     return mcp
 
 
 if __name__ == "__main__":
-    mcp.run()
+    mcp.run()

molmass/mcp_output/requirements.txt

@@ -1,5 +1,2 @@
 fastmcp
-fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-standard library (dataclasses/typing/re/math/etc.)
+molmass

molmass/mcp_output/start_mcp.py

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

port.json

@@ -1,5 +1 @@
-{
-  "repo": "molmass",
-  "port": 7909,
-  "timestamp": 1773407876
-}
+{"port": 7860}

requirements.txt

@@ -1,5 +1,4 @@
 fastmcp
+molmass
 fastapi
-uvicorn[standard]
-pydantic>=2.0.0
-
+uvicorn

run_docker.ps1

@@ -1,26 +1,11 @@
-cd $PSScriptRoot
 $ErrorActionPreference = "Stop"
-$entryName = if ($env:MCP_ENTRY_NAME) { $env:MCP_ENTRY_NAME } else { "molmass" }
-$entryUrl  = if ($env:MCP_ENTRY_URL)  { $env:MCP_ENTRY_URL  } else { "http://localhost:7909/mcp" }
-$imageName = if ($env:MCP_IMAGE_NAME) { $env:MCP_IMAGE_NAME } else { "molmass-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 "port.json" | ConvertFrom-Json
+$port = [int]$portConfig.port
+$imageName = "molmass-mcp"
+
+Write-Host "Building Docker image: $imageName"
 docker build -t $imageName .
-docker run --rm -p 7909:7860 $imageName
+
+Write-Host "Running container on port $port"
+docker run --rm -it -p "${port}:${port}" $imageName

run_docker.sh

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