LangGraph RAG MCP

Un sistema de generación aumentada por recuperación (RAG) que proporciona la documentación de LangGraph a través del Model Context Protocol (MCP).

Descripción general

Este proyecto construye un sistema de recuperación de documentación que:

1. Recopila y procesa la documentación de LangGraph del sitio web oficial

2. Crea una base de datos vectorial a partir de esta documentación para la búsqueda semántica

3. Expone este conocimiento a través del Model Context Protocol (MCP)

4. Se integra con hosts compatibles con MCP como VS Code, Cursor, Claude Desktop o Windsurf

Related MCP server: mcp-rag-agent

Cómo funciona

1. Recopilación y procesamiento de documentación (Contexto)

• Extrae y limpia de forma recursiva la documentación de LangGraph de múltiples URL de sitios web usando RecursiveUrlLoader y BeautifulSoup.

• Divide el texto en fragmentos manejables usando RecursiveCharacterTextSplitter con tiktoken para un recuento preciso de tokens.

• Convierte los fragmentos en representaciones vectoriales usando los embeddings de BAAI/bge-large-en-v1.5.

• Almacena los vectores en un SKLearnVectorStore para una recuperación eficiente.

2. Sistema de recuperación (Herramienta)

• Implementa una función de recuperación que encuentra los fragmentos de documentación más relevantes para una consulta determinada.

• Integra esta función con modelos de lenguaje como Claude para ofrecer respuestas conscientes del contexto.

• Devuelve respuestas formateadas que incluyen la atribución de la fuente y el contexto relevante.

3. Integración del servidor MCP

• Envuelve la herramienta de recuperación en un servidor MCP usando la biblioteca fastmcp.

• Expone la función de recuperación como una herramienta que los hosts compatibles con MCP pueden usar.

• Proporciona acceso tanto al sistema de recuperación como a recursos adicionales (como el archivo de documentación completo).

Requisitos

• Python 3.10+

• Docker y Docker Compose (recomendado)

• Clave de API de Anthropic (para los modelos Claude)

Instalación y configuración

Puedes ejecutar este proyecto con Docker (recomendado) o en un entorno local de Python.

Usando Docker (Recomendado)

1. Clona este repositorio:

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

2. Configura tus claves de API en un archivo .env: Crea un archivo .env en la raíz del proyecto y añade tu clave de API de Anthropic:

   echo "ANTHROPIC_API_KEY=your_api_key_here" > .env

   El archivo docker-compose.yml cargará automáticamente esta variable de entorno.

Entorno local (sin Docker)

1. Clona este repositorio:

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

2. Crea y activa un entorno virtual:

   conda create -n mcp python=3.13
   conda activate mcp

3. Instala los paquetes necesarios:

   pip install -r requirements.txt

4. Configura tus claves de API en un archivo .env:

   echo "ANTHROPIC_API_KEY=your_api_key_here" > .env

Uso

El proceso implica dos pasos principales: primero, generar el almacén de vectores, y segundo, ejecutar el servidor MCP.

Paso 1: Generar el almacén de vectores

Solo necesitas hacerlo una vez, o cada vez que quieras actualizar la documentación.

1. Abre y ejecuta el notebook rag-tool.ipynb en un entorno de Jupyter.

2. Esto hará lo siguiente:

   • Descargará la documentación más reciente de LangGraph.

   • Guardará la documentación completa en llms_full.txt.

   • Dividirá los documentos en fragmentos.

   • Creará y persistirá un almacén de vectores en sklearn_vectorstore.parquet.

Paso 2: Ejecutar el servidor MCP

Con Docker

La forma más sencilla de ejecutar el servidor es usar el script de shell proporcionado, que envuelve Docker Compose.

bash run-mcp-docker.sh

Este script construirá la imagen de Docker si no existe, iniciará el contenedor y luego ejecutará el servidor MCP dentro de él, manejando correctamente la E/S estándar para la comunicación MCP.

Sin Docker

Si no estás usando Docker, puedes ejecutar el servidor MCP directamente en modo de desarrollo mediante el comando:

mcp dev langgraph-mcp.py

Configuración de hosts MCP

Para usar este servidor MCP con un editor compatible, debes configurarlo.

VS Code

1. Abre tu archivo settings.json de VS Code. (Puedes encontrarlo mediante la paleta de comandos: Preferences: Open User Settings (JSON)).

2. Añade la siguiente configuración al archivo. Asegúrate de reemplazar <path-to-your-project> con la ruta absoluta al directorio langraph-rag-mcp en tu máquina.

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

Si no estás usando Docker, cambia el command a:

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

Arquitectura del sistema

(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)

Recursos

MCP From Scratch