LangGraph RAG MCP

Ein Retrieval-Augmented-Generation-System (RAG), das LangGraph-Dokumentation über das Model Context Protocol (MCP) bereitstellt.

Übersicht

Dieses Projekt erstellt ein Dokumentations-Retrieval-System, das:

1. Sammelt und verarbeitet LangGraph-Dokumentation von der offiziellen Website

2. Erstellt eine Vektordatenbank aus dieser Dokumentation für die semantische Suche

3. Stellt dieses Wissen über das Model Context Protocol (MCP) bereit

4. Integriert sich mit MCP-kompatiblen Hosts wie VS Code, Cursor, Claude Desktop oder Windsurf

Related MCP server: AI Research Assistant MCP Server

So funktioniert es

1. Sammlung und Verarbeitung der Dokumentation (Kontext)

• Sammelt und bereinigt rekursiv LangGraph-Dokumentation von mehreren Website-URLs mithilfe von RecursiveUrlLoader und BeautifulSoup.

• Teilt den Text mithilfe von RecursiveCharacterTextSplitter und tiktoken für eine genaue Tokenzählung in überschaubare Abschnitte.

• Bettet Abschnitte mithilfe der BAAI/bge-large-en-v1.5-Embeddings in Vektordarstellungen ein.

• Speichert Vektoren in einem SKLearnVectorStore für ein effizientes Retrieval.

2. Retrieval-System (Tool)

• Implementiert eine Retrieval-Funktion, die für eine Abfrage die relevantesten Dokumentationsabschnitte findet.

• Integriert diese Funktion in Sprachmodelle wie Claude, um kontextbezogene Antworten zu liefern.

• Gibt formatierte Antworten zurück, die Quellenangabe und relevanten Kontext enthalten.

3. MCP-Server-Integration

• Kapselt das Retrieval-Tool in einem MCP-Server mithilfe der Bibliothek fastmcp.

• Stellt die Retrieval-Funktion als Tool bereit, das MCP-kompatible Hosts verwenden können.

• Bietet Zugriff auf das Retrieval-System und zusätzliche Ressourcen (wie die vollständige Dokumentationsdatei).

Voraussetzungen

• Python 3.10+

• Docker und Docker Compose (empfohlen)

• Anthropic-API-Schlüssel (für Claude-Modelle)

Installation und Einrichtung

Sie können dieses Projekt entweder mit Docker (empfohlen) oder in einer lokalen Python-Umgebung ausführen.

Mit Docker (empfohlen)

1. Klonen Sie dieses Repository:

   git clone https://github.com/yourusername/langraph-rag-mcp.git
   cd langraph-rag-mcp

2. Richten Sie Ihre API-Schlüssel in einer .env-Datei ein: Erstellen Sie eine .env-Datei im Projektstammverzeichnis und fügen Sie Ihren Anthropic-API-Schlüssel hinzu:

   echo "ANTHROPIC_API_KEY=your_api_key_here" > .env

   Die docker-compose.yml-Datei lädt diese Umgebungsvariable automatisch.

Lokale Umgebung (ohne Docker)

1. Klonen Sie dieses Repository:

   git clone https://github.com/yourusername/langraph-rag-mcp.git
   cd langraph-rag-mcp

2. Erstellen und aktivieren Sie eine virtuelle Umgebung:

   conda create -n mcp python=3.13
   conda activate mcp

3. Installieren Sie die erforderlichen Pakete:

   pip install -r requirements.txt

4. Richten Sie Ihre API-Schlüssel in einer .env-Datei ein:

   echo "ANTHROPIC_API_KEY=your_api_key_here" > .env

Verwendung

Der Ablauf besteht aus zwei Hauptschritten: Zuerst wird der Vektor-Store generiert, danach wird der MCP-Server ausgeführt.

Schritt 1: Vektor-Store generieren

Sie müssen dies nur einmal durchführen oder immer dann, wenn Sie die Dokumentation aktualisieren möchten.

1. Öffnen und führen Sie das Notebook rag-tool.ipynb in einer Jupyter-Umgebung aus.

2. Dabei wird Folgendes durchgeführt:

   • Die neueste LangGraph-Dokumentation wird heruntergeladen.

   • Die vollständige Dokumentation wird in llms_full.txt gespeichert.

   • Die Dokumente werden in Abschnitte aufgeteilt.

   • Ein Vektor-Store wird unter sklearn_vectorstore.parquet erstellt und dauerhaft gespeichert.

