decimer-mcp-server 0.1.2__tar.gz

decimer_mcp_server-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DocMinus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

decimer_mcp_server-0.1.2/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: decimer-mcp-server
+Version: 0.1.2
+Summary: MCP adapter server for DECIMER FastAPI image-to-SMILES endpoint
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Dynamic: license-file
+
+# DecimerMCPServer
+
+MCP server that exposes DECIMER image-to-SMILES functionality as tool calls.
+
+This project is a thin adapter over the existing FastAPI service in `DecimerServerAPI`.
+It does not run DECIMER models directly.
+The adapter sends JSON requests by default, with automatic fallback to form payloads for compatibility.
+
+## Tools
+
+- `server_health`: Checks whether the DECIMER FastAPI server is reachable.
+- `analyze_chemical_image`: Sends a base64-encoded image to `/image2smiles/` and returns structured output.
+
+## Requirements
+
+- Python 3.10+
+- Running DECIMER API server (default: `http://localhost:8099`)
+
+## Install
+
+```bash
+cd /Users/a/dev/DecimerMCPServer
+uv venv
+uv sync
+```
+
+## Configuration
+
+Copy `.env.example` values into your environment:
+
+- `DECIMER_API_BASE_URL` (default `http://localhost:8099`)
+- `DECIMER_API_TIMEOUT_SECONDS` (default `60`)
+- `DECIMER_MAX_IMAGE_BYTES` (default `10000000`)
+- `DECIMER_MCP_LOG_LEVEL` (default `INFO`)
+
+## Run (stdio transport)
+
+```bash
+uv run decimer-mcp-server
+```
+
+or
+
+```bash
+uv run python -m decimer_mcp_server
+```
+
+## Example MCP client config
+
+```json
+{
+  "mcpServers": {
+    "decimer": {
+      "command": "uv",
+      "args": ["run", "python", "-m", "decimer_mcp_server"],
+      "env": {
+        "DECIMER_API_BASE_URL": "http://localhost:8099"
+      }
+    }
+  }
+}
+```
+
+## Output shape
+
+`analyze_chemical_image` returns:
+
+```json
+{
+  "ok": true,
+  "smiles": "CCO",
+  "reason": null,
+  "api_status_code": 200,
+  "api_message": null,
+  "classifier_score": 0.0000012,
+  "classifier_threshold": 0.3,
+  "classifier_decision": "structure_like"
+}
+```
+
+When no SMILES is returned by API classifier behavior:
+
+```json
+{
+  "ok": true,
+  "smiles": null,
+  "reason": "not_chemical_structure",
+  "api_status_code": 200,
+  "api_message": "No SMILES returned by API",
+  "classifier_score": 0.99999,
+  "classifier_threshold": 0.3,
+  "classifier_decision": "not_structure_like"
+}
+```
+
+## Development tests
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+Make targets:
+
+```bash
+make sync
+make test
+```
+
+## Smoke test helper
+
+Run one health check + one inference call against your DECIMER API:
+
+```bash
+cd /Users/a/dev/DecimerMCPServer
+DECIMER_API_BASE_URL=http://chitchat:8099 uv run decimer-mcp-smoke-test --image /Users/a/dev/DecimerServerAPI/example_usage/structure.png
+```
+
+If you keep settings in `.env`, load it with:
+
+```bash
+uv run --env-file .env decimer-mcp-smoke-test --image /Users/a/dev/DecimerServerAPI/example_usage/structure.png
+```
+
+or use make:
+
+```bash
+make smoke
+```
+
+Override the image path if needed:
+
+```bash
+make smoke SMOKE_IMAGE=/absolute/path/to/image.png
+
+## MCP Registry publishing
+
+Tags matching `v*` trigger `.github/workflows/publish-mcp.yml`.
+
+Workflow steps:
+- installs `mcp-publisher`
+- validates `server.json`
+- calls registry publish using secret `MCP_REGISTRY_TOKEN`
+- publishes slug `io.github.DocMinus/decimer-mcp-server` (case sensitive; must match registry grant)
+
+Before tagging:
+1. Update `pyproject.toml` + `server.json` versions
+2. Ensure `server.json` stays valid (`uv pip install jsonschema && python validate snippet from AGENTS.md`)
+3. Add GitHub repo secret `MCP_REGISTRY_TOKEN` (GitHub PAT with `repo`, `workflow` scopes)
+
+Release flow:
+```bash
+git tag v0.1.1
+git push origin v0.1.1
+```
+
+Monitor Actions tab. If publish fails, rerun using workflow dispatch after fixing issues.
+```
+
+## Contribution
+This project was built by DocMinus with AI-assisted coding support (OpenCode/Copilot-style tooling), then reviewed and tested by the author.
+
+## AI usage policy
+
+- AI assistance was used for scaffolding, implementation drafts, and documentation edits.
+- Final technical decisions, validation runs, and acceptance were performed by the maintainer.
+- Runtime behavior should be validated with local tests (`make test`) and smoke tests (`make smoke`) before release.

