LangGraph RAG MCP

Un sistema de generación aumentada por recuperación (RAG) que ofrece la documentación de LangGraph a través del Protocolo de Contexto de Modelo (MCP).

Resumen

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

1. Recopila y procesa la documentación de LangGraph desde el 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 Protocolo de Contexto de Modelo (MCP).

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

Related MCP server: AI Research Assistant MCP Server

Cómo funciona

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

• Extrae y limpia de forma recursiva la documentación de LangGraph de varias URL de sitios mediante RecursiveUrlLoader y BeautifulSoup.

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

• Convierte los fragmentos en representaciones vectoriales mediante 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 contextualizadas.

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

3. Integración con el servidor MCP

• Envuelve la herramienta de recuperación en un servidor MCP mediante la librería 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.

Uso con 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 consta de 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 hacer esto 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. Este proceso 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 conservará un almacén de vectores en sklearn_vectorstore.parquet.

Paso 2: Ejecutar el servidor MCP

Con Docker

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

bash run-mcp-docker.sh

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

Sin Docker

Si no usas 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 el archivo settings.json de tu 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 usas 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