bioinformatics-mcp-server 0.1.0__tar.gz

bioinformatics_mcp_server-0.1.0/.gitignore

@@ -0,0 +1,44 @@
+.env
+keys.env
+.mcp.json
+analytics.json
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+venv/
+*.log
+*.egg-info/
+dist/
+build/
+.claude/
+
+# Andere MCP-Projekte (haben eigene Git-Repos)
+Agriculture_MCP/
+Analytics_MCP/
+Aviation_MCP/
+Company_MCP/
+Cybersecurity_MCP/
+Directory_MCP/
+Germany_MCP/
+Health_MCP/
+Memory_MCP/
+Payment_Gateway_MCP/
+Reputation_MCP/
+Space_MCP/
+Weather_MCP/
+Workflow_MCP/
+Agent_Commerce_MCP/
+Agent_Identity_MCP/
+Business_Bridge_MCP/
+github_profile/
+API_Converter_MCP/
+Agent_Coordination_MCP/
+Agent_Interface_Standard/
+Agent_Validator_MCP/
+Feedback_MCP/
+Hive_Mind_MCP/
+MCP_Hub/
+Prompt_Library_MCP/
+Political_Finance_MCP/
+Supply_Chain_MCP/

bioinformatics_mcp_server-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: bioinformatics-mcp-server
+Version: 0.1.0
+Summary: MCP-Server für Bioinformatik-Daten — Gene, Proteine, PubMed-Literatur, Varianten und Sequenzen via NCBI & UniProt
+Project-URL: Homepage, https://github.com/AiAgentKarl/bioinformatics-mcp-server
+Project-URL: Repository, https://github.com/AiAgentKarl/bioinformatics-mcp-server
+Project-URL: Issues, https://github.com/AiAgentKarl/bioinformatics-mcp-server/issues
+Author: AiAgentKarl
+License-Expression: MIT
+Keywords: ai-agent,bioinformatics,genes,genomics,life-science,mcp,ncbi,proteins,pubmed,uniprot
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Description-Content-Type: text/markdown
+
+# bioinformatics-mcp-server
+
+MCP-Server für Bioinformatik- und Life-Science-Daten. Gibt AI-Agents Zugriff auf NCBI Gene, UniProt, PubMed und ClinVar — komplett kostenlos ohne API-Key.
+
+## Tools
+
+| Tool | Beschreibung |
+|------|-------------|
+| `search_genes` | Gen-Suche in NCBI Gene Database (Symbol, Name, Funktion) |
+| `get_gene_details` | Detailinfos zu einem Gen via NCBI Gene ID |
+| `search_clinvar_variants` | Klinische Varianten/Mutationen via NCBI ClinVar |
+| `get_taxonomy` | Taxonomische Klassifikation via NCBI Taxonomy |
+| `search_proteins` | Protein-Suche in UniProt |
+| `get_protein_details` | Protein-Details via UniProt Accession |
+| `get_ncbi_sequence` | DNA/Protein-Sequenzen aus NCBI (FASTA/GenBank) |
+| `search_pubmed` | Literatur-Suche in PubMed |
+| `get_pubmed_abstract` | Vollständiger Abstract eines PubMed-Artikels |
+| `get_pubmed_citations` | Artikel die eine Publikation zitieren |
+
+## Installation
+
+```bash
+pip install bioinformatics-mcp-server
+```
+
+## Konfiguration (Claude Desktop)
+
+```json
+{
+  "mcpServers": {
+    "bioinformatics": {
+      "command": "bioinformatics-server"
+    }
+  }
+}
+```
+
+## Beispiele
+
+```
+# Gen-Suche
+search_genes("BRCA1", organism="human")
+search_genes("p53", organism="mouse")
+
+# Klinische Varianten
+search_clinvar_variants("CFTR", significance="pathogenic")
+
+# Protein-Lookup
+search_proteins("insulin receptor", organism="human")
+get_protein_details("P06213")
+
+# DNA-Sequenz abrufen
+get_ncbi_sequence("NM_007294", database="nucleotide")
+
+# Literatur
+search_pubmed("CRISPR gene therapy cancer 2025", max_results=5)
+get_pubmed_abstract("33461210")
+```
+
+## APIs
+
+- **NCBI E-utilities** — Gene, ClinVar, Taxonomy, PubMed, Sequenzen (kostenlos, 3 req/s)
+- **UniProt REST API** — Proteine, Sequenzen, Funktionen (kostenlos, unbegrenzt)
+
+Kein API-Key erforderlich.
+
+## Lizenz
+
+MIT

bioinformatics_mcp_server-0.1.0/README.md

