RAG con MCP: recuperación de información para tu IA

Aprende a construir un pipeline de Retrieval Augmented Generation usando servidores MCP como fuente de datos, memoria y contexto. Tu IA dejará de alucinar y empezará a responder con información real.

¿Qué es RAG?

Retrieval Augmented Generation (RAG) es una arquitectura que combina recuperación de información con generación de texto. En lugar de que un modelo de lenguaje responda únicamente desde su conocimiento interno (con fecha de corte y propenso a alucinaciones), RAG primero consulta una fuente externa — documentos, bases de datos, web — y luego genera la respuesta usando ese contexto recuperado.

Un pipeline RAG típico tiene cuatro componentes:

• Ingesta — leer documentos fuente y extraer su contenido
• Almacenamiento — guardar la información procesada en un formato recuperable
• Recuperación — buscar los fragmentos más relevantes para una consulta
• Generación — el modelo de lenguaje responde usando el contexto recuperado

MCP encaja de forma natural aquí: cada fase del pipeline puede ser cubierta por uno o varios servidores MCP, sin necesidad de infraestructura adicional.

Componentes RAG como MCPs

El ecosistema MCP incluye servidores que cubren cada etapa del pipeline RAG. Estos son los más relevantes:

Filesystem MCP

El servidor @modelcontextprotocol/server-filesystem expone herramientas para leer archivos del disco. Es tu puerta de entrada para la ingesta: documentación técnica, manuales, archivos markdown, código fuente. Con tools como read_file, list_directory y search_files, la IA puede explorar y extraer contenido de cualquier carpeta del proyecto.

Fetch MCP

El servidor @modelcontextprotocol/server-fetch permite a la IA descargar contenido web. Ideal para traer documentación online, artículos, o APIs públicas. La herramienta fetch recibe una URL y devuelve el contenido en texto plano, listo para ser procesado.

Memory MCP

El servidor @modelcontextprotocol/server-memory proporciona una base de conocimiento persistente basada en grafos de entidades. Con tools como add_knowledge, search_knowledge y get_related_knowledge, la IA puede almacenar hechos, conceptos y relaciones entre sesiones. Es el equivalente a una memoria vectorial ligera, pero sin necesidad de embeddings ni bases de datos especializadas.

Servidores de vectores (opcional)

Para búsqueda semántica a gran escala, existen servidores MCP que se conectan a bases de datos vectoriales como Supabase (pgvector), Pinecone o Weaviate. No son parte del estándar MCP, pero la comunidad los ha implementado como wrappers. Si tu volumen de documentos supera unos pocos megabytes, vale la pena considerar esta opción.

Pipeline de ingesta

La ingesta es el proceso de leer documentos y convertirlos en conocimiento estructurado que la IA pueda recuperar después. Con MCP, este pipeline se ejecuta dentro de la conversación:

1. Leer documentos con Filesystem MCP

La IA usa list_directory para explorar la carpeta de documentos y read_file para leer cada archivo relevante. Puede filtrar por extensión, nombre o contenido con search_files.

// La IA ejecuta internamente algo como:
list_directory("./docs/api/")
→ ["endpoints.md", "auth.md", "errors.md"]

read_file("./docs/api/endpoints.md")
→ "# Endpoints\n## GET /users\n..."

2. Extraer chunks relevantes

La IA analiza el contenido y extrae fragmentos significativos: definiciones de endpoints, descripciones de parámetros, ejemplos de uso. Cada fragmento debe ser atómico — una idea por chunk — para que la recuperación sea precisa.

3. Almacenar en Memory MCP

Cada fragmento se guarda como un nodo de conocimiento con add_knowledge. Puedes incluir metadatos como la fuente, el tipo de información o tags para facilitar el filtrado posterior.

// Cada chunk se convierte en un nodo de conocimiento
add_knowledge({
  fact: "GET /users devuelve la lista de usuarios paginada",
  source: "./docs/api/endpoints.md",
  tags: ["endpoint", "users", "GET"]
})

