Upload 14 files

Dockerfile

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

README.md

@@ -1,10 +1,58 @@
 ---
-title: Biopython
-emoji: 🐨
-colorFrom: purple
-colorTo: blue
+title: biopython 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
+# biopython MCP Service
+
+This deployment package exposes core Biopython sequence-analysis capabilities as an MCP service using FastMCP.
+
+## Available Tools
+
+- `health_check`
+- `parse_fasta_text`
+- `translate_dna`
+- `reverse_complement`
+- `global_align`
+- `compute_gc_fraction`
+- `find_motif_positions`
+
+## Local stdio (Claude Desktop / CLI)
+
+```bash
+cd biopython/mcp_output
+MCP_TRANSPORT=stdio python start_mcp.py
+```
+
+You can also run the local stdio entry directly:
+
+```bash
+cd biopython/mcp_output/mcp_plugin
+python main.py
+```
+
+## HTTP MCP (Docker / HF Spaces)
+
+This deployment uses FastMCP HTTP transport, with endpoint exposed at `/mcp`.
+
+Local run:
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=7860 python biopython/mcp_output/start_mcp.py
+```
+
+Docker run:
+
+```bash
+./run_docker.sh
+```
+
+Then connect MCP clients to:
+
+- `http://localhost:7860/mcp`
+- `https://<your-space-host>/mcp`

app.py

@@ -1,45 +1,82 @@
-from fastapi import FastAPI
+"""Supplementary FastAPI app for local inspection (not MCP runtime entrypoint)."""
+
+from __future__ import annotations
+
 import os
+import importlib
 import sys
+from pathlib import Path
+from typing import Any
+
+try:
+    FastAPI = getattr(importlib.import_module("fastapi"), "FastAPI", None)
+except Exception:
+    FastAPI = None
+
+PLUGIN_DIR = Path(__file__).resolve().parent / "biopython" / "mcp_output" / "mcp_plugin"
+plugin_dir_str = str(PLUGIN_DIR)
+if plugin_dir_str not in sys.path:
+    sys.path.insert(0, plugin_dir_str)
+
+if FastAPI is not None:
+    app = FastAPI(title="biopython-mcp-info", version="1.0.0")
+else:
+    class _FallbackApp:
+        def get(self, *_args: Any, **_kwargs: Any):
+            def decorator(func):
+                return func
+
+            return decorator
+
+    app = _FallbackApp()
+PORT = int(os.getenv("PORT", "7860"))
 
-mcp_plugin_path = os.path.join(os.path.dirname(__file__), "biopython", "mcp_output", "mcp_plugin")
-sys.path.insert(0, mcp_plugin_path)
 
-app = FastAPI(
-    title="Biopython MCP Service",
-    description="Auto-generated MCP service for biopython",
-    version="1.0.0"
-)
+def _extract_tools(app_obj: Any) -> list[dict[str, str]]:
+    tools_attr = getattr(app_obj, "tools", None)
+    if tools_attr is None:
+        return []
+
+    if isinstance(tools_attr, dict):
+        items = tools_attr.values()
+    else:
+        items = tools_attr
+
+    tools: list[dict[str, str]] = []
+    for item in items:
+        if isinstance(item, dict):
+            name = str(item.get("name", ""))
+            description = str(item.get("description", ""))
+        else:
+            name = str(getattr(item, "name", getattr(item, "__name__", "")))
+            description = str(getattr(item, "description", ""))
+        if name:
+            tools.append({"name": name, "description": description})
+    return tools
+
 
 @app.get("/")
-def root():
+def root() -> dict[str, Any]:
     return {
-        "service": "Biopython MCP Service",
-        "version": "1.0.0",
-        "status": "running",
-        "transport": os.environ.get("MCP_TRANSPORT", "http")
+        "service": "biopython-mcp-deployment",
+        "mcp_transport": os.getenv("MCP_TRANSPORT", "stdio"),
+        "mcp_port": os.getenv("MCP_PORT", "8000"),
+        "info_port": PORT,
+        "note": "This FastAPI app is supplementary and does not run the MCP server.",
     }
 
+
 @app.get("/health")
-def health_check():
-    return {"status": "healthy", "service": "biopython MCP"}
+def health() -> dict[str, str]:
+    return {"status": "healthy"}
+
 
 @app.get("/tools")
-def list_tools():
+def tools() -> dict[str, Any]:
     try:
-        from mcp_service import create_app
+        create_app = getattr(importlib.import_module("mcp_service"), "create_app")
+
         mcp_app = create_app()
-        tools = []
-        for tool_name, tool_func in mcp_app.tools.items():
-            tools.append({
-                "name": tool_name,
-                "description": tool_func.__doc__ or "No description available"
-            })
-        return {"tools": tools}
-    except Exception as e:
-        return {"error": f"Failed to load tools: {str(e)}"}
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+        return {"tools": _extract_tools(mcp_app)}
+    except Exception as exc:
+        return {"tools": [], "error": str(exc)}

biopython/mcp_output/README_MCP.md