@@ -0,0 +1,69 @@
+# bioinformatics-mcp-server
+
+MCP-Server für Bioinformatik- und Life-Science-Daten. Gibt AI-Agents Zugriff auf NCBI Gene, UniProt, PubMed und ClinVar — komplett kostenlos ohne API-Key.
+
+## Tools
+
+| Tool | Beschreibung |
+|------|-------------|
+| `search_genes` | Gen-Suche in NCBI Gene Database (Symbol, Name, Funktion) |
+| `get_gene_details` | Detailinfos zu einem Gen via NCBI Gene ID |
+| `search_clinvar_variants` | Klinische Varianten/Mutationen via NCBI ClinVar |
+| `get_taxonomy` | Taxonomische Klassifikation via NCBI Taxonomy |
+| `search_proteins` | Protein-Suche in UniProt |
+| `get_protein_details` | Protein-Details via UniProt Accession |
+| `get_ncbi_sequence` | DNA/Protein-Sequenzen aus NCBI (FASTA/GenBank) |
+| `search_pubmed` | Literatur-Suche in PubMed |
+| `get_pubmed_abstract` | Vollständiger Abstract eines PubMed-Artikels |
+| `get_pubmed_citations` | Artikel die eine Publikation zitieren |
+
+## Installation
+
+```bash
+pip install bioinformatics-mcp-server
+```
+
+## Konfiguration (Claude Desktop)
+
+```json
+{
+  "mcpServers": {
+    "bioinformatics": {
+      "command": "bioinformatics-server"
+    }
+  }
+}
+```
+
+## Beispiele
+
+```
+# Gen-Suche
+search_genes("BRCA1", organism="human")
+search_genes("p53", organism="mouse")
+
+# Klinische Varianten
+search_clinvar_variants("CFTR", significance="pathogenic")
+
+# Protein-Lookup
+search_proteins("insulin receptor", organism="human")
+get_protein_details("P06213")
+
+# DNA-Sequenz abrufen
+get_ncbi_sequence("NM_007294", database="nucleotide")
+
+# Literatur
+search_pubmed("CRISPR gene therapy cancer 2025", max_results=5)
+get_pubmed_abstract("33461210")
+```
+
+## APIs
+
+- **NCBI E-utilities** — Gene, ClinVar, Taxonomy, PubMed, Sequenzen (kostenlos, 3 req/s)
+- **UniProt REST API** — Proteine, Sequenzen, Funktionen (kostenlos, unbegrenzt)
+
+Kein API-Key erforderlich.
+
+## Lizenz
+
+MIT

