Mutation Clinical Trial Matching MCP

Mutation Klinische Studie Matching MCP

Ein Model Context Protocol (MCP)-Server, der es Claude Desktop ermöglicht, basierend auf Mutationen nach Übereinstimmungen in clincialtrials.gov zu suchen.

Status

Dies ist derzeit die erste Entwicklungsphase. Sie dient dazu, Versuche basierend auf den in der Claude-Abfrage angegebenen Mutationen abzurufen. Es gibt jedoch noch Fehler und weitere Verbesserungen und Ergänzungen, die implementiert werden müssen.

Überblick

Dieses Projekt folgt den Prinzipien des Agentic Coding und erstellt ein System, das Claude Desktop mit der API von clinicaltrials.gov integriert. Der Server ermöglicht natürlichsprachliche Abfragen zu genetischen Mutationen und liefert zusammengefasste Informationen zu relevanten klinischen Studien.

Jeder Knoten im Flow folgt dem PocketFlow-Knotenmuster mit den Methoden prep , exec und post :

Projektstruktur

Dieses Projekt ist nach dem Agentic Coding-Paradigma organisiert:

1. Anforderungen (vom Menschen geleitet):
   • Suchen und fassen Sie klinische Studien zu bestimmten genetischen Mutationen zusammen
   • Bereitstellung von Mutationsinformationen als kontextbezogene Ressourcen
   • Nahtlose Integration mit Claude Desktop
2. Flow-Design (kollaborativ):
   • Benutzer fragt Claude Desktop nach einer genetischen Mutation
   • Claude nennt unser MCP-Server-Tool
   • Server fragt clinicaltrials.gov API ab
   • Server verarbeitet und fasst die Ergebnisse zusammen
   • Der Server gibt formatierte Ergebnisse an Claude zurück
3. Dienstprogramme (kollaborativ):
   • clinicaltrials/query.py : Verarbeitet API-Aufrufe an clinicaltrials.gov
   • utils/call_llm.py : Dienstprogramme für die Arbeit mit Claude
4. Knotendesign (KI-gesteuert):
   • utils/node.py : Implementiert Basisklassen von Node und BatchNode mit dem Muster prep/exec/post
   • clinicaltrials/nodes.py : Definiert spezialisierte Knoten für Abfragen und Zusammenfassungen
   • clinicaltrials_mcp_server.py : Orchestriert die Flow-Ausführung
5. Implementierung (KI-geführt):
   • FastMCP SDK zur Handhabung der Protokolldetails
   • Fehlerbehandlung auf allen Ebenen
   • Ressourcen für häufige Mutationen

Komponenten

MCP-Server ( clinicaltrials_mcp_server.py )

Der Hauptserver, der die Model Context Protocol-Schnittstelle mithilfe des offiziellen Python SDK implementiert. Er:

• Registriert und stellt Werkzeuge für Claude bereit
• Bietet Ressourcen mit Informationen zu häufigen Mutationen
• Verwaltet die Kommunikation mit Claude Desktop

Abfragemodul ( clinicaltrials/query.py )

Verantwortlich für die Abfrage der clinicaltrials.gov-API mit:

• Robuste Fehlerbehandlung
• Eingabevalidierung
• Detaillierte Protokollierung

Zusammenfasser ( llm/summarize.py )

Verarbeitet und formatiert die Daten klinischer Studien:

• Organisiert Versuche nach Phasen
• Extrahiert wichtige Informationen (NCT-ID, Zusammenfassung, Bedingungen usw.)
• Erstellt eine lesbare Markdown-Zusammenfassung

Knotenmusterimplementierung

Dieses Projekt implementiert das PocketFlow-Knotenmuster, das einen modularen, wartbaren Ansatz zum Erstellen von KI-Workflows bietet:

Kernknotenklassen ( utils/node.py )

• Node : Basisklasse mit den Methoden prep , exec und post zur Datenverarbeitung
• BatchNode : Erweiterung für die Stapelverarbeitung mehrerer Elemente
• Flow : Orchestriert die Ausführung von Knoten in der richtigen Reihenfolge

Implementierungsknoten ( clinicaltrials/nodes.py )

1. QueryTrialsNode :
   # Queries clinicaltrials.gov API def prep(self, shared): return shared["mutation"] def exec(self, mutation): return query_clinical_trials(mutation) def post(self, shared, mutation, result): shared["trials_data"] = result shared["studies"] = result.get("studies", []) return "summarize"
2. SummarizeTrialsNode :
   # Formats trial data into readable summaries def prep(self, shared): return shared["studies"] def exec(self, studies): return format_trial_summary(studies) def post(self, shared, studies, summary): shared["summary"] = summary return None # End of flow