@@ -1,119 +1,99 @@
-# Biopython MCP (Model Context Protocol) Service README
-
-## 1) Project Introduction
-
-This service wraps core Biopython APIs as MCP (Model Context Protocol) tools for sequence, alignment, structure, phylogeny, search-result parsing, and NCBI Entrez retrieval workflows.
-
-Primary goals:
-- Provide stable, developer-friendly bioinformatics operations via MCP (Model Context Protocol)
-- Expose high-value Biopython modules (`SeqIO`, `AlignIO`, `Align`, `PDB`, `Phylo`, `SearchIO`, `Entrez`)
-- Enable format conversion, parsing, indexing, and basic analysis in a tool-callable interface
-
----
-
-## 2) Installation Method
-
-### Requirements
-- Python 3.x
-- `biopython`
-- `numpy` (required by Biopython)
-
-Optional (feature-dependent):
-- `reportlab` (graphics/genome diagrams)
-- `matplotlib` (phylo plotting)
-- `networkx` or `igraph` (some phylo integrations)
-- `mmtf-python` (MMTF support)
-- DB drivers for BioSQL: `mysqlclient` / `mysql-connector-python` / `psycopg2` / `sqlite3`
-- External binaries for some modules: DSSP, NACCESS, PAML, BLAST tools
-
-### Install
-pip install biopython numpy
-
-Optional extras (as needed):
-pip install reportlab matplotlib networkx mmtf-python
-
----
-
-## 3) Quick Start
-
-### Minimal usage flow
-1. Start your MCP (Model Context Protocol) host runtime
-2. Register this Biopython service
-3. Call tools such as sequence parse/read/write or alignment/structure parsers
-
-### Typical tool calls (conceptual)
-- Parse FASTA/GenBank records using `SeqIO.parse` / `SeqIO.read`
-- Convert sequence formats using `SeqIO.convert`
-- Parse alignments using `AlignIO.parse` or modern `Bio.Align.parse`
-- Load substitution matrices via `Bio.Align.substitution_matrices.load`
-- Parse PDB/mmCIF structures with `PDBParser` / `MMCIFParser`
-- Read/convert phylogenetic trees via `Phylo.read` / `Phylo.convert`
-- Parse BLAST/HMMER outputs via `SearchIO.parse`
-- Query NCBI with `Entrez.esearch` + `Entrez.efetch`
-
----
-
-## 4) Available Tools and Endpoints List
-
-Recommended MCP (Model Context Protocol) endpoints for this service:
-
-- `seqio_parse`
-  - Parse multi-record sequence files (FASTA/GenBank/EMBL/FASTQ/etc.)
-- `seqio_read`
-  - Read exactly one sequence record
-- `seqio_write`
-  - Write sequence records to target format
-- `seqio_convert`
-  - Convert sequence files between supported formats
-- `seqio_index` / `seqio_index_db`
-  - Build lightweight/random-access sequence indexes
-
-- `alignio_parse` / `alignio_read` / `alignio_write` / `alignio_convert`
-  - Multiple sequence alignment I/O and conversion
-
-- `align_parse` / `align_read` / `align_write`
-  - Modern `Bio.Align` alignment APIs
-- `pairwise_align`
-  - Pairwise alignment via `PairwiseAligner`
-- `load_substitution_matrix`
-  - Load scoring matrices (e.g., BLOSUM/PAM)
-
-- `pdb_parse`
-  - Parse PDB files
-- `mmcif_parse`
-  - Parse mmCIF files
-- `pdb_write`
-  - Export structures
-- `structure_superimpose` / `neighbor_search`
-  - Structural comparison and proximity queries
-
-- `phylo_read` / `phylo_parse` / `phylo_write` / `phylo_convert`
-  - Phylogenetic tree I/O workflows
-
-- `searchio_parse` / `searchio_read` / `searchio_index` / `searchio_convert`
-  - Search tool output parsing (BLAST/HMMER/Infernal/Exonerate)
-
-- `entrez_esearch` / `entrez_efetch` / `entrez_esummary` / `entrez_elink`
-  - NCBI E-utilities access (network dependent)
-
----
-
-## 5) Common Issues and Notes
-
-- No first-class package CLI entry points are defined; Biopython is primarily a library.
-- Some capabilities require optional dependencies or external binaries.
-- Entrez usage requires internet and proper NCBI etiquette (`Entrez.email`, rate-limit awareness, API key if needed).
-- Large files (BAM-like, big alignments, massive GenBank) should use streaming/indexing to avoid memory pressure.
-- Format strictness varies; malformed biological files may parse partially or fail.
-- BioSQL features need database-specific drivers and schema setup.
-- Use pinned versions in production for reproducibility.
-
----
-
-## 6) Reference Links / Documentation
-
-- Biopython repository: https://github.com/biopython/biopython
-- Biopython docs: https://biopython.org/wiki/Documentation
-- API docs: https://biopython.org/docs/latest/api/
-- Tutorial & Cookbook: https://biopython.org/DIST/docs/tutorial/Tutorial.html
-- NCBI Entrez E-utilities: https://www.ncbi.nlm.nih.gov/books/NBK25501/
+# Biopython MCP Plugin
+
+This MCP plugin exposes core Biopython sequence-analysis capabilities through FastMCP.
+
+## Exposed Tools
+
+### 1) `health_check`
+- **Parameters**: none
+- **Returns**: dependency availability and adapter/module loading health.
+- **Example**:
+```json
+{"name":"health_check","arguments":{}}
+```
+
+### 2) `parse_fasta_text`
+- **Parameters**:
+  - `fasta_text: str` - FASTA content
+  - `max_records: int = 50` - max records to return
+- **Returns**: parsed records with id, description, length, and sequence.
+- **Example**:
+```json
+{"name":"parse_fasta_text","arguments":{"fasta_text":">seq1\nATGC\n","max_records":10}}
+```
+
+### 3) `translate_dna`
+- **Parameters**:
+  - `sequence: str`
+  - `to_stop: bool = false`
+  - `table: int = 1`
+- **Returns**: translated protein sequence.
+- **Example**:
+```json
+{"name":"translate_dna","arguments":{"sequence":"ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG"}}
+```
+
+### 4) `reverse_complement`
+- **Parameters**:
+  - `sequence: str`
+- **Returns**: reverse-complement sequence.
+- **Example**:
+```json
+{"name":"reverse_complement","arguments":{"sequence":"ATGCCT"}}
+```
+
+### 5) `global_align`
+- **Parameters**:
+  - `seq_a: str`
+  - `seq_b: str`
+  - `match_score: float = 1.0`
+  - `mismatch_score: float = -1.0`
+  - `open_gap_score: float = -0.5`
+  - `extend_gap_score: float = -0.1`
+  - `max_alignments: int = 5`
+- **Returns**: alignment list with score/start/end.
+- **Example**:
+```json
+{"name":"global_align","arguments":{"seq_a":"ACCGT","seq_b":"ACG"}}
+```
+
+### 6) `compute_gc_fraction`
+- **Parameters**:
+  - `sequence: str`
+- **Returns**: GC fraction in [0,1].
+- **Example**:
+```json
+{"name":"compute_gc_fraction","arguments":{"sequence":"ATGCGCGT"}}
+```
+
+### 7) `find_motif_positions`
+- **Parameters**:
+  - `sequence: str`
+  - `motif: str`
+- **Returns**: motif and all start positions.
+- **Example**:
+```json
+{"name":"find_motif_positions","arguments":{"sequence":"ATGATGAT","motif":"ATG"}}
+```
+
+## Run Locally (stdio)
+
+From `mcp_output/`:
+
+```bash
+python start_mcp.py
+```
+
+Or explicit:
+
+```bash
+MCP_TRANSPORT=stdio python start_mcp.py
+```
+
+## Run via HTTP
+
+```bash
+MCP_TRANSPORT=http MCP_PORT=8000 python start_mcp.py
+```
+
+MCP endpoint will be served by FastMCP at `/mcp`.