Pipeline de consulta

Cuando un usuario hace una pregunta, la IA sigue este flujo:

• 1. Interpretar — la IA analiza la pregunta y extrae términos clave
• 2. Buscar en memoria — usa search_knowledge en Memory MCP para encontrar hechos relevantes
• 3. Complementar — si la memoria no tiene suficiente contexto, lee archivos directamente con Filesystem MCP o fetch
• 4. Combinar — integra el contexto recuperado con la pregunta original
• 5. Responder — genera la respuesta citando las fuentes

La clave de RAG con MCP es que la recuperación y la generación ocurren en el mismo turno de conversación. No hay un sistema externo de embeddings ni una base de datos vectorial intermedia — todo vive en los servidores MCP que el asistente ya tiene configurados.

Ejemplo práctico: asistente de documentación

Vamos a montar un asistente que analiza la documentación de una API y responde preguntas sobre sus endpoints. Solo necesitas dos servidores MCP.

Configurar Filesystem MCP

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./docs"]
    }
  }
}

Configurar Memory MCP

{
  "mcpServers": {
    "filesystem": { ... },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Workflow

Una vez configurados, puedes pedirle a la IA:

"Analiza la documentación de mi API en ./docs y responde preguntas sobre los endpoints."

La IA hará lo siguiente automáticamente:

• Explorará ./docs con list_directory
• Leerá cada archivo markdown con read_file
• Extraerá hechos (endpoints, parámetros, ejemplos) y los guardará con add_knowledge
• En consultas futuras, usará search_knowledge para recuperar el contexto antes de responder

Por ejemplo, tras la ingesta puedes preguntar:

"¿Qué parámetros acepta el endpoint POST /users?"

La IA buscará en su memoria MCP, encontrará el chunk relevante y te responderá con la información exacta de la documentación, incluyendo la fuente.

Estrategias avanzadas

Chunking semántico vs por tokens

El chunking determina cómo divides los documentos en fragmentos recuperables. El enfoque por tokens corta cada N tokens, es simple pero puede partir una idea por la mitad. El chunking semántico respeta los límites naturales del contenido: párrafos, secciones, bloques de código. Memory MCP funciona mejor con chunks semánticos porque cada nodo de conocimiento representa un hecho completo y coherente.

Metadata tagging para filtrado

Cuando almacenas conocimiento en Memory MCP, los tags son tu herramienta de filtrado más potente. Puedes etiquetar chunks por:

• Tipo de información: "endpoint", "schema", "ejemplo", "error"
• Módulo o área: "auth", "payments", "users"
• Prioridad o versión: "v2", "deprecated", "critical"

Cuando la IA busca, puede incluir tags en la consulta para acotar los resultados y mejorar la precisión.

Actualización incremental de memoria

La documentación cambia. Con MCP puedes mantener la memoria actualizada sin re-ingestar todo: la IA lee solo los archivos modificados, elimina los nodos de conocimiento obsoletos y añade los nuevos. Puedes incluso pedirle una rutina de verificación periódica.

Limitaciones

RAG con MCP es poderoso para equipos pequeños y documentación técnica, pero tiene limitaciones que conviene conocer:

• Ventana de contexto del modelo — aunque Memory MCP almacena muchos hechos, la IA solo puede recuperar unos pocos en cada consulta. El límite es la ventana de contexto del modelo que estés usando.
• Coste de tokens en ingesta grande — si tu documentación tiene cientos de archivos, la ingesta inicial puede consumir muchos tokens. Planifica la ingesta incremental para mitigar este coste.
• Sin base de datos vectorial nativa en MCP estándar — Memory MCP usa búsqueda por palabras clave y relaciones, no embeddings. Para búsqueda semántica a escala necesitarás un servidor de vectores externo o una base de datos como Supabase con pgvector.