Flow-Ausführung

Der MCP-Server erstellt und führt den Flow aus:

Dieses Muster trennt Vorbereitung, Ausführung und Nachbearbeitung und macht den Code dadurch wartungs- und testfreundlicher. Weitere Details finden Sie im Designdokument .

Verwendung

1. Installieren Sie Abhängigkeiten mit uv:
   uv pip install -r requirements.txt
2. Claude Desktop konfigurieren:
   • Die Konfiguration unter ~/Library/Application Support/Claude/claude_desktop_config.json sollte bereits eingerichtet sein
3. Starten Sie Claude Desktop und stellen Sie Fragen wie:
   • „Welche klinischen Studien gibt es für EGFR L858R-Mutationen?“
   • „Gibt es Studien zu BRAF-V600E-Mutationen?“
   • „Erzählen Sie mir von Versuchen zur ALK-Umlagerung.“
4. Nutzen Sie Ressourcen, indem Sie fragen:
   • „Können Sie mir mehr über die KRAS G12C-Mutation erzählen?“

Integration mit Claude Desktop

Sie können dieses Projekt als Claude Desktop MCP-Tool konfigurieren. Verwenden Sie in Ihrer Konfiguration Pfadplatzhalter und ersetzen Sie diese durch Ihre tatsächlichen Pfade:

Pfadvariablen:

• {PATH_TO_VENV} : Vollständiger Pfad zu Ihrem virtuellen Umgebungsverzeichnis.
• {PATH_TO_PROJECT} : Vollständiger Pfad zum Verzeichnis, das Ihre Projektdateien enthält.

Installationsanweisungen:

1. Klonen Sie das Repository auf Ihren lokalen Computer.
2. Installieren Sie uv, falls Sie es noch nicht haben:
   curl -LsSf https://astral.sh/uv/install.sh | sh # macOS/Linux # or iwr -useb https://astral.sh/uv/install.ps1 | iex # Windows PowerShell
3. Erstellen Sie eine virtuelle Umgebung und installieren Sie Abhängigkeiten in einem Schritt:
   uv venv .venv uv pip install -r requirements.txt
4. Aktivieren Sie die virtuelle Umgebung bei Bedarf:
   source .venv/bin/activate # macOS/Linux .venv\Scripts\activate # Windows
5. Bestimmen Sie den vollständigen Pfad zu Ihrer virtuellen Umgebung und Ihrem Projektverzeichnis.
6. Aktualisieren Sie Ihre Konfiguration mit diesen spezifischen Pfaden.

Beispiele:

• Unter macOS/Linux:
  "command": "/Users/username/projects/mutation_trial_matcher/.venv/bin/python"
• Unter Windows:
  "command": "C:\\Users\\username\\projects\\mutation_trial_matcher\\.venv\\Scripts\\python.exe"

Tipps zur Pfadfindung:

• Um den genauen Pfad zu Ihrem Python-Interpreter in der virtuellen Umgebung zu finden, führen Sie Folgendes aus:
  • which python (macOS/Linux)
  • where python (Windows, nach Aktivierung des Venv)
• Verwenden Sie als Projektpfad den vollständigen Pfad zum Verzeichnis, clinicaltrials_mcp_server.py enthält.

Zukünftige Verbesserungen

Eine umfassende Liste der geplanten Verbesserungen und zukünftigen Arbeiten finden Sie im Dokument future_work.md .

Abhängigkeiten

Dieses Projekt basiert auf den folgenden wichtigen Abhängigkeiten:

• Python 3.7+ – Basislaufzeitumgebung
• PocketFlow ( pocketflow>=0.0.1 ) – Framework zum Erstellen modularer KI-Workflows mit dem Node-Muster
• MCP SDK ( mcp[cli]>=1.0.0 ) – Offizielles Model Context Protocol SDK zum Erstellen von Claude Desktop-Tools
• Anfragen ( requests==2.31.0 ) – HTTP-Bibliothek zum Tätigen von API-Aufrufen an clinicaltrials.gov
• Python-dotenv ( python-dotenv==1.1.0 ) – Zum Laden von Umgebungsvariablen aus .env-Dateien

Alle Abhängigkeiten können mit UV installiert werden, wie in der Installationsanleitung beschrieben.

Fehlerbehebung

Wenn Claude Desktop die Verbindung zum MCP-Server trennt:

• Überprüfen Sie die Protokolle unter: ~/Library/Logs/Claude/mcp-server-clinicaltrials-mcp.log
• Starten Sie Claude Desktop neu
• Überprüfen Sie, ob der Server ordnungsgemäß ausgeführt wird