decimer_mcp_server-0.1.2/README.md

@@ -0,0 +1,167 @@
+# DecimerMCPServer
+
+MCP server that exposes DECIMER image-to-SMILES functionality as tool calls.
+
+This project is a thin adapter over the existing FastAPI service in `DecimerServerAPI`.
+It does not run DECIMER models directly.
+The adapter sends JSON requests by default, with automatic fallback to form payloads for compatibility.
+
+## Tools
+
+- `server_health`: Checks whether the DECIMER FastAPI server is reachable.
+- `analyze_chemical_image`: Sends a base64-encoded image to `/image2smiles/` and returns structured output.
+
+## Requirements
+
+- Python 3.10+
+- Running DECIMER API server (default: `http://localhost:8099`)
+
+## Install
+
+```bash
+cd /Users/a/dev/DecimerMCPServer
+uv venv
+uv sync
+```
+
+## Configuration
+
+Copy `.env.example` values into your environment:
+
+- `DECIMER_API_BASE_URL` (default `http://localhost:8099`)
+- `DECIMER_API_TIMEOUT_SECONDS` (default `60`)
+- `DECIMER_MAX_IMAGE_BYTES` (default `10000000`)
+- `DECIMER_MCP_LOG_LEVEL` (default `INFO`)
+
+## Run (stdio transport)
+
+```bash
+uv run decimer-mcp-server
+```
+
+or
+
+```bash
+uv run python -m decimer_mcp_server
+```
+
+## Example MCP client config
+
+```json
+{
+  "mcpServers": {
+    "decimer": {
+      "command": "uv",
+      "args": ["run", "python", "-m", "decimer_mcp_server"],
+      "env": {
+        "DECIMER_API_BASE_URL": "http://localhost:8099"
+      }
+    }
+  }
+}
+```
+
+## Output shape
+
+`analyze_chemical_image` returns:
+
+```json
+{
+  "ok": true,
+  "smiles": "CCO",
+  "reason": null,
+  "api_status_code": 200,
+  "api_message": null,
+  "classifier_score": 0.0000012,
+  "classifier_threshold": 0.3,
+  "classifier_decision": "structure_like"
+}
+```
+
+When no SMILES is returned by API classifier behavior:
+
+```json
+{
+  "ok": true,
+  "smiles": null,
+  "reason": "not_chemical_structure",
+  "api_status_code": 200,
+  "api_message": "No SMILES returned by API",
+  "classifier_score": 0.99999,
+  "classifier_threshold": 0.3,
+  "classifier_decision": "not_structure_like"
+}
+```
+
+## Development tests
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+Make targets:
+
+```bash
+make sync
+make test
+```
+
+## Smoke test helper
+
+Run one health check + one inference call against your DECIMER API:
+
+```bash
+cd /Users/a/dev/DecimerMCPServer
+DECIMER_API_BASE_URL=http://chitchat:8099 uv run decimer-mcp-smoke-test --image /Users/a/dev/DecimerServerAPI/example_usage/structure.png
+```
+
+If you keep settings in `.env`, load it with:
+
+```bash
+uv run --env-file .env decimer-mcp-smoke-test --image /Users/a/dev/DecimerServerAPI/example_usage/structure.png
+```
+
+or use make:
+
+```bash
+make smoke
+```
+
+Override the image path if needed:
+
+```bash
+make smoke SMOKE_IMAGE=/absolute/path/to/image.png
+
+## MCP Registry publishing
+
+Tags matching `v*` trigger `.github/workflows/publish-mcp.yml`.
+
+Workflow steps:
+- installs `mcp-publisher`
+- validates `server.json`
+- calls registry publish using secret `MCP_REGISTRY_TOKEN`
+- publishes slug `io.github.DocMinus/decimer-mcp-server` (case sensitive; must match registry grant)
+
+Before tagging:
+1. Update `pyproject.toml` + `server.json` versions
+2. Ensure `server.json` stays valid (`uv pip install jsonschema && python validate snippet from AGENTS.md`)
+3. Add GitHub repo secret `MCP_REGISTRY_TOKEN` (GitHub PAT with `repo`, `workflow` scopes)
+
+Release flow:
+```bash
+git tag v0.1.1
+git push origin v0.1.1
+```
+
+Monitor Actions tab. If publish fails, rerun using workflow dispatch after fixing issues.
+```
+
+## Contribution
+This project was built by DocMinus with AI-assisted coding support (OpenCode/Copilot-style tooling), then reviewed and tested by the author.
+
+## AI usage policy
+
+- AI assistance was used for scaffolding, implementation drafts, and documentation edits.
+- Final technical decisions, validation runs, and acceptance were performed by the maintainer.
+- Runtime behavior should be validated with local tests (`make test`) and smoke tests (`make smoke`) before release.