bioinformatics_mcp_server-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "bioinformatics-mcp-server"
+version = "0.1.0"
+description = "MCP-Server für Bioinformatik-Daten — Gene, Proteine, PubMed-Literatur, Varianten und Sequenzen via NCBI & UniProt"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+authors = [{ name = "AiAgentKarl" }]
+keywords = ["mcp", "bioinformatics", "genomics", "ncbi", "uniprot", "pubmed", "genes", "proteins", "ai-agent", "life-science"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "mcp[cli]>=1.0.0",
+    "httpx>=0.27.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AiAgentKarl/bioinformatics-mcp-server"
+Repository = "https://github.com/AiAgentKarl/bioinformatics-mcp-server"
+Issues = "https://github.com/AiAgentKarl/bioinformatics-mcp-server/issues"
+
+[project.scripts]
+bioinformatics-server = "src.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]

bioinformatics_mcp_server-0.1.0/smithery.yaml

@@ -0,0 +1,17 @@
+name: bioinformatics-mcp-server
+description: MCP-Server for bioinformatics data — genes, proteins, PubMed literature, clinical variants and sequences via NCBI & UniProt (free, no API key required)
+license: MIT
+homepage: https://github.com/AiAgentKarl/bioinformatics-mcp-server
+
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    properties: {}
+    required: []
+  commandFunction: |-
+    (config) => ({
+      command: "bioinformatics-server",
+      args: [],
+      env: {}
+    })

bioinformatics_mcp_server-0.1.0/src/server.py

@@ -0,0 +1,45 @@
+"""Bioinformatics MCP Server — Genomik- und Life-Science-Daten für AI-Agents.
+
+Bietet:
+- Gen-Suche und -Details via NCBI Gene Database
+- Protein-Lookup via UniProt REST API
+- Wissenschaftliche Literatur via PubMed (NCBI)
+- Klinische Varianten via NCBI ClinVar
+- DNA/Protein-Sequenzen via NCBI Nucleotide
+- Taxonomie-Lookup via NCBI Taxonomy
+Alle Daten kostenlos, kein API-Key erforderlich.
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+from src.tools.genes import register_gene_tools
+from src.tools.proteins import register_protein_tools
+from src.tools.literature import register_literature_tools
+
+# FastMCP Server erstellen
+mcp = FastMCP(
+    "Bioinformatics MCP Server",
+    instructions=(
+        "Gibt AI-Agents Zugriff auf bioinformatische Datenbanken: "
+        "NCBI Gene (Gen-Suche, Funktion, Orthologe), "
+        "UniProt (Protein-Struktur, Funktion, Sequenzen), "
+        "PubMed (wissenschaftliche Literatur, Abstracts), "
+        "NCBI ClinVar (klinische Varianten, Pathogenität), "
+        "NCBI Taxonomy (Spezies-Klassifikation, Phylogenie). "
+        "Alle Endpunkte kostenlos ohne API-Key via NCBI E-utilities und UniProt REST API."
+    ),
+)
+
+# Tool-Gruppen registrieren
+register_gene_tools(mcp)
+register_protein_tools(mcp)
+register_literature_tools(mcp)
+
+
+def main():
+    """Server starten."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

bioinformatics_mcp_server-0.1.0/src/tools/genes.py

@@ -0,0 +1,272 @@
+"""Gen-Tools — Suche und Details via NCBI Gene Database und ClinVar."""
+
+import httpx
+from typing import Any
+
+
+# NCBI E-utilities Basis-URL
+NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+# Tool- und Email-Parameter für NCBI (höflicher Zugriff)
+NCBI_PARAMS = {"tool": "bioinformatics-mcp-server", "email": "agent@aiagentkarl.com"}
+
+
+async def _ncbi_get(endpoint: str, params: dict) -> dict[str, Any]:
+    """NCBI E-utilities API Anfrage."""
+    try:
+        merged = {**NCBI_PARAMS, **params, "retmode": "json"}
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            response = await client.get(f"{NCBI_BASE}/{endpoint}", params=merged)
+            response.raise_for_status()
+            return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _ncbi_fetch_text(endpoint: str, params: dict) -> str:
+    """NCBI E-utilities API Anfrage mit Text-Rückgabe (für Sequenzen)."""
+    try:
+        merged = {**NCBI_PARAMS, **params}
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            response = await client.get(f"{NCBI_BASE}/{endpoint}", params=merged)
+            response.raise_for_status()
+            return response.text
+    except Exception as e:
+        return f"Fehler: {e}"
+
+
+def register_gene_tools(mcp) -> None:
+    """Registriert alle Gen- und Varianten-Tools."""
+
+    @mcp.tool()
+    async def search_genes(
+        query: str,
+        organism: str = "human",
+        max_results: int = 10,
+    ) -> dict:
+        """Sucht nach Genen in der NCBI Gene Datenbank.
+
+        Args:
+            query: Suchbegriff (z.B. "BRCA1", "TP53", "insulin receptor")
+            organism: Organismus (z.B. "human", "mouse", "rat"). Standard: human
+            max_results: Maximale Ergebnisanzahl (1-20). Standard: 10
+        """
+        max_results = min(max(1, max_results), 20)
+        # Suchanfrage mit Organismus-Filter
+        search_term = f"{query}[Gene Name] AND {organism}[Organism]"
+
+        # Schritt 1: IDs suchen
+        search_data = await _ncbi_get(
+            "esearch.fcgi",
+            {"db": "gene", "term": search_term, "retmax": max_results},
+        )
+        if "error" in search_data:
+            return {"fehler": search_data["error"]}
+
+        ids = search_data.get("esearchresult", {}).get("idlist", [])
+        if not ids:
+            # Breiteren Fallback versuchen
+            search_data = await _ncbi_get(
+                "esearch.fcgi",
+                {"db": "gene", "term": f"{query} AND {organism}[Organism]", "retmax": max_results},
+            )
+            ids = search_data.get("esearchresult", {}).get("idlist", [])
+
+        if not ids:
+            return {"fehler": f"Keine Gene für '{query}' in '{organism}' gefunden"}
+
+        # Schritt 2: Zusammenfassungen abrufen
+        summary_data = await _ncbi_get(
+            "esummary.fcgi",
+            {"db": "gene", "id": ",".join(ids)},
+        )
+        if "error" in summary_data:
+            return {"fehler": summary_data["error"]}
+
+        result_map = summary_data.get("result", {})
+        gene_list = []
+        for gene_id in ids:
+            g = result_map.get(gene_id, {})
+            if not g or gene_id == "uids":
+                continue
+            gene_list.append({
+                "gen_id": gene_id,
+                "name": g.get("name", ""),
+                "vollstaendiger_name": g.get("description", ""),
+                "organismus": g.get("organism", {}).get("scientificname", ""),
+                "chromosom": g.get("chromosome", ""),
+                "position": g.get("maplocation", ""),
+                "zusammenfassung": (g.get("summary") or "")[:400],
+                "ncbi_url": f"https://www.ncbi.nlm.nih.gov/gene/{gene_id}",
+            })
+
+        return {
+            "suchbegriff": query,
+            "organismus": organism,
+            "gefunden": len(gene_list),
+            "gene": gene_list,
+        }
+
+    @mcp.tool()
+    async def get_gene_details(gene_id: str) -> dict:
+        """Ruft detaillierte Informationen zu einem Gen via NCBI Gene ID ab.
+
+        Args:
+            gene_id: NCBI Gene ID (z.B. "672" für BRCA1, "7157" für TP53)
+        """
+        data = await _ncbi_get("esummary.fcgi", {"db": "gene", "id": gene_id})
+        if "error" in data:
+            return {"fehler": data["error"]}
+
+        result = data.get("result", {}).get(gene_id, {})
+        if not result:
+            return {"fehler": f"Gen mit ID '{gene_id}' nicht gefunden"}
+
+        # Verwandte Gene (Gene Neighbors) aus LocationHistList
+        orthologe = []
+        for orth in result.get("orthologs", [])[:5]:
+            orthologe.append({
+                "gen_id": orth.get("geneids", [""])[0],
+                "organismus": orth.get("scientificname", ""),
+            })
+
+        return {
+            "gen_id": gene_id,
+            "symbol": result.get("name", ""),
+            "vollstaendiger_name": result.get("description", ""),
+            "organismus": result.get("organism", {}).get("scientificname", ""),
+            "chromosom": result.get("chromosome", ""),
+            "position": result.get("maplocation", ""),
+            "typ": result.get("genetype", ""),
+            "zusammenfassung": result.get("summary", ""),
+            "aliases": result.get("otheraliases", ""),
+            "andere_bezeichnungen": result.get("otherdesignations", ""),
+            "ncbi_url": f"https://www.ncbi.nlm.nih.gov/gene/{gene_id}",
+        }
+
+    @mcp.tool()
+    async def search_clinvar_variants(
+        gene_symbol: str,
+        significance: str = "pathogenic",
+        max_results: int = 10,
+    ) -> dict:
+        """Sucht klinische Varianten (Mutationen) für ein Gen via NCBI ClinVar.
+
+        Args:
+            gene_symbol: Gen-Symbol (z.B. "BRCA1", "TP53", "CFTR")
+            significance: Klinische Signifikanz — "pathogenic", "benign", "uncertain" oder "all". Standard: pathogenic
+            max_results: Maximale Ergebnisanzahl (1-20). Standard: 10
+        """
+        max_results = min(max(1, max_results), 20)
+
+        # Suchanfrage aufbauen
+        if significance == "all":
+            term = f"{gene_symbol}[gene]"
+        else:
+            sig_map = {
+                "pathogenic": "Pathogenic[ClinSig]",
+                "benign": "Benign[ClinSig]",
+                "uncertain": "Uncertain significance[ClinSig]",
+            }
+            sig_filter = sig_map.get(significance, "Pathogenic[ClinSig]")
+            term = f"{gene_symbol}[gene] AND {sig_filter}"
+
+        # IDs suchen
+        search_data = await _ncbi_get(
+            "esearch.fcgi",
+            {"db": "clinvar", "term": term, "retmax": max_results},
+        )
+        if "error" in search_data:
+            return {"fehler": search_data["error"]}
+
+        ids = search_data.get("esearchresult", {}).get("idlist", [])
+        if not ids:
+            return {
+                "fehler": f"Keine Varianten für '{gene_symbol}' mit Signifikanz '{significance}' gefunden",
+                "tipp": "Versuche significance='all' für alle Varianten",
+            }
+
+        # Zusammenfassungen abrufen
+        summary_data = await _ncbi_get(
+            "esummary.fcgi",
+            {"db": "clinvar", "id": ",".join(ids)},
+        )
+        if "error" in summary_data:
+            return {"fehler": summary_data["error"]}
+
+        result_map = summary_data.get("result", {})
+        varianten = []
+        for var_id in ids:
+            v = result_map.get(var_id, {})
+            if not v or var_id == "uids":
+                continue
+
+            # Signifikanz aus clinical_significance
+            clin_sig = v.get("clinical_significance", {})
+            sig_label = clin_sig.get("description", "")
+
+            varianten.append({
+                "varianten_id": var_id,
+                "name": v.get("title", ""),
+                "gen": gene_symbol,
+                "typ": v.get("obj_type", ""),
+                "klinische_signifikanz": sig_label,
+                "review_status": clin_sig.get("review_status", ""),
+                "bedingung": v.get("trait_set", [{}])[0].get("trait_name", "") if v.get("trait_set") else "",
+                "letzte_bewertung": clin_sig.get("last_evaluated", ""),
+                "clinvar_url": f"https://www.ncbi.nlm.nih.gov/clinvar/variation/{var_id}/",
+            })
+
+        return {
+            "gen": gene_symbol,
+            "signifikanz_filter": significance,
+            "gefunden": len(varianten),
+            "varianten": varianten,
+        }
+
+    @mcp.tool()
+    async def get_taxonomy(
+        taxon: str,
+    ) -> dict:
+        """Ruft taxonomische Klassifikation einer Spezies via NCBI Taxonomy ab.
+
+        Args:
+            taxon: Artname oder Taxonomie-ID (z.B. "Homo sapiens", "9606", "Mus musculus")
+        """
+        # Prüfen ob ID oder Name
+        if taxon.isdigit():
+            tax_id = taxon
+        else:
+            # Name zu ID auflösen
+            search_data = await _ncbi_get(
+                "esearch.fcgi",
+                {"db": "taxonomy", "term": taxon},
+            )
+            if "error" in search_data:
+                return {"fehler": search_data["error"]}
+            ids = search_data.get("esearchresult", {}).get("idlist", [])
+            if not ids:
+                return {"fehler": f"Taxonomie für '{taxon}' nicht gefunden"}
+            tax_id = ids[0]
+
+        # Details abrufen
+        summary_data = await _ncbi_get(
+            "esummary.fcgi",
+            {"db": "taxonomy", "id": tax_id},
+        )
+        if "error" in summary_data:
+            return {"fehler": summary_data["error"]}
+
+        t = summary_data.get("result", {}).get(tax_id, {})
+        if not t:
+            return {"fehler": f"Taxonomie-ID '{tax_id}' nicht gefunden"}
+
+        return {
+            "taxonomie_id": tax_id,
+            "wissenschaftlicher_name": t.get("scientificname", ""),
+            "gemeiner_name": t.get("commonname", ""),
+            "rang": t.get("rank", ""),
+            "abteilung": t.get("division", ""),
+            "genetischer_code": t.get("gencodeId", ""),
+            "mitochondrialer_code": t.get("mgcodeId", ""),
+            "ncbi_url": f"https://www.ncbi.nlm.nih.gov/Taxonomy/Browser/wwwtax.cgi?id={tax_id}",
+        }

bioinformatics_mcp_server-0.1.0/src/tools/literature.py

@@ -0,0 +1,223 @@
+"""Literatur-Tools — Wissenschaftliche Artikel via PubMed (NCBI E-utilities)."""
+
+import httpx
+from typing import Any
+
+
+# NCBI E-utilities Basis-URL
+NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+NCBI_PARAMS = {"tool": "bioinformatics-mcp-server", "email": "agent@aiagentkarl.com"}
+
+
+async def _ncbi_get(endpoint: str, params: dict) -> dict[str, Any]:
+    """NCBI E-utilities API Anfrage."""
+    try:
+        merged = {**NCBI_PARAMS, **params, "retmode": "json"}
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            response = await client.get(f"{NCBI_BASE}/{endpoint}", params=merged)
+            response.raise_for_status()
+            return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def register_literature_tools(mcp) -> None:
+    """Registriert alle Literatur-Tools."""
+
+    @mcp.tool()
+    async def search_pubmed(
+        query: str,
+        max_results: int = 10,
+        sort: str = "relevance",
+        years_back: int = 0,
+    ) -> dict:
+        """Sucht wissenschaftliche Artikel in PubMed.
+
+        Args:
+            query: Suchbegriff (z.B. "BRCA1 breast cancer therapy", "CRISPR gene editing")
+            max_results: Maximale Ergebnisanzahl (1-20). Standard: 10
+            sort: Sortierung — "relevance" oder "date". Standard: relevance
+            years_back: Nur Artikel der letzten N Jahre (0 = alle). Standard: 0
+        """
+        max_results = min(max(1, max_results), 20)
+
+        # Datumsfilter
+        search_term = query
+        if years_back > 0:
+            from datetime import datetime
+            aktuelles_jahr = datetime.now().year
+            von_jahr = aktuelles_jahr - years_back
+            search_term = f"{query} AND ({von_jahr}:{aktuelles_jahr}[pdat])"
+
+        sort_param = "relevance" if sort == "relevance" else "pub+date"
+
+        # Schritt 1: Artikel-IDs suchen
+        search_data = await _ncbi_get(
+            "esearch.fcgi",
+            {
+                "db": "pubmed",
+                "term": search_term,
+                "retmax": max_results,
+                "sort": sort_param,
+                "usehistory": "y",
+            },
+        )
+        if "error" in search_data:
+            return {"fehler": search_data["error"]}
+
+        ids = search_data.get("esearchresult", {}).get("idlist", [])
+        count = search_data.get("esearchresult", {}).get("count", "0")
+
+        if not ids:
+            return {
+                "fehler": f"Keine Artikel für '{query}' in PubMed gefunden",
+                "tipp": "Versuche weniger spezifische Suchbegriffe oder Englisch",
+            }
+
+        # Schritt 2: Zusammenfassungen abrufen
+        summary_data = await _ncbi_get(
+            "esummary.fcgi",
+            {"db": "pubmed", "id": ",".join(ids)},
+        )
+        if "error" in summary_data:
+            return {"fehler": summary_data["error"]}
+
+        result_map = summary_data.get("result", {})
+        artikel = []
+
+        for pmid in ids:
+            a = result_map.get(pmid, {})
+            if not a or pmid == "uids":
+                continue
+
+            # Autoren extrahieren
+            autoren = []
+            for author in a.get("authors", [])[:5]:
+                autoren.append(author.get("name", ""))
+
+            artikel.append({
+                "pmid": pmid,
+                "titel": a.get("title", ""),
+                "autoren": autoren,
+                "journal": a.get("fulljournalname", a.get("source", "")),
+                "erscheinungsjahr": a.get("pubdate", "")[:4],
+                "doi": a.get("elocationid", ""),
+                "abstract_url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
+            })
+
+        return {
+            "suchbegriff": query,
+            "gesamt_treffer": int(count),
+            "angezeigt": len(artikel),
+            "sortierung": sort,
+            "artikel": artikel,
+        }
+
+    @mcp.tool()
+    async def get_pubmed_abstract(pmid: str) -> dict:
+        """Ruft den vollständigen Abstract eines PubMed-Artikels ab.
+
+        Args:
+            pmid: PubMed ID (z.B. "33461210", "36257307")
+        """
+        # Abstract via efetch abrufen
+        try:
+            merged = {**NCBI_PARAMS, "db": "pubmed", "id": pmid, "rettype": "abstract", "retmode": "text"}
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                response = await client.get(f"{NCBI_BASE}/efetch.fcgi", params=merged)
+                response.raise_for_status()
+                abstract_text = response.text
+        except Exception as e:
+            return {"fehler": str(e)}
+
+        # Zusätzliche Metadaten
+        summary_data = await _ncbi_get("esummary.fcgi", {"db": "pubmed", "id": pmid})
+        meta = summary_data.get("result", {}).get(pmid, {})
+
+        autoren = []
+        for author in meta.get("authors", []):
+            autoren.append(author.get("name", ""))
+
+        return {
+            "pmid": pmid,
+            "titel": meta.get("title", ""),
+            "autoren": autoren,
+            "journal": meta.get("fulljournalname", meta.get("source", "")),
+            "erscheinungsdatum": meta.get("pubdate", ""),
+            "doi": meta.get("elocationid", ""),
+            "abstract": abstract_text.strip(),
+            "pubmed_url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
+        }
+
+    @mcp.tool()
+    async def get_pubmed_citations(
+        pmid: str,
+        max_results: int = 10,
+    ) -> dict:
+        """Ruft Artikel ab, die einen bestimmten PubMed-Artikel zitieren.
+
+        Args:
+            pmid: PubMed ID des zitierten Artikels (z.B. "33461210")
+            max_results: Maximale Ergebnisanzahl (1-20). Standard: 10
+        """
+        max_results = min(max(1, max_results), 20)
+
+        # elink: Artikel finden die diesen zitieren
+        try:
+            params = {
+                **NCBI_PARAMS,
+                "dbfrom": "pubmed",
+                "db": "pubmed",
+                "id": pmid,
+                "linkname": "pubmed_pubmed_citedin",
+                "retmode": "json",
+            }
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                response = await client.get(f"{NCBI_BASE}/elink.fcgi", params=params)
+                response.raise_for_status()
+                link_data = response.json()
+        except Exception as e:
+            return {"fehler": str(e)}
+
+        # IDs aus linksets extrahieren
+        citing_ids = []
+        for linkset in link_data.get("linksets", []):
+            for lsd in linkset.get("linksetdbs", []):
+                if lsd.get("linkname") == "pubmed_pubmed_citedin":
+                    citing_ids = lsd.get("links", [])[:max_results]
+                    break
+
+        if not citing_ids:
+            return {
+                "pmid": pmid,
+                "zitiert_von": 0,
+                "artikel": [],
+                "hinweis": "Keine Zitationen in PubMed gefunden (nur indexierte Artikel werden erfasst)",
+            }
+
+        # Zusammenfassungen der zitierenden Artikel
+        id_str = ",".join(str(i) for i in citing_ids)
+        summary_data = await _ncbi_get("esummary.fcgi", {"db": "pubmed", "id": id_str})
+        result_map = summary_data.get("result", {})
+
+        artikel = []
+        for cid in citing_ids:
+            cid_str = str(cid)
+            a = result_map.get(cid_str, {})
+            if not a or cid_str == "uids":
+                continue
+            autoren = [auth.get("name", "") for auth in a.get("authors", [])[:3]]
+            artikel.append({
+                "pmid": cid_str,
+                "titel": a.get("title", ""),
+                "autoren": autoren,
+                "journal": a.get("fulljournalname", a.get("source", "")),
+                "erscheinungsjahr": a.get("pubdate", "")[:4],
+                "url": f"https://pubmed.ncbi.nlm.nih.gov/{cid_str}/",
+            })
+
+        return {
+            "original_pmid": pmid,
+            "gefundene_zitationen": len(artikel),
+            "artikel": artikel,
+        }

bioinformatics_mcp_server-0.1.0/src/tools/proteins.py

@@ -0,0 +1,242 @@
+"""Protein-Tools — Lookup und Sequenzen via UniProt REST API."""
+
+import httpx
+from typing import Any
+
+
+# UniProt REST API Basis-URL
+UNIPROT_BASE = "https://rest.uniprot.org/uniprotkb"
+# NCBI E-utilities für Sequenzen
+NCBI_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+NCBI_PARAMS = {"tool": "bioinformatics-mcp-server", "email": "agent@aiagentkarl.com"}
+
+
+async def _uniprot_get(endpoint: str, params: dict = None) -> dict[str, Any]:
+    """UniProt REST API Anfrage."""
+    try:
+        async with httpx.AsyncClient(
+            timeout=20.0,
+            headers={"Accept": "application/json"},
+        ) as client:
+            response = await client.get(
+                f"{UNIPROT_BASE}/{endpoint}",
+                params=params or {},
+            )
+            response.raise_for_status()
+            return response.json()
+    except Exception as e:
+        return {"error": str(e)}
+
+
+async def _ncbi_fetch_text(endpoint: str, params: dict) -> str:
+    """NCBI E-utilities Text-Anfrage für Sequenzen."""
+    try:
+        merged = {**NCBI_PARAMS, **params}
+        async with httpx.AsyncClient(timeout=20.0) as client:
+            response = await client.get(f"{NCBI_BASE}/{endpoint}", params=merged)
+            response.raise_for_status()
+            return response.text
+    except Exception as e:
+        return f"Fehler: {e}"
+
+
+def register_protein_tools(mcp) -> None:
+    """Registriert alle Protein-Tools."""
+
+    @mcp.tool()
+    async def search_proteins(
+        query: str,
+        organism: str = "human",
+        max_results: int = 10,
+    ) -> dict:
+        """Sucht nach Proteinen in der UniProt-Datenbank.
+
+        Args:
+            query: Suchbegriff (z.B. "BRCA1", "insulin receptor", "p53 tumor suppressor")
+            organism: Organismus (z.B. "human", "mouse", "E. coli"). Standard: human
+            max_results: Maximale Ergebnisanzahl (1-25). Standard: 10
+        """
+        max_results = min(max(1, max_results), 25)
+
+        # UniProt Suchanfrage
+        search_query = f"({query}) AND (organism_name:{organism})"
+        data = await _uniprot_get(
+            "search",
+            {
+                "query": search_query,
+                "size": max_results,
+                "fields": "accession,id,protein_name,gene_names,organism_name,length,reviewed,function",
+            },
+        )
+        if "error" in data:
+            return {"fehler": data["error"]}
+
+        results = data.get("results", [])
+        if not results:
+            return {"fehler": f"Keine Proteine für '{query}' in '{organism}' gefunden"}
+
+        proteine = []
+        for p in results:
+            # Proteinname extrahieren
+            prot_names = p.get("proteinDescription", {})
+            rec_name = prot_names.get("recommendedName", {})
+            full_name = rec_name.get("fullName", {}).get("value", "")
+            if not full_name:
+                sub_names = prot_names.get("submittedNames", [])
+                if sub_names:
+                    full_name = sub_names[0].get("fullName", {}).get("value", "")
+
+            # Gen-Namen
+            gene_names = []
+            for gn in p.get("genes", []):
+                gn_val = gn.get("geneName", {}).get("value", "")
+                if gn_val:
+                    gene_names.append(gn_val)
+
+            # Funktion (erstes Kommentar)
+            funktion = ""
+            for kommentar in p.get("comments", []):
+                if kommentar.get("commentType") == "FUNCTION":
+                    texts = kommentar.get("texts", [])
+                    if texts:
+                        funktion = texts[0].get("value", "")[:300]
+                        break
+
+            proteine.append({
+                "accession": p.get("primaryAccession", ""),
+                "entry_name": p.get("uniProtkbId", ""),
+                "protein_name": full_name,
+                "gene_namen": gene_names,
+                "organismus": p.get("organism", {}).get("scientificName", ""),
+                "laenge": p.get("sequence", {}).get("length", 0),
+                "reviewed": p.get("entryType", "") == "UniProtKB reviewed (Swiss-Prot)",
+                "funktion": funktion,
+                "uniprot_url": f"https://www.uniprot.org/uniprotkb/{p.get('primaryAccession', '')}",
+            })
+
+        return {
+            "suchbegriff": query,
+            "organismus": organism,
+            "gefunden": len(proteine),
+            "proteine": proteine,
+        }
+
+    @mcp.tool()
+    async def get_protein_details(accession: str) -> dict:
+        """Ruft detaillierte Informationen zu einem Protein via UniProt Accession ab.
+
+        Args:
+            accession: UniProt Accession-Nummer (z.B. "P38398" für BRCA1, "P04637" für TP53)
+        """
+        data = await _uniprot_get(accession)
+        if "error" in data:
+            return {"fehler": data["error"]}
+
+        # Protein-Name
+        prot_names = data.get("proteinDescription", {})
+        rec_name = prot_names.get("recommendedName", {})
+        full_name = rec_name.get("fullName", {}).get("value", "")
+        kurz_name = rec_name.get("shortNames", [{}])[0].get("value", "") if rec_name.get("shortNames") else ""
+
+        # Gen-Namen
+        gene_namen = []
+        for gn in data.get("genes", []):
+            gn_val = gn.get("geneName", {}).get("value", "")
+            if gn_val:
+                gene_namen.append(gn_val)
+
+        # Funktion
+        funktion = ""
+        subunit = ""
+        for kommentar in data.get("comments", []):
+            ct = kommentar.get("commentType", "")
+            texts = kommentar.get("texts", [])
+            if ct == "FUNCTION" and texts and not funktion:
+                funktion = texts[0].get("value", "")[:500]
+            elif ct == "SUBUNIT" and texts and not subunit:
+                subunit = texts[0].get("value", "")[:300]
+
+        # Keywords
+        keywords = [kw.get("name", "") for kw in data.get("keywords", [])[:10]]
+
+        # Sequenz-Info
+        seq = data.get("sequence", {})
+
+        return {
+            "accession": accession,
+            "entry_name": data.get("uniProtkbId", ""),
+            "protein_name": full_name,
+            "kurzname": kurz_name,
+            "gene_namen": gene_namen,
+            "organismus": data.get("organism", {}).get("scientificName", ""),
+            "taxonomie_id": data.get("organism", {}).get("taxonId", ""),
+            "laenge_aminosaeuren": seq.get("length", 0),
+            "molekulargewicht": seq.get("molWeight", 0),
+            "funktion": funktion,
+            "untereinheit": subunit,
+            "keywords": keywords,
+            "reviewed": data.get("entryType", "") == "UniProtKB reviewed (Swiss-Prot)",
+            "sequenz": (seq.get("value", "") or "")[:200] + ("..." if len(seq.get("value", "") or "") > 200 else ""),
+            "uniprot_url": f"https://www.uniprot.org/uniprotkb/{accession}",
+        }
+
+    @mcp.tool()
+    async def get_ncbi_sequence(
+        accession: str,
+        database: str = "nucleotide",
+        sequence_type: str = "fasta",
+    ) -> dict:
+        """Ruft eine DNA- oder Protein-Sequenz aus NCBI ab.
+
+        Args:
+            accession: NCBI Accession-Nummer (z.B. "NM_007294" für BRCA1 mRNA, "NP_009225" für BRCA1 Protein)
+            database: Datenbank — "nucleotide" (DNA/RNA) oder "protein". Standard: nucleotide
+            sequence_type: Format — "fasta" (Sequenz) oder "gb" (GenBank-Eintrag). Standard: fasta
+        """
+        valid_dbs = ("nucleotide", "protein")
+        if database not in valid_dbs:
+            return {"fehler": f"Ungültige Datenbank. Erlaubt: {', '.join(valid_dbs)}"}
+
+        valid_types = ("fasta", "gb")
+        if sequence_type not in valid_types:
+            return {"fehler": f"Ungültiger Sequenztyp. Erlaubt: {', '.join(valid_types)}"}
+
+        # Zuerst ID suchen
+        params = {**NCBI_PARAMS, "retmode": "json"}
+        try:
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                search_resp = await client.get(
+                    f"{NCBI_BASE}/esearch.fcgi",
+                    params={**params, "db": database, "term": accession},
+                )
+                search_resp.raise_for_status()
+                search_data = search_resp.json()
+        except Exception as e:
+            return {"fehler": str(e)}
+
+        ids = search_data.get("esearchresult", {}).get("idlist", [])
+        if not ids:
+            return {"fehler": f"Sequenz '{accession}' in '{database}' nicht gefunden"}
+
+        # Sequenz abrufen
+        ret_type = "fasta" if sequence_type == "fasta" else "gb"
+        sequenz = await _ncbi_fetch_text(
+            "efetch.fcgi",
+            {"db": database, "id": ids[0], "rettype": ret_type, "retmode": "text"},
+        )
+
+        # FASTA kürzen für Ausgabe
+        zeilen = sequenz.strip().split("\n")
+        header = zeilen[0] if zeilen else ""
+        seq_daten = "".join(zeilen[1:]) if len(zeilen) > 1 else ""
+
+        return {
+            "accession": accession,
+            "datenbank": database,
+            "format": sequence_type,
+            "ncbi_id": ids[0],
+            "header": header,
+            "sequenz_laenge": len(seq_daten),
+            "sequenz_vorschau": seq_daten[:300] + ("..." if len(seq_daten) > 300 else ""),
+            "vollstaendige_sequenz": seq_daten if len(seq_daten) <= 2000 else seq_daten[:2000] + f"... [{len(seq_daten) - 2000} weitere Zeichen]",
+        }