Entwicklungsprozess

Dieses Projekt wurde mit einem KI-gestützten Programmieransatz entwickelt und folgt den Prinzipien des Agentic Coding, bei dem Menschen entwerfen und KI-Agenten implementieren. Das ursprüngliche Programm wurde am 30.04.2025 auf Main erstellt. Die Implementierung erfolgte durch Paarprogrammierung mit:

• Windsurf
  • ChatGPT 4.1
  • Claude 3.7 Sonett

Diese KI-Assistenten waren maßgeblich daran beteiligt, Designanforderungen auf hoher Ebene in funktionalen Code zu übersetzen, bei der API-Integration zu helfen und das Projekt gemäß Best Practices zu strukturieren.

Umgang mit der Zeichenbeschränkung .windsurfrules

Die PocketFlow-Datei .windsurfrules aus dem Vorlagen-Repository enthält umfassende Projektregeln. Windsurf setzt jedoch eine Begrenzung von 6.000 Zeichen für Regeldateien voraus. Das bedeutet, dass Sie nicht alle Richtlinien direkt in Ihr Projekt integrieren können und wichtige Regeln möglicherweise weggelassen oder abgeschnitten werden.

Um dieses Problem zu beheben, werden zwei Lösungen empfohlen:

1. Verwenden des Windsurf-Speichers zum Speichern von Regeln

Sie können die Speicherfunktion von Windsurf nutzen, um den gesamten Satz an PocketFlow-Regeln zu speichern, selbst wenn diese das Dateilimit von .windsurfrules überschreiten. So können Sie alle Projektkonventionen und Best Practices im Dialog mit Windsurf berücksichtigen und sicherstellen, dass durch Kürzungen nichts verloren geht. Eine Schritt-für-Schritt-Anleitung und einen detaillierten Vergleich von Speicher- und Regeldateien finden Sie unter docs/memory_vs_windsurfrules.md .

2. Verwenden von Context7 zum Zugriff auf Richtlinien

Wichtiger Hinweis : Dieses Projekt basiert auf dem PocketFlow-Template-Python- Repository, das eine umfassende .windsurfrules Datei enthält. Windsurf hat jedoch eine Begrenzung von 6.000 Zeichen für Regeldateien, sodass die vollständigen PocketFlow-Richtlinien nicht vollständig in den Speicher von Windsurf geladen werden können.

Um diese Einschränkung zu beheben, haben wir detaillierte Anweisungen zur Verwendung des Context7 MCP-Servers für den Zugriff auf PocketFlow-Richtlinien während der Entwicklung erstellt. Dieser Ansatz ermöglicht es Ihnen, die volle Leistungsfähigkeit der Designmuster und Best Practices von PocketFlow zu nutzen, ohne durch die Zeichenbeschränkung eingeschränkt zu sein.

Ausführliche Anweisungen zur Verwendung von Context7 mit PocketFlow finden Sie in unserem Context7-Handbuch . Dieses Handbuch enthält:

• Schritt-für-Schritt-Anleitung zur Konfiguration von Context7 MCP in Windsurf
• Eingabeaufforderungen in natürlicher Sprache für den Zugriff auf die PocketFlow-Dokumentation
• Beispiele für das Abrufen spezifischer Implementierungsmuster
• So speichern Sie wichtige Muster als Erinnerung für spätere Verwendung

Wenn Sie dieser Anleitung folgen, können Sie bei der Entwicklung und Erweiterung dieses Projekts die Übereinstimmung mit den Agentic Coding-Prinzipien von PocketFlow wahren.

Danksagung

Dieses Projekt wurde auf Grundlage des PocketFlow-Template-Python erstellt. Besonderer Dank gilt den ursprünglichen Projektbeteiligten für die Bereitstellung der Grundlage und Struktur, die diese Implementierung ermöglicht hat.

Das Projekt folgt der Agentic-Coding-Methodik, wie sie in der Originalvorlage beschrieben ist.

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE .

⚠️ Haftungsausschluss

Dieses Projekt ist ein Prototyp und dient ausschließlich Forschungs- und Demonstrationszwecken. Es sollte nicht zur medizinischen Entscheidungsfindung oder als Ersatz für professionelle medizinische Beratung, Diagnose oder Behandlung verwendet werden. Aufgrund der Einschränkungen großer Sprachmodelle (LLMs) können die von diesem Tool bereitgestellten Informationen unvollständig, ungenau oder veraltet sein. Nutzer sollten Vorsicht walten lassen und qualifiziertes medizinisches Fachpersonal konsultieren, bevor sie Entscheidungen auf Grundlage der Ergebnisse dieses Systems treffen.