decimer_mcp_server-0.1.2/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "decimer-mcp-server"
+version = "0.1.2"
+description = "MCP adapter server for DECIMER FastAPI image-to-SMILES endpoint"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "mcp>=1.2.0",
+    "httpx>=0.27.0",
+    "pydantic>=2.8.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+]
+
+[project.scripts]
+decimer-mcp-server = "decimer_mcp_server.__main__:main"
+decimer-mcp-smoke-test = "decimer_mcp_server.smoke_test:main"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

decimer_mcp_server-0.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

decimer_mcp_server-0.1.2/src/decimer_mcp_server/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

decimer_mcp_server-0.1.2/src/decimer_mcp_server/__main__.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from .server import mcp
+
+
+def main() -> None:
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

decimer_mcp_server-0.1.2/src/decimer_mcp_server/config.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import os
+
+
+def _get_env_str(name: str, default: str) -> str:
+    value = os.getenv(name)
+    if value is None or value.strip() == "":
+        return default
+    return value.strip()
+
+
+def _get_env_int(name: str, default: int) -> int:
+    value = os.getenv(name)
+    if value is None or value.strip() == "":
+        return default
+    try:
+        parsed = int(value)
+    except ValueError as exc:
+        raise ValueError(f"Environment variable {name} must be an integer") from exc
+    if parsed <= 0:
+        raise ValueError(f"Environment variable {name} must be greater than 0")
+    return parsed
+
+
+def _get_env_float(name: str, default: float) -> float:
+    value = os.getenv(name)
+    if value is None or value.strip() == "":
+        return default
+    try:
+        parsed = float(value)
+    except ValueError as exc:
+        raise ValueError(f"Environment variable {name} must be a float") from exc
+    if parsed <= 0:
+        raise ValueError(f"Environment variable {name} must be greater than 0")
+    return parsed
+
+
+class Settings:
+    def __init__(self) -> None:
+        self.decimer_api_base_url = _get_env_str(
+            "DECIMER_API_BASE_URL", "http://localhost:8099"
+        )
+        self.decimer_api_timeout_seconds = _get_env_float(
+            "DECIMER_API_TIMEOUT_SECONDS", 60.0
+        )
+        self.decimer_max_image_bytes = _get_env_int(
+            "DECIMER_MAX_IMAGE_BYTES", 10_000_000
+        )
+        self.decimer_mcp_log_level = _get_env_str("DECIMER_MCP_LOG_LEVEL", "INFO")
+
+
+settings = Settings()