biopython/mcp_output/mcp_plugin/adapter.py

@@ -1,432 +1,199 @@
-import os
-import sys
-from typing import Any, Dict, Optional, Tuple
-
-source_path = os.path.join(
-    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-    "source",
-)
-sys.path.insert(0, source_path)
+"""Adapter layer for dynamic Biopython module loading and execution."""
 
+from __future__ import annotations
 
-class Adapter:
-    """
-    MCP Import-mode adapter for Biopython core I/O and alignment surfaces.
-
-    This adapter targets the analyzed modules:
-    - source.Bio.SeqIO -> Bio.SeqIO
-    - source.Bio.AlignIO -> Bio.AlignIO
-    - source.Bio.Align -> Bio.Align
+import importlib
+import inspect
+import pkgutil
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Any
 
-    It provides:
-    - Dedicated class instance factory methods for identified classes:
-      PairwiseAligner, Alignment, Alignments
-    - Dedicated function-call methods for identified functions:
-      parse, read, write (for SeqIO / AlignIO / Align)
-    - Unified dictionary response format with status field
-    - Graceful fallback when import fails
-    """
+SOURCE_DIR = Path(__file__).resolve().parents[2] / "source"
+if SOURCE_DIR.exists():
+    source_dir_str = str(SOURCE_DIR)
+    if source_dir_str not in sys.path:
+        sys.path.insert(0, source_dir_str)
 
-    # -------------------------------------------------------------------------
-    # Initialization and module management
-    # -------------------------------------------------------------------------
-    def __init__(self) -> None:
-        """
-        Initialize adapter in import mode and attempt module imports.
 
-        Attributes:
-            mode (str): Always "import" for this adapter.
-            available (bool): True if core imports succeeded.
-            import_error (Optional[str]): Captured import error if unavailable.
-        """
-        self.mode = "import"
-        self.available = False
-        self.import_error: Optional[str] = None
+class Adapter:
+    """Dynamically loads Biopython modules and provides introspection/execution helpers."""
 
-        self._seqio = None
-        self._alignio = None
-        self._align = None
+    def __init__(self, root_package: str = "Bio") -> None:
+        self.root_package = root_package
+        self.loaded_modules: dict[str, ModuleType] = {}
+        self.failed_modules: dict[str, str] = {}
+        self.mode = "active"
+        self._load_root_package()
 
-        self._import_modules()
+    def _status(self, status: str, **payload: Any) -> dict[str, Any]:
+        result: dict[str, Any] = {"status": status}
+        result.update(payload)
+        return result
 
-    def _import_modules(self) -> None:
-        """Attempt importing required modules and classes from repository source tree."""
+    def _load_root_package(self) -> None:
         try:
-            import Bio.SeqIO as seqio_module
-            import Bio.AlignIO as alignio_module
-            import Bio.Align as align_module
-
-            self._seqio = seqio_module
-            self._alignio = alignio_module
-            self._align = align_module
-            self.available = True
-            self.import_error = None
+            root = importlib.import_module(self.root_package)
+            self.loaded_modules[self.root_package] = root
+            self.mode = "active"
         except Exception as exc:
-            self.available = False
-            self.import_error = (
-                f"Import failed. Ensure repository source is present under '{source_path}' "
-                f"and compatible dependencies are installed. Details: {exc}"
+            self.failed_modules[self.root_package] = str(exc)
+            self.mode = "blackbox"
+
+    def load_all_submodules(self) -> dict[str, Any]:
+        """Load all importable submodules under the root package."""
+        if self.root_package not in self.loaded_modules:
+            self.mode = "blackbox"
+            return self._status(
+                "fallback",
+                mode=self.mode,
+                loaded=0,
+                failed=len(self.failed_modules),
+                message="Root package unavailable; running in blackbox mode.",
             )
 
-    def _result(self, status: str, **kwargs: Any) -> Dict[str, Any]:
-        """Create unified result dictionary."""
-        payload = {"status": status, "mode": self.mode}
-        payload.update(kwargs)
-        return payload
-
-    def _ensure_available(self) -> Tuple[bool, Optional[Dict[str, Any]]]:
-        """Check adapter availability and return fallback error payload when unavailable."""
-        if not self.available:
-            return False, self._result(
-                "error",
-                message=self.import_error
-                or "Adapter imports are unavailable. Verify source path and dependencies.",
-                actionable_guidance=(
-                    "Confirm the 'source' directory exists, includes Bio package, and retry. "
-                    "If needed, install optional dependencies required by target format."
-                ),
-            )
-        return True, None
-
-    # -------------------------------------------------------------------------
-    # Health and capability methods
-    # -------------------------------------------------------------------------
-    def health(self) -> Dict[str, Any]:
-        """
-        Return adapter health and import status.
-        """
-        if self.available:
-            return self._result(
+        root = self.loaded_modules[self.root_package]
+        if not hasattr(root, "__path__"):
+            return self._status(
                 "ok",
-                available=True,
-                modules=["Bio.SeqIO", "Bio.AlignIO", "Bio.Align"],
+                mode=self.mode,
+                loaded=len(self.loaded_modules),
+                failed=len(self.failed_modules),
+                message="Root package has no __path__; no submodules discovered.",
             )
-        return self._result(
-            "error",
-            available=False,
-            message=self.import_error,
-        )
-
-    # -------------------------------------------------------------------------
-    # Class instance factory methods (identified classes from Bio.Align)
-    # -------------------------------------------------------------------------
-    def create_pairwise_aligner(self, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Create a Bio.Align.PairwiseAligner instance.
 
-        Parameters:
-            **kwargs: Attributes to set on the newly created aligner, e.g.
-                mode="local", match_score=2.0, mismatch_score=-1.0,
-                open_gap_score=-0.5, extend_gap_score=-0.1
-
-        Returns:
-            dict: Unified status payload with aligner instance under 'instance' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            cls = getattr(self._align, "PairwiseAligner")
-            obj = cls()
-            for k, v in kwargs.items():
-                setattr(obj, k, v)
-            return self._result("ok", instance=obj, class_name="PairwiseAligner")
-        except Exception as exc:
-            return self._result(
-                "error",
-                message=f"Failed to create PairwiseAligner: {exc}",
-                actionable_guidance="Validate aligner parameter names and values.",
+        for module_info in pkgutil.walk_packages(root.__path__, prefix=f"{self.root_package}."):
+            module_name = module_info.name
+            if module_name in self.loaded_modules or module_name in self.failed_modules:
+                continue
+            try:
+                module = importlib.import_module(module_name)
+                self.loaded_modules[module_name] = module
+            except Exception as exc:
+                self.failed_modules[module_name] = str(exc)
+
+        if not self.loaded_modules:
+            self.mode = "blackbox"
+            return self._status(
+                "fallback",
+                mode=self.mode,
+                loaded=0,
+                failed=len(self.failed_modules),
+                message="No modules loaded; running in blackbox mode.",
             )
 
-    def create_alignment(self, sequences: Any = None, coordinates: Any = None) -> Dict[str, Any]:
-        """
-        Create a Bio.Align.Alignment instance.
-
-        Parameters:
-            sequences: Sequence-like inputs expected by Bio.Align.Alignment.
-            coordinates: Optional coordinates array-like object.
-
-        Returns:
-            dict: Unified status payload with alignment instance under 'instance' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            cls = getattr(self._align, "Alignment")
-            if sequences is not None and coordinates is not None:
-                obj = cls(sequences, coordinates)
-            elif sequences is not None:
-                obj = cls(sequences)
-            else:
-                obj = cls()
-            return self._result("ok", instance=obj, class_name="Alignment")
-        except Exception as exc:
-            return self._result(
-                "error",
-                message=f"Failed to create Alignment: {exc}",
-                actionable_guidance=(
-                    "Provide valid sequences and optional coordinates matching Bio.Align.Alignment expectations."
-                ),
-            )
+        return self._status(
+            "ok",
+            mode=self.mode,
+            loaded=len(self.loaded_modules),
+            failed=len(self.failed_modules),
+            message="Module scan complete.",
+        )
 
-    def create_alignments(self, iterable: Any = None) -> Dict[str, Any]:
-        """
-        Create a Bio.Align.Alignments instance.
+    def health(self) -> dict[str, Any]:
+        """Return module loading health information."""
+        status = "ok" if self.loaded_modules else "fallback"
+        return self._status(
+            status,
+            mode=self.mode,
+            root_package=self.root_package,
+            loaded_count=len(self.loaded_modules),
+            failed_count=len(self.failed_modules),
+        )
 
-        Parameters:
-            iterable: Optional iterable of alignment objects.
+    def list_modules(self) -> dict[str, Any]:
+        """List loaded and failed module names."""
+        status = "ok" if self.loaded_modules else "fallback"
+        return self._status(
+            status,
+            mode=self.mode,
+            loaded_modules=sorted(self.loaded_modules.keys()),
+            failed_modules=sorted(self.failed_modules.keys()),
+        )
 
-        Returns:
-            dict: Unified status payload with alignments instance under 'instance' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            cls = getattr(self._align, "Alignments")
-            obj = cls(iterable) if iterable is not None else cls()
-            return self._result("ok", instance=obj, class_name="Alignments")
-        except Exception as exc:
-            return self._result(
+    def list_symbols(self, module_name: str) -> dict[str, Any]:
+        """List public symbols from a loaded module."""
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            if module_name in self.failed_modules:
+                return self._status(
+                    "error",
+                    message="Module failed to load.",
+                    module=module_name,
+                    error=self.failed_modules[module_name],
+                )
+            return self._status(
                 "error",
-                message=f"Failed to create Alignments: {exc}",
-                actionable_guidance="Ensure iterable elements are valid alignment objects.",
+                message="Module is not loaded.",
+                module=module_name,
             )
 
-    # -------------------------------------------------------------------------
-    # SeqIO function wrappers: parse/read/write
-    # -------------------------------------------------------------------------
-    def seqio_parse(self, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.SeqIO.parse.
+        symbols = [name for name in dir(module) if not name.startswith("_")]
+        return self._status("ok", module=module_name, symbols=symbols)
 
-        Parameters:
-            handle: File path, handle, or text stream.
-            format (str): Sequence file format (e.g., 'fasta', 'genbank').
-            **kwargs: Extra parser options forwarded to Bio.SeqIO.parse.
-
-        Returns:
-            dict: status='ok' with iterator under 'result' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._seqio.parse(handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.SeqIO", function="parse")
-        except Exception as exc:
-            return self._result(
+    def call_function(self, module_name: str, function_name: str, args: list[Any]) -> dict[str, Any]:
+        """Call a function by module and function name."""
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return self._status(
                 "error",
-                message=f"Bio.SeqIO.parse failed: {exc}",
-                actionable_guidance="Verify input handle/path and format string.",
+                message="Module is not loaded.",
+                module=module_name,
             )
 
-    def seqio_read(self, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.SeqIO.read.
-
-        Parameters:
-            handle: File path, handle, or text stream containing exactly one record.
-            format (str): Sequence file format.
-            **kwargs: Extra options forwarded to Bio.SeqIO.read.
-
-        Returns:
-            dict: status='ok' with record under 'result' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._seqio.read(handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.SeqIO", function="read")
-        except Exception as exc:
-            return self._result(
+        target = getattr(module, function_name, None)
+        if target is None or not callable(target):
+            return self._status(
                 "error",
-                message=f"Bio.SeqIO.read failed: {exc}",
-                actionable_guidance="Ensure exactly one record exists in input for read().",
+                message="Function not found or not callable.",
+                module=module_name,
+                function=function_name,
             )
 
-    def seqio_write(self, sequences: Any, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.SeqIO.write.
-
-        Parameters:
-            sequences: SeqRecord or iterable of SeqRecord objects.
-            handle: Output file path or writable handle.
-            format (str): Output format.
-            **kwargs: Extra options forwarded to Bio.SeqIO.write.
-
-        Returns:
-            dict: status='ok' with count under 'result' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
         try:
-            result = self._seqio.write(sequences, handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.SeqIO", function="write")
+            value = target(*args)
+            return self._status("ok", module=module_name, function=function_name, result=value)
         except Exception as exc:
-            return self._result(
+            return self._status(
                 "error",
-                message=f"Bio.SeqIO.write failed: {exc}",
-                actionable_guidance="Validate sequence objects, output handle, and format.",
+                module=module_name,
+                function=function_name,
+                error=str(exc),
             )
 
-    # -------------------------------------------------------------------------
-    # AlignIO function wrappers: parse/read/write
-    # -------------------------------------------------------------------------
-    def alignio_parse(self, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.AlignIO.parse.
-
-        Parameters:
-            handle: File path, handle, or text stream.
-            format (str): Alignment format (e.g., 'clustal', 'stockholm', 'phylip').
-            **kwargs: Extra parser options.
-
-        Returns:
-            dict: status='ok' with iterator under 'result' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._alignio.parse(handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.AlignIO", function="parse")
-        except Exception as exc:
-            return self._result(
+    def create_instance(self, module_name: str, class_name: str, args: list[Any]) -> dict[str, Any]:
+        """Create an instance from a class in a loaded module."""
+        module = self.loaded_modules.get(module_name)
+        if module is None:
+            return self._status(
                 "error",
-                message=f"Bio.AlignIO.parse failed: {exc}",
-                actionable_guidance="Check alignment input source and specified format.",
+                message="Module is not loaded.",
+                module=module_name,
             )
 
-    def alignio_read(self, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.AlignIO.read.
-
-        Parameters:
-            handle: Input file path or handle containing one alignment.
-            format (str): Alignment format.
-            **kwargs: Extra options.
-
-        Returns:
-            dict: status='ok' with alignment object under 'result' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._alignio.read(handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.AlignIO", function="read")
-        except Exception as exc:
-            return self._result(
+        cls = getattr(module, class_name, None)
+        if cls is None or not inspect.isclass(cls):
+            return self._status(
                 "error",
-                message=f"Bio.AlignIO.read failed: {exc}",
-                actionable_guidance="Ensure input contains exactly one alignment.",
+                message="Class not found.",
+                module=module_name,
+                class_name=class_name,
             )
 
-    def alignio_write(self, alignments: Any, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.AlignIO.write.
-
-        Parameters:
-            alignments: Alignment object or iterable of alignments.
-            handle: Output file path or writable handle.
-            format (str): Alignment output format.
-            **kwargs: Extra options.
-
-        Returns:
-            dict: status='ok' with write count under 'result' on success.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
         try:
-            result = self._alignio.write(alignments, handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.AlignIO", function="write")
-        except Exception as exc:
-            return self._result(
-                "error",
-                message=f"Bio.AlignIO.write failed: {exc}",
-                actionable_guidance="Validate alignment objects and output destination.",
-            )
-
-    # -------------------------------------------------------------------------
-    # Align function wrappers: parse/read/write
-    # -------------------------------------------------------------------------
-    def align_parse(self, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.Align.parse.
-
-        Parameters:
-            handle: Alignment input source.
-            format (str): Format supported by Bio.Align parser.
-            **kwargs: Additional parser options.
-
-        Returns:
-            dict: status='ok' with iterator or alignment stream under 'result'.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._align.parse(handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.Align", function="parse")
-        except Exception as exc:
-            return self._result(
-                "error",
-                message=f"Bio.Align.parse failed: {exc}",
-                actionable_guidance="Verify format and input compatibility with Bio.Align.",
+            instance = cls(*args)
+            return self._status(
+                "ok",
+                module=module_name,
+                class_name=class_name,
+                instance_type=type(instance).__name__,
+                repr=repr(instance),
             )
-
-    def align_read(self, handle: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.Align.read.
-
-        Parameters:
-            handle: Input source containing a single alignment item.
-            format (str): Expected alignment format.
-            **kwargs: Additional read options.
-
-        Returns:
-            dict: status='ok' with alignment object under 'result'.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._align.read(handle, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.Align", function="read")
         except Exception as exc:
-            return self._result(
+            return self._status(
                 "error",
-                message=f"Bio.Align.read failed: {exc}",
-                actionable_guidance="Ensure a single valid alignment is present in the input.",
+                module=module_name,
+                class_name=class_name,
+                error=str(exc),
             )
-
-    def align_write(self, alignments: Any, target: Any, format: str, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Call Bio.Align.write.
-
-        Parameters:
-            alignments: Alignment or iterable of alignments.
-            target: Output destination path or handle.
-            format (str): Output format.
-            **kwargs: Additional write options.
-
-        Returns:
-            dict: status='ok' with write result under 'result'.
-        """
-        ok, err = self._ensure_available()
-        if not ok:
-            return err
-        try:
-            result = self._align.write(alignments, target, format, **kwargs)
-            return self._result("ok", result=result, module="Bio.Align", function="write")
-        except Exception as exc:
-            return self._result(
-                "error",
-                message=f"Bio.Align.write failed: {exc}",
-                actionable_guidance="Check output target permissions and alignment object validity.",
-            )

biopython/mcp_output/mcp_plugin/main.py

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

biopython/mcp_output/mcp_plugin/mcp_service.py

@@ -1,281 +1,264 @@
-import os
-import sys
-from io import StringIO
-from typing import List, Optional, Dict, 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)
-
-from fastmcp import FastMCP
-from Bio import SeqIO, AlignIO, Align
-from Bio.Seq import Seq
-from Bio.SeqRecord import SeqRecord
+"""FastMCP service exposing core Biopython capabilities."""
 
+from __future__ import annotations
 
-mcp = FastMCP("biopython_core_service")
-
-
-@mcp.tool(
-    name="seqio_parse_text",
-    description="Parse sequence records from text using Bio.SeqIO.parse.",
-)
-def seqio_parse_text(format_name: str, data: str) -> Dict[str, Any]:
+import importlib
+import sys
+from pathlib import Path
+from typing import Any
+
+SOURCE_DIR = Path(__file__).resolve().parents[2] / "source"
+if SOURCE_DIR.exists():
+    source_dir_str = str(SOURCE_DIR)
+    if source_dir_str not in sys.path:
+        sys.path.insert(0, source_dir_str)
+
+try:
+    from fastmcp import FastMCP
+except Exception:
+    FastMCP = None
+
+try:
+    _bio_seq_module = importlib.import_module("Bio.Seq")
+    Seq = getattr(_bio_seq_module, "Seq", None)
+except Exception:
+    Seq = None
+
+try:
+    SeqIO = importlib.import_module("Bio.SeqIO")
+except Exception:
+    SeqIO = None
+
+try:
+    pairwise2 = importlib.import_module("Bio.pairwise2")
+except Exception:
+    pairwise2 = None
+
+try:
+    _sequtils_module = importlib.import_module("Bio.SeqUtils")
+    gc_fraction = getattr(_sequtils_module, "gc_fraction", None)
+except Exception:
+    gc_fraction = None
+
+try:
+    _sequtils_module2 = importlib.import_module("Bio.SeqUtils")
+    nt_search = getattr(_sequtils_module2, "nt_search", None)
+except Exception:
+    nt_search = None
+
+from adapter import Adapter
+
+
+class _FallbackMCP:
+    def __init__(self) -> None:
+        self.tools: list[Any] = []
+
+    def tool(self, name: str, description: str):
+        def decorator(func):
+            func.name = name
+            func.description = description
+            self.tools.append(func)
+            return func
+
+        return decorator
+
+    def run(self, *_, **__):
+        raise RuntimeError("fastmcp is unavailable")
+
+
+mcp = FastMCP("biopython-mcp-service") if FastMCP is not None else _FallbackMCP()
+adapter = Adapter(root_package="Bio")
+adapter.load_all_submodules()
+
+
+def _response(success: bool, result: Any = None, error: str | None = None) -> dict[str, Any]:
+    return {"success": success, "result": result, "error": error}
+
+
+@mcp.tool(name="health_check", description="Check MCP service and Biopython dependency health.")
+def health_check() -> dict[str, Any]:
+    """Return runtime health details including dependency availability and adapter status."""
+    deps = {
+        "fastmcp": FastMCP is not None,
+        "Bio.Seq": Seq is not None,
+        "Bio.SeqIO": SeqIO is not None,
+        "Bio.pairwise2": pairwise2 is not None,
+        "Bio.SeqUtils.gc_fraction": gc_fraction is not None,
+        "Bio.SeqUtils.nt_search": nt_search is not None,
+    }
+    return _response(True, {"dependencies": deps, "adapter": adapter.health()}, None)
+
+
+@mcp.tool(name="parse_fasta_text", description="Parse FASTA text and return sequence summaries.")
+def parse_fasta_text(fasta_text: str, max_records: int = 50) -> dict[str, Any]:
+    """Parse FASTA-formatted text.
+
+    Args:
+        fasta_text: FASTA input content.
+        max_records: Maximum number of records to return.
     """
-    Parse sequence records from in-memory text content.
+    if SeqIO is None:
+        return _response(False, None, "Bio.SeqIO is unavailable")
 
-    Parameters:
-    - format_name: Sequence file format (e.g., 'fasta', 'genbank').
-    - data: Raw text content containing one or more records.
-
-    Returns:
-    - dict with success/result/error.
-    """
     try:
-        handle = StringIO(data)
-        records = list(SeqIO.parse(handle, format_name))
-        result = [
-            {
-                "id": rec.id,
-                "name": rec.name,
-                "description": rec.description,
-                "seq": str(rec.seq),
-                "length": len(rec.seq),
-            }
-            for rec in records
-        ]
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(
-    name="seqio_read_text",
-    description="Read exactly one sequence record from text using Bio.SeqIO.read.",
-)
-def seqio_read_text(format_name: str, data: str) -> Dict[str, Any]:
+        from io import StringIO
+
+        handle = StringIO(fasta_text)
+        parsed = []
+        for idx, record in enumerate(SeqIO.parse(handle, "fasta")):
+            if idx >= max_records:
+                break
+            parsed.append(
+                {
+                    "id": record.id,
+                    "name": record.name,
+                    "description": record.description,
+                    "length": len(record.seq),
+                    "sequence": str(record.seq),
+                }
+            )
+        return _response(True, {"count": len(parsed), "records": parsed}, None)
+    except Exception as exc:
+        return _response(False, None, str(exc))
+
+
+@mcp.tool(name="translate_dna", description="Translate a DNA sequence into amino acids.")
+def translate_dna(sequence: str, to_stop: bool = False, table: int = 1) -> dict[str, Any]:
+    """Translate a nucleotide sequence.
+
+    Args:
+        sequence: DNA sequence string.
+        to_stop: Whether to stop at first stop codon.
+        table: NCBI codon table number.
     """
-    Read a single sequence record from in-memory text content.
-
-    Parameters:
-    - format_name: Sequence file format.
-    - data: Raw text content containing exactly one record.
+    if Seq is None:
+        return _response(False, None, "Bio.Seq is unavailable")
 
-    Returns:
-    - dict with success/result/error.
-    """
     try:
-        handle = StringIO(data)
-        rec = SeqIO.read(handle, format_name)
-        result = {
-            "id": rec.id,
-            "name": rec.name,
-            "description": rec.description,
-            "seq": str(rec.seq),
-            "length": len(rec.seq),
-        }
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(
-    name="seqio_write_fasta",
-    description="Write sequence records to FASTA text using Bio.SeqIO.write.",
-)
-def seqio_write_fasta(
-    sequences: List[str],
-    ids: Optional[List[str]] = None,
-    descriptions: Optional[List[str]] = None,
-) -> Dict[str, Any]:
-    """
-    Create FASTA text from provided sequences.
+        protein = str(Seq(sequence).translate(to_stop=to_stop, table=table))
+        return _response(True, {"protein": protein, "length": len(protein)}, None)
+    except Exception as exc:
+        return _response(False, None, str(exc))
 
-    Parameters:
-    - sequences: List of sequence strings.
-    - ids: Optional list of IDs matching sequence count.
-    - descriptions: Optional list of descriptions matching sequence count.
 
-    Returns:
-    - dict with success/result/error.
-    """
-    try:
-        if ids is not None and len(ids) != len(sequences):
-            raise ValueError("Length of ids must match length of sequences")
-        if descriptions is not None and len(descriptions) != len(sequences):
-            raise ValueError("Length of descriptions must match length of sequences")
-
-        records = []
-        for i, seq_text in enumerate(sequences):
-            rec_id = ids[i] if ids is not None else f"seq_{i+1}"
-            rec_desc = descriptions[i] if descriptions is not None else rec_id
-            records.append(SeqRecord(Seq(seq_text), id=rec_id, description=rec_desc))
-
-        out = StringIO()
-        SeqIO.write(records, out, "fasta")
-        return {"success": True, "result": out.getvalue(), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(
-    name="alignio_parse_text",
-    description="Parse alignments from text using Bio.AlignIO.parse.",
-)
-def alignio_parse_text(format_name: str, data: str) -> Dict[str, Any]:
-    """
-    Parse multiple alignments from in-memory text content.
-
-    Parameters:
-    - format_name: Alignment format (e.g., 'clustal', 'stockholm', 'phylip').
-    - data: Raw text content containing one or more alignments.
+@mcp.tool(name="reverse_complement", description="Compute reverse complement for a nucleotide sequence.")
+def reverse_complement(sequence: str) -> dict[str, Any]:
+    """Return reverse complement of a DNA/RNA-like sequence.
 
-    Returns:
-    - dict with success/result/error.
+    Args:
+        sequence: Input nucleotide sequence.
     """
+    if Seq is None:
+        return _response(False, None, "Bio.Seq is unavailable")
+
     try:
-        handle = StringIO(data)
-        aligns = list(AlignIO.parse(handle, format_name))
-        result = [
-            {
-                "num_sequences": len(aln),
-                "alignment_length": aln.get_alignment_length(),
-                "ids": [rec.id for rec in aln],
-            }
-            for aln in aligns
-        ]
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(
-    name="alignio_read_text",
-    description="Read exactly one alignment from text using Bio.AlignIO.read.",
-)
-def alignio_read_text(format_name: str, data: str) -> Dict[str, Any]:
-    """
-    Read a single alignment from in-memory text content.
+        rc = str(Seq(sequence).reverse_complement())
+        return _response(True, {"reverse_complement": rc}, None)
+    except Exception as exc:
+        return _response(False, None, str(exc))
 
-    Parameters:
-    - format_name: Alignment format.
-    - data: Raw text content containing exactly one alignment.
 
-    Returns:
-    - dict with success/result/error.
-    """
-    try:
-        handle = StringIO(data)
-        aln = AlignIO.read(handle, format_name)
-        result = {
-            "num_sequences": len(aln),
-            "alignment_length": aln.get_alignment_length(),
-            "ids": [rec.id for rec in aln],
-            "rows": [str(rec.seq) for rec in aln],
-        }
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(
-    name="align_pairwise_global",
-    description="Run pairwise global alignment using Bio.Align.PairwiseAligner.",
-)
-def align_pairwise_global(
-    sequence_a: str,
-    sequence_b: str,
+@mcp.tool(name="global_align", description="Run global pairwise alignment between two sequences.")
+def global_align(
+    seq_a: str,
+    seq_b: str,
     match_score: float = 1.0,
-    mismatch_score: float = 0.0,
-    open_gap_score: float = -1.0,
-    extend_gap_score: float = -0.5,
-) -> Dict[str, Any]:
-    """
-    Perform global pairwise alignment with configurable scoring.
-
-    Parameters:
-    - sequence_a: First sequence.
-    - sequence_b: Second sequence.
-    - match_score: Score for matching characters.
-    - mismatch_score: Score for mismatching characters.
-    - open_gap_score: Gap opening score.
-    - extend_gap_score: Gap extension score.
-
-    Returns:
-    - dict with success/result/error.
+    mismatch_score: float = -1.0,
+    open_gap_score: float = -0.5,
+    extend_gap_score: float = -0.1,
+    max_alignments: int = 5,
+) -> dict[str, Any]:
+    """Compute global pairwise alignments.
+
+    Args:
+        seq_a: First sequence.
+        seq_b: Second sequence.
+        match_score: Match score.
+        mismatch_score: Mismatch score.
+        open_gap_score: Gap opening penalty.
+        extend_gap_score: Gap extension penalty.
+        max_alignments: Maximum alignments to include in output.
     """
+    if pairwise2 is None:
+        return _response(False, None, "Bio.pairwise2 is unavailable")
+
     try:
-        aligner = Align.PairwiseAligner()
-        aligner.mode = "global"
-        aligner.match_score = match_score
-        aligner.mismatch_score = mismatch_score
-        aligner.open_gap_score = open_gap_score
-        aligner.extend_gap_score = extend_gap_score
-
-        alignments = aligner.align(sequence_a, sequence_b)
-        best = alignments[0]
-        result = {
-            "score": float(best.score),
-            "num_alignments": len(alignments),
-            "alignment": str(best),
-        }
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(
-    name="align_pairwise_local",
-    description="Run pairwise local alignment using Bio.Align.PairwiseAligner.",
-)
-def align_pairwise_local(
-    sequence_a: str,
-    sequence_b: str,
-    match_score: float = 1.0,
-    mismatch_score: float = 0.0,
-    open_gap_score: float = -1.0,
-    extend_gap_score: float = -0.5,
-) -> Dict[str, Any]:
+        alignments = pairwise2.align.globalms(
+            seq_a,
+            seq_b,
+            match_score,
+            mismatch_score,
+            open_gap_score,
+            extend_gap_score,
+        )
+        items = []
+        for alignment in alignments[: max_alignments if max_alignments > 0 else 1]:
+            items.append(
+                {
+                    "seqA": alignment.seqA,
+                    "seqB": alignment.seqB,
+                    "score": alignment.score,
+                    "start": alignment.start,
+                    "end": alignment.end,
+                }
+            )
+        return _response(True, {"count": len(items), "alignments": items}, None)
+    except Exception as exc:
+        return _response(False, None, str(exc))
+
+
+@mcp.tool(name="compute_gc_fraction", description="Compute GC fraction for a nucleotide sequence.")
+def compute_gc_fraction(sequence: str) -> dict[str, Any]:
+    """Compute the GC fraction.
+
+    Args:
+        sequence: Input nucleotide sequence.
     """
-    Perform local pairwise alignment with configurable scoring.
-
-    Parameters:
-    - sequence_a: First sequence.
-    - sequence_b: Second sequence.
-    - match_score: Score for matching characters.
-    - mismatch_score: Score for mismatching characters.
-    - open_gap_score: Gap opening score.
-    - extend_gap_score: Gap extension score.
-
-    Returns:
-    - dict with success/result/error.
+    try:
+        if gc_fraction is not None:
+            value = float(gc_fraction(sequence))
+        else:
+            seq = sequence.upper()
+            value = ((seq.count("G") + seq.count("C")) / len(seq)) if seq else 0.0
+        return _response(True, {"gc_fraction": value}, None)
+    except Exception as exc:
+        return _response(False, None, str(exc))
+
+
+@mcp.tool(name="find_motif_positions", description="Find motif positions in a nucleotide sequence.")
+def find_motif_positions(sequence: str, motif: str) -> dict[str, Any]:
+    """Find positions where motif occurs in a sequence.
+
+    Args:
+        sequence: Sequence to search in.
+        motif: Nucleotide motif to search for.
     """
     try:
-        aligner = Align.PairwiseAligner()
-        aligner.mode = "local"
-        aligner.match_score = match_score
-        aligner.mismatch_score = mismatch_score
-        aligner.open_gap_score = open_gap_score
-        aligner.extend_gap_score = extend_gap_score
-
-        alignments = aligner.align(sequence_a, sequence_b)
-        best = alignments[0]
-        result = {
-            "score": float(best.score),
-            "num_alignments": len(alignments),
-            "alignment": str(best),
-        }
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-def create_app() -> FastMCP:
+        if nt_search is not None:
+            raw = nt_search(sequence.upper(), motif.upper())
+            pattern = raw[0] if raw else motif
+            positions = raw[1:] if len(raw) > 1 else []
+        else:
+            pattern = motif
+            positions = []
+            start = 0
+            upper_seq = sequence.upper()
+            upper_motif = motif.upper()
+            while True:
+                idx = upper_seq.find(upper_motif, start)
+                if idx < 0:
+                    break
+                positions.append(idx)
+                start = idx + 1
+        return _response(True, {"motif": pattern, "positions": positions}, None)
+    except Exception as exc:
+        return _response(False, None, str(exc))
+
+
+def create_app():
+    """Create and return the module-level FastMCP app instance."""
     return mcp
 
 
 if __name__ == "__main__":
-    mcp.run()
+    mcp.run()

biopython/mcp_output/requirements.txt

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

biopython/mcp_output/start_mcp.py

@@ -1,30 +1,33 @@
+"""Environment-aware launcher for MCP service."""
+
+from __future__ import annotations
 
-"""
-MCP Service Startup Entry
-"""
-import sys
 import os
+import sys
+from pathlib import Path
 
-project_root = os.path.dirname(os.path.abspath(__file__))
-mcp_plugin_dir = os.path.join(project_root, "mcp_plugin")
-if mcp_plugin_dir not in sys.path:
-    sys.path.insert(0, mcp_plugin_dir)
+PLUGIN_DIR = Path(__file__).resolve().parent / "mcp_plugin"
+plugin_dir_str = str(PLUGIN_DIR)
+if plugin_dir_str not in sys.path:
+    sys.path.insert(0, plugin_dir_str)
 
 from mcp_service import create_app
 
-def main():
-    """Start FastMCP service"""
+
+def main() -> None:
+    transport = os.getenv("MCP_TRANSPORT", "stdio").strip().lower() or "stdio"
+    port = int(os.getenv("MCP_PORT", "8000"))
     app = create_app()
-    # Use environment variable to configure port, default 8000
-    port = int(os.environ.get("MCP_PORT", "8000"))
-    
-    # Choose transport mode based on environment variable
-    transport = os.environ.get("MCP_TRANSPORT", "stdio")
+
     if transport == "http":
-        app.run(transport="http", host="0.0.0.0", port=port)
-    else:
-        # Default to STDIO mode
-        app.run()
+        try:
+            app.run(transport="http", host="0.0.0.0", port=port)
+        except TypeError:
+            app.run(transport="http", port=port)
+        return
+
+    app.run(transport="stdio")
+
 
 if __name__ == "__main__":
     main()

port.json

@@ -1,5 +1 @@
-{
-  "repo": "biopython",
-  "port": 7862,
-  "timestamp": 1773379300
-}
+{"port": 7860}

requirements.txt

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

run_docker.ps1

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

run_docker.sh

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