Schritt 2: MCP-Server ausführen

Mit Docker

Der einfachste Weg, den Server auszuführen, ist das mitgelieferte Shell-Skript, das Docker Compose kapselt.

bash run-mcp-docker.sh

Dieses Skript erstellt das Docker-Image, falls es nicht existiert, startet den Container und führt anschließend den MCP-Server darin aus. Dabei verarbeitet es die Standard-I/O für die MCP-Kommunikation korrekt.

Ohne Docker

Wenn Sie Docker nicht verwenden, können Sie den MCP-Server direkt im Dev-Modus über den folgenden Befehl ausführen:

mcp dev langgraph-mcp.py

MCP-Hosts konfigurieren

Um diesen MCP-Server mit einem kompatiblen Editor zu verwenden, müssen Sie ihn konfigurieren.

VS Code

1. Öffnen Sie die Datei settings.json in VS Code. (Sie finden sie über die Befehlspalette: Preferences: Open User Settings (JSON)).

2. Fügen Sie die folgende Konfiguration in die Datei ein. Ersetzen Sie <path-to-your-project> durch den absoluten Pfad zum Verzeichnis langraph-rag-mcp auf Ihrem Rechner.

   "mcp.servers": [
       {
           "name": "langgraph-mcp",
           "command": [
               "/bin/bash",
               "<path-to-your-project>/run-mcp-docker.sh"
           ],
           "env": {
               "ANTHROPIC_API_KEY": "<your-anthropic-api-key>"
           }
       }
   ]

Wenn Sie Docker nicht verwenden, ändern Sie den command zu:

"command": [
    "<path-to-your-conda-env>/bin/python",
    "<path-to-your-project>/langgraph-mcp.py"
]

Systemarchitektur

(Phase 1: Data Ingestion - Performed once on Host Machine)
┌─────────────┐      ┌──────────────────┐      ┌───────────────────────────────┐
│ LangGraph   │      │ Jupyter Notebook │      │ Vector Store & Full Docs      │
│ Docs (Web)  │───▶  │ (rag-tool.ipynb) │───▶  │ (.parquet & .txt files)       │
└─────────────┘      └──────────────────┘      └───────────────────────────────┘


(Phase 2: Live RAG System - Request/Response Flow)
┌──────────────┐                             ┌─────────────┐
│   VS Code    │                             │  .env file  │
│(User Interface)│                             │ (API KEY)   │
└──────┬───────┘                             └──────┬──────┘
       │ 1. User Query                             │ (provides)
       ▼                                           │
┌──────┴───────────────────────────────────────────┴───────────────────────────────┐
│ Host Machine Boundary                                                            │
│                                                                                  │
│      ┌────────────────────┐          ┌─────────────────────────────────────────┐ │
│      │ run-mcp-docker.sh  │ 2. Execs │  🐳 Docker Container                      │ │
│      │ (Entrypoint Script)│────▶     │                                         │ │
│      └────────────────────┘          │  ┌───────────────────────────────────┐  │ │
│                                      │  │   🐍 Python MCP Server              │  │ │
│      ▲                             ◀─┼──│   (langgraph-mcp.py)              │  │ │
│      │ 7. Final Response             │  └───────────────┬───────────────────┘  │ │
│      │                               │                  │ 3. Reads Data From  │ │
│      └───────────────────────────────│──────────────────│─────────────────────┘ │
│                                      │                  │                       │
│                                      │                  ▼                       │
│                                      │  ┌───────────────────────────────────┐  │
│ (files mounted from Host) ············  │   Mounted Vector Store & Docs     │  │
│                                      │  └───────────────────────────────────┘  │
│                                      └─────────────────────────────────────────┘ │
│                                                                                  │
└──────────────────────────────────────────────────────────────────────────────────┘
                                                        │ 4. API Call
                                                        │    (sends augmented prompt)
                                                        ▼
                                             ┌────────────────────┐
                                             │ ☁️ Anthropic API   │
                                             │   (Claude LLM)     │
                                             └──────────┬─────────┘
                                                        │ 5. Generation
                                                        │
                                                        ◀························
                                                          6. Returns Response
                                                          (to MCP Server)

Ressourcen

MCP From Scratch