decimer_mcp_server-0.1.2/src/decimer_mcp_server/decimer_api_client.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+
+import httpx
+
+
+@dataclass
+class APIResult:
+    ok: bool
+    status_code: int
+    smiles: str | None = None
+    message: str | None = None
+    reason: str | None = None
+    classifier_score: float | None = None
+    classifier_threshold: float | None = None
+    classifier_decision: str | None = None
+
+
+class DecimerAPIClient:
+    def __init__(
+        self, base_url: str, timeout_seconds: float, max_image_bytes: int
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout_seconds = timeout_seconds
+        self.max_image_bytes = max_image_bytes
+
+    def _validate_image_size(self, encoded_image: str) -> None:
+        decoded = base64.b64decode(encoded_image, validate=True)
+        if len(decoded) > self.max_image_bytes:
+            raise ValueError(
+                f"Decoded image size exceeds limit of {self.max_image_bytes} bytes"
+            )
+
+    async def health(self) -> APIResult:
+        url = f"{self.base_url}/"
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout_seconds) as client:
+                response = await client.get(url)
+        except httpx.TimeoutException:
+            return APIResult(
+                ok=False,
+                status_code=504,
+                message="DECIMER API request timed out",
+                reason="timeout",
+            )
+        except httpx.HTTPError as exc:
+            return APIResult(
+                ok=False,
+                status_code=503,
+                message=f"DECIMER API unreachable: {exc}",
+                reason="unreachable",
+            )
+
+        message = None
+        try:
+            payload = response.json()
+            message = payload.get("Message") or payload.get("message")
+        except ValueError:
+            message = response.text
+
+        return APIResult(
+            ok=response.status_code == 200,
+            status_code=response.status_code,
+            message=message,
+            reason=None if response.status_code == 200 else "http_error",
+        )
+
+    async def image_to_smiles(
+        self,
+        encoded_image: str,
+        is_hand_drawn: bool,
+        classify_image: bool,
+    ) -> APIResult:
+        self._validate_image_size(encoded_image)
+        url = f"{self.base_url}/image2smiles/"
+        json_payload = {
+            "encoded_image": encoded_image,
+            "is_hand_drawn": is_hand_drawn,
+            "classify_image": classify_image,
+        }
+        form_data = {
+            "encoded_image": encoded_image,
+            "is_hand_drawn": str(is_hand_drawn).lower(),
+            "classify_image": str(classify_image).lower(),
+        }
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout_seconds) as client:
+                response = await client.post(url, json=json_payload)
+                if response.status_code in {400, 415, 422}:
+                    response = await client.post(url, data=form_data)
+        except httpx.TimeoutException:
+            return APIResult(
+                ok=False,
+                status_code=504,
+                message="DECIMER API request timed out",
+                reason="timeout",
+            )
+        except httpx.HTTPError as exc:
+            return APIResult(
+                ok=False,
+                status_code=503,
+                message=f"DECIMER API unreachable: {exc}",
+                reason="unreachable",
+            )
+
+        try:
+            payload = response.json()
+        except ValueError:
+            payload = {"message": response.text}
+
+        if response.status_code != 200:
+            return APIResult(
+                ok=False,
+                status_code=response.status_code,
+                message=payload.get("message", "Unknown API error"),
+                reason="http_error",
+            )
+
+        smiles = payload.get("smiles")
+        if smiles is None:
+            return APIResult(
+                ok=True,
+                status_code=200,
+                smiles=None,
+                message=payload.get("message", "No SMILES returned by API"),
+                reason=payload.get("reason", "no_smiles_returned"),
+                classifier_score=payload.get("classifier_score"),
+                classifier_threshold=payload.get("classifier_threshold"),
+                classifier_decision=payload.get("classifier_decision"),
+            )
+
+        return APIResult(
+            ok=True,
+            status_code=200,
+            smiles=smiles,
+            classifier_score=payload.get("classifier_score"),
+            classifier_threshold=payload.get("classifier_threshold"),
+            classifier_decision=payload.get("classifier_decision"),
+        )

