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. LangGraph-Dokumentation sammelt und verarbeitet von der offiziellen Website

2. Eine Vektordatenbank erstellt aus dieser Dokumentation für die semantische Suche

3. Dieses Wissen zugänglich macht über das Model Context Protocol (MCP)

4. Sich in MCP-kompatible Hosts integriert wie VS Code, Cursor, Claude Desktop oder Windsurf

Related MCP server: mcp-rag-agent

So funktioniert es

1. Dokumentationssammlung und -verarbeitung (Kontext)

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

• Teilt Text mithilfe von RecursiveCharacterTextSplitter mit tiktoken in überschaubare Abschnitte auf, um Token genau zu zählen.

• Bettet Abschnitte mithilfe von 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 die relevantesten Dokumentationsabschnitte für eine bestimmte Abfrage findet.

• Integriert diese Funktion mit Sprachmodellen wie Claude, um kontextbewusste Antworten zu liefern.

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

3. MCP-Server-Integration

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

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

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

Anforderungen

• 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 Stammverzeichnis des Projekts und fügen Sie Ihren Anthropic-API-Schlüssel hinzu:

   echo "ANTHROPIC_API_KEY=your_api_key_here" > .env

   Die Datei docker-compose.yml 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 Prozess umfasst zwei Hauptschritte: erstens die Erzeugung des Vektor-Stores und zweitens die Ausführung des MCP-Servers.

Schritt 1: Vektor-Store erzeugen

Sie müssen dies nur einmal tun 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. Dies bewirkt Folgendes:

   • Die neueste LangGraph-Dokumentation herunterladen.

   • Die vollständige Dokumentation unter llms_full.txt speichern.

   • Die Dokumente in Abschnitte aufteilen.

   • Einen Vektor-Store unter sklearn_vectorstore.parquet erstellen und dauerhaft speichern.

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, wobei die Standard-I/O für die MCP-Kommunikation korrekt behandelt wird.

Ohne Docker

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

mcp dev langgraph-mcp.py

Konfigurieren von MCP-Hosts

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

VS Code

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

2. Fügen Sie die folgende Konfiguration zur Datei hinzu. Stellen Sie sicher, dass Sie <path-to-your-project> durch den absoluten Pfad zum Verzeichnis langraph-rag-mcp auf Ihrem Computer ersetzen.

"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 command wie folgt:

"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