LangGraph RAG MCP

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

Übersicht

Dieses Projekt erstellt ein Dokumentationsabrufsystem, das:

1. sammelt und verarbeitet die 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 in MCP-kompatible Hosts wie VS Code, Cursor, Claude Desktop oder Windsurf

Related MCP server: LangGraph RAG MCP

So funktioniert es

1. Erfassung 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 mit tiktoken in überschaubare Abschnitte auf, um eine genaue Token-Zählung zu ermöglichen.

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

• Speichert die Vektoren in einem SKLearnVectorStore für einen effizienten Abruf.

2. Retrieval-System (Tool)

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

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

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

3. MCP-Server-Integration

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

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

• Bietet Zugriff auf das Retrieval-System und zusätzliche Ressourcen (beispielsweise 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:
   Legen Sie die .env-Datei im Projektstamm an 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 Vorgang besteht aus zwei Schritten: Zuerst wird der Vektor-Store erzeugt, dann wird der MCP-Server ausgeführt.

Schritt 1: Vektor-Store erzeugen

Sie müssen das 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. Dieser Vorgang:

   • lädt die neueste LangGraph-Dokumentation herunter

   • speichert die vollständige Dokumentation unter llms_full.txt

   • teilt die Dokumente in Abschnitte auf

   • erstellt und speichert einen Vektor-Store unter sklearn_vectorstore.parquet

Schritt 2: MCP-Server ausführen

Mit Docker

Der einfachste Weg, den Server auszuführen, ist das mitgelieferte Shell-Skript zu verwenden, das Docker Compose umhüllt.

bash run-mcp-docker.sh

Dieses Skript erstellt das Docker-Image, falls es nicht existiert, startet den Container und führt dann den MCP-Server darin aus, wobei die Standardein-/ausgabe für die MCP-Kommunikation korrekt behandelt wird.

Ohne Docker

Wenn Sie Docker nicht verwenden, können Sie den MCP-Server direkt im Dev-Modus über den 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 Ihre VS-Code-Datei settings.json. (Sie finden sie über die Befehlspalette: Preferences: Open User Settings (JSON)).

2. Fügen Sie die folgende Konfiguration zur Datei hinzu. Ersetzen Sie <path-to-your-project> durch den absoluten Pfad zum langgraph-rag-mcp-Verzeichnis auf Ihrem Computer.

   "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 in:

"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`