decimer_mcp_server-0.1.2/src/decimer_mcp_server/schemas.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import base64
+import binascii
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class AnalyzeChemicalImageInput(BaseModel):
+    encoded_image: str = Field(
+        ..., description="Base64-encoded image content (PNG/JPEG recommended)."
+    )
+    is_hand_drawn: bool = Field(
+        default=False,
+        description="Whether the depicted chemical structure is hand-drawn.",
+    )
+    classify_image: bool = Field(
+        default=True,
+        description="Whether to run image classification before DECIMER OCR.",
+    )
+
+    @field_validator("encoded_image")
+    @classmethod
+    def validate_base64(cls, value: str) -> str:
+        stripped = value.strip()
+        if not stripped:
+            raise ValueError("encoded_image must not be empty")
+        try:
+            base64.b64decode(stripped, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise ValueError("encoded_image is not valid base64") from exc
+        return stripped
+
+
+class AnalyzeChemicalImageOutput(BaseModel):
+    ok: bool
+    smiles: str | None
+    reason: str | None = None
+    api_status_code: int
+    api_message: str | None = None
+    classifier_score: float | None = None
+    classifier_threshold: float | None = None
+    classifier_decision: str | None = None
+
+
+class ServerHealthOutput(BaseModel):
+    ok: bool
+    api_status_code: int
+    message: str

decimer_mcp_server-0.1.2/src/decimer_mcp_server/server.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from .config import settings
+from .decimer_api_client import DecimerAPIClient
+from .schemas import (
+    AnalyzeChemicalImageInput,
+    AnalyzeChemicalImageOutput,
+    ServerHealthOutput,
+)
+
+
+mcp = FastMCP("decimer-mcp-server")
+api_client = DecimerAPIClient(
+    base_url=settings.decimer_api_base_url,
+    timeout_seconds=settings.decimer_api_timeout_seconds,
+    max_image_bytes=settings.decimer_max_image_bytes,
+)
+
+
+@mcp.tool()
+async def server_health() -> dict:
+    """Check DECIMER FastAPI server availability."""
+    result = await api_client.health()
+    output = ServerHealthOutput(
+        ok=result.ok,
+        api_status_code=result.status_code,
+        message=result.message or "No response message",
+    )
+    return output.model_dump()
+
+
+@mcp.tool()
+async def analyze_chemical_image(
+    encoded_image: str,
+    is_hand_drawn: bool = False,
+    classify_image: bool = True,
+) -> dict:
+    """Analyze a base64 image and return a predicted SMILES string when available."""
+    parsed = AnalyzeChemicalImageInput(
+        encoded_image=encoded_image,
+        is_hand_drawn=is_hand_drawn,
+        classify_image=classify_image,
+    )
+
+    try:
+        result = await api_client.image_to_smiles(
+            encoded_image=parsed.encoded_image,
+            is_hand_drawn=parsed.is_hand_drawn,
+            classify_image=parsed.classify_image,
+        )
+    except ValueError as exc:
+        output = AnalyzeChemicalImageOutput(
+            ok=False,
+            smiles=None,
+            reason="image_too_large",
+            api_status_code=413,
+            api_message=str(exc),
+        )
+        return output.model_dump()
+
+    output = AnalyzeChemicalImageOutput(
+        ok=result.ok,
+        smiles=result.smiles,
+        reason=result.reason,
+        api_status_code=result.status_code,
+        api_message=result.message,
+        classifier_score=result.classifier_score,
+        classifier_threshold=result.classifier_threshold,
+        classifier_decision=result.classifier_decision,
+    )
+    return output.model_dump()

decimer_mcp_server-0.1.2/src/decimer_mcp_server/smoke_test.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import os
+from pathlib import Path
+
+from .decimer_api_client import DecimerAPIClient
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Run a DECIMER API smoke test with one image."
+    )
+    parser.add_argument(
+        "--image",
+        required=True,
+        help="Path to an image file to send to /image2smiles/",
+    )
+    parser.add_argument(
+        "--base-url",
+        default=os.getenv("DECIMER_API_BASE_URL", "http://localhost:8099"),
+        help="DECIMER API base URL (default: DECIMER_API_BASE_URL or http://localhost:8099)",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=60.0,
+        help="HTTP timeout in seconds (default: 60)",
+    )
+    parser.add_argument(
+        "--max-image-bytes",
+        type=int,
+        default=10_000_000,
+        help="Maximum decoded image bytes (default: 10000000)",
+    )
+    parser.add_argument(
+        "--is-hand-drawn",
+        action="store_true",
+        help="Set hand-drawn mode for DECIMER",
+    )
+    parser.add_argument(
+        "--no-classify",
+        action="store_true",
+        help="Disable classifier pre-check",
+    )
+    return parser.parse_args()
+
+
+async def run() -> int:
+    args = parse_args()
+    image_path = Path(args.image)
+    if not image_path.exists() or not image_path.is_file():
+        print(f"ERROR: Image path not found or not a file: {image_path}")
+        return 2
+
+    encoded_image = base64.b64encode(image_path.read_bytes()).decode("utf-8")
+    client = DecimerAPIClient(
+        base_url=args.base_url,
+        timeout_seconds=args.timeout,
+        max_image_bytes=args.max_image_bytes,
+    )
+
+    health = await client.health()
+    print(f"health.ok={health.ok} status={health.status_code} message={health.message}")
+    if not health.ok:
+        return 1
+
+    result = await client.image_to_smiles(
+        encoded_image=encoded_image,
+        is_hand_drawn=args.is_hand_drawn,
+        classify_image=not args.no_classify,
+    )
+    print(
+        "inference."
+        f"ok={result.ok} status={result.status_code} smiles={result.smiles} "
+        f"reason={result.reason} message={result.message}"
+    )
+
+    if not result.ok:
+        return 1
+    return 0
+
+
+def main() -> None:
+    exit_code = asyncio.run(run())
+    raise SystemExit(exit_code)

decimer_mcp_server-0.1.2/src/decimer_mcp_server.egg-info/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: decimer-mcp-server
+Version: 0.1.2
+Summary: MCP adapter server for DECIMER FastAPI image-to-SMILES endpoint
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.2.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.8.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Dynamic: license-file
+
+# DecimerMCPServer
+
+MCP server that exposes DECIMER image-to-SMILES functionality as tool calls.
+
+This project is a thin adapter over the existing FastAPI service in `DecimerServerAPI`.
+It does not run DECIMER models directly.
+The adapter sends JSON requests by default, with automatic fallback to form payloads for compatibility.
+
+## Tools
+
+- `server_health`: Checks whether the DECIMER FastAPI server is reachable.
+- `analyze_chemical_image`: Sends a base64-encoded image to `/image2smiles/` and returns structured output.
+
+## Requirements
+
+- Python 3.10+
+- Running DECIMER API server (default: `http://localhost:8099`)
+
+## Install
+
+```bash
+cd /Users/a/dev/DecimerMCPServer
+uv venv
+uv sync
+```
+
+## Configuration
+
+Copy `.env.example` values into your environment:
+
+- `DECIMER_API_BASE_URL` (default `http://localhost:8099`)
+- `DECIMER_API_TIMEOUT_SECONDS` (default `60`)
+- `DECIMER_MAX_IMAGE_BYTES` (default `10000000`)
+- `DECIMER_MCP_LOG_LEVEL` (default `INFO`)
+
+## Run (stdio transport)
+
+```bash
+uv run decimer-mcp-server
+```
+
+or
+
+```bash
+uv run python -m decimer_mcp_server
+```
+
+## Example MCP client config
+
+```json
+{
+  "mcpServers": {
+    "decimer": {
+      "command": "uv",
+      "args": ["run", "python", "-m", "decimer_mcp_server"],
+      "env": {
+        "DECIMER_API_BASE_URL": "http://localhost:8099"
+      }
+    }
+  }
+}
+```
+
+## Output shape
+
+`analyze_chemical_image` returns:
+
+```json
+{
+  "ok": true,
+  "smiles": "CCO",
+  "reason": null,
+  "api_status_code": 200,
+  "api_message": null,
+  "classifier_score": 0.0000012,
+  "classifier_threshold": 0.3,
+  "classifier_decision": "structure_like"
+}
+```
+
+When no SMILES is returned by API classifier behavior:
+
+```json
+{
+  "ok": true,
+  "smiles": null,
+  "reason": "not_chemical_structure",
+  "api_status_code": 200,
+  "api_message": "No SMILES returned by API",
+  "classifier_score": 0.99999,
+  "classifier_threshold": 0.3,
+  "classifier_decision": "not_structure_like"
+}
+```
+
+## Development tests
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+Make targets:
+
+```bash
+make sync
+make test
+```
+
+## Smoke test helper
+
+Run one health check + one inference call against your DECIMER API:
+
+```bash
+cd /Users/a/dev/DecimerMCPServer
+DECIMER_API_BASE_URL=http://chitchat:8099 uv run decimer-mcp-smoke-test --image /Users/a/dev/DecimerServerAPI/example_usage/structure.png
+```
+
+If you keep settings in `.env`, load it with:
+
+```bash
+uv run --env-file .env decimer-mcp-smoke-test --image /Users/a/dev/DecimerServerAPI/example_usage/structure.png
+```
+
+or use make:
+
+```bash
+make smoke
+```
+
+Override the image path if needed:
+
+```bash
+make smoke SMOKE_IMAGE=/absolute/path/to/image.png
+
+## MCP Registry publishing
+
+Tags matching `v*` trigger `.github/workflows/publish-mcp.yml`.
+
+Workflow steps:
+- installs `mcp-publisher`
+- validates `server.json`
+- calls registry publish using secret `MCP_REGISTRY_TOKEN`
+- publishes slug `io.github.DocMinus/decimer-mcp-server` (case sensitive; must match registry grant)
+
+Before tagging:
+1. Update `pyproject.toml` + `server.json` versions
+2. Ensure `server.json` stays valid (`uv pip install jsonschema && python validate snippet from AGENTS.md`)
+3. Add GitHub repo secret `MCP_REGISTRY_TOKEN` (GitHub PAT with `repo`, `workflow` scopes)
+
+Release flow:
+```bash
+git tag v0.1.1
+git push origin v0.1.1
+```
+
+Monitor Actions tab. If publish fails, rerun using workflow dispatch after fixing issues.
+```
+
+## Contribution
+This project was built by DocMinus with AI-assisted coding support (OpenCode/Copilot-style tooling), then reviewed and tested by the author.
+
+## AI usage policy
+
+- AI assistance was used for scaffolding, implementation drafts, and documentation edits.
+- Final technical decisions, validation runs, and acceptance were performed by the maintainer.
+- Runtime behavior should be validated with local tests (`make test`) and smoke tests (`make smoke`) before release.

decimer_mcp_server-0.1.2/src/decimer_mcp_server.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+src/decimer_mcp_server/__init__.py
+src/decimer_mcp_server/__main__.py
+src/decimer_mcp_server/config.py
+src/decimer_mcp_server/decimer_api_client.py
+src/decimer_mcp_server/schemas.py
+src/decimer_mcp_server/server.py
+src/decimer_mcp_server/smoke_test.py
+src/decimer_mcp_server.egg-info/PKG-INFO
+src/decimer_mcp_server.egg-info/SOURCES.txt
+src/decimer_mcp_server.egg-info/dependency_links.txt
+src/decimer_mcp_server.egg-info/entry_points.txt
+src/decimer_mcp_server.egg-info/requires.txt
+src/decimer_mcp_server.egg-info/top_level.txt
+tests/test_api_client_unit.py
+tests/test_integration_optional.py
+tests/test_tools_unit.py

decimer_mcp_server-0.1.2/src/decimer_mcp_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

decimer_mcp_server-0.1.2/src/decimer_mcp_server.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+decimer-mcp-server = decimer_mcp_server.__main__:main
+decimer-mcp-smoke-test = decimer_mcp_server.smoke_test:main

decimer_mcp_server-0.1.2/src/decimer_mcp_server.egg-info/requires.txt

@@ -0,0 +1,6 @@
+mcp>=1.2.0
+httpx>=0.27.0
+pydantic>=2.8.0
+
+[dev]
+pytest>=8.0.0

decimer_mcp_server-0.1.2/src/decimer_mcp_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+decimer_mcp_server

decimer_mcp_server-0.1.2/tests/test_api_client_unit.py

@@ -0,0 +1,28 @@
+import base64
+
+from decimer_mcp_server.decimer_api_client import DecimerAPIClient
+
+
+def test_validate_image_size_allows_small_payload() -> None:
+    client = DecimerAPIClient(
+        base_url="http://localhost:8099",
+        timeout_seconds=1.0,
+        max_image_bytes=20,
+    )
+    encoded = base64.b64encode(b"12345").decode("utf-8")
+    client._validate_image_size(encoded)
+
+
+def test_validate_image_size_rejects_large_payload() -> None:
+    client = DecimerAPIClient(
+        base_url="http://localhost:8099",
+        timeout_seconds=1.0,
+        max_image_bytes=4,
+    )
+    encoded = base64.b64encode(b"12345").decode("utf-8")
+
+    try:
+        client._validate_image_size(encoded)
+        assert False, "Expected ValueError for oversized image payload"
+    except ValueError as exc:
+        assert "exceeds limit" in str(exc)

decimer_mcp_server-0.1.2/tests/test_integration_optional.py

@@ -0,0 +1,23 @@
+"""Optional integration tests.
+
+Run with a live DecimerServerAPI instance listening on DECIMER_API_BASE_URL.
+"""
+
+import os
+
+import pytest
+
+from decimer_mcp_server.decimer_api_client import DecimerAPIClient
+
+
+@pytest.mark.anyio
+async def test_health_live() -> None:
+    base_url = os.getenv("DECIMER_API_BASE_URL")
+    if not base_url:
+        pytest.skip("DECIMER_API_BASE_URL not set")
+
+    client = DecimerAPIClient(
+        base_url=base_url, timeout_seconds=5.0, max_image_bytes=1_000_000
+    )
+    result = await client.health()
+    assert result.status_code in (200, 503, 504)

decimer_mcp_server-0.1.2/tests/test_tools_unit.py

@@ -0,0 +1,15 @@
+from decimer_mcp_server.schemas import AnalyzeChemicalImageInput
+
+
+def test_input_schema_accepts_valid_base64() -> None:
+    valid = "aGVsbG8="
+    parsed = AnalyzeChemicalImageInput(encoded_image=valid)
+    assert parsed.encoded_image == valid
+
+
+def test_input_schema_rejects_invalid_base64() -> None:
+    try:
+        AnalyzeChemicalImageInput(encoded_image="not_base64!!!")
+        assert False, "Expected base64 validation failure"
+    except ValueError as exc:
+        assert "valid base64" in str(exc)