---
title: "EdgeQuake: GraphRAG en PostgreSQL y memoria MCP"
canonical: https://wavect.io/es/blog/edgequake-postgresql-graphrag-mcp-agent-memory/
language: es
description: "Evalúa EdgeQuake v0.34.0 para GraphRAG en PostgreSQL y memoria MCP: permisos por espacio, modelos locales, configuración y límites del benchmark con LightRAG."
image: "https://wavect.io/img/blog/headers/header_edgequake-postgresql-graphrag-mcp-agent-memory.png"
author: ["Kevin Riedl"]
published: "2026-10-12"
updated: "2026-10-12"
reviewed: "2026-10-12"
---

# EdgeQuake: GraphRAG en PostgreSQL y memoria MCP para agentes

[**Volver**](/es/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/es/team/kevin-riedl/)

[Kevin Riedl](/es/team/kevin-riedl/) https://linkedin.com/in/wsdt

13 min de lectura · 12 oct 2026 Última revisión 12 de octubre de 2026

[**Siguiente**](/es/blog/graph-engineering-ai-agents/)

Resumen

EdgeQuake combina Rust, PostgreSQL, pgvector y Apache AGE para recuperar documentos y relaciones. Sus herramientas MCP devuelven evidencias con las que el agente elabora la respuesta. Evalúa v0.34.0 comprobando los permisos por espacio, la finalización de la indexación y cada función del modelo, incluidos los proveedores de respaldo. La comparación publicada de exactitud con LightRAG no tiene un ganador claro; los 82 ms utilizan cachés del LLM y de embeddings, mientras que la latencia en frío es similar. v0.34.0 añade un recorrido visual y mantiene el esquema 169.

**EdgeQuake es un servidor GraphRAG escrito en Rust que combina la búsqueda documental con un grafo de conocimiento en PostgreSQL.** Mediante MCP, un agente puede recuperar evidencias de ese almacén en conversaciones sucesivas. Su principal utilidad aparece cuando una respuesta exige relacionar varios documentos: por ejemplo, qué contrato de proveedor cubre un componente utilizado en un producto concreto.

La [versión v0.34.0](https://github.com/raphaelmansuy/edgequake/releases/tag/v0.34.0), publicada el 11 de octubre de 2026, ofrece un punto de referencia para evaluar esa arquitectura. Si tu equipo ya administra PostgreSQL, mantener los datos del grafo, los vectores y los documentos en un mismo almacén puede facilitar la gestión del despliegue.

**Revisado el 12 de octubre de 2026.** Este artículo contrasta la documentación y la implementación de la versión etiquetada. Los ejemplos proponen pasos de evaluación; Wavect no ha ejecutado este despliegue de EdgeQuake ni ha reproducido sus benchmarks de forma independiente.

## ¿Qué cambia en EdgeQuake v0.34.0?

**v0.34.0 añade un recorrido visual y mantiene el esquema de base de datos 169.** Las [notas de actualización de esta versión](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/operations/upgrade-to-0.34.0.md) indican que las consultas y el almacenamiento conservan su comportamiento. La versión reutiliza resultados de exactitud publicados en agosto. Las conexiones cifradas a proveedores, el aislamiento entre espacios de trabajo y MCP son capacidades acumuladas del producto que ya existían antes de este lanzamiento.

Esta distinción ayuda a planificar la actualización. Al partir de v0.33.0 con el esquema 169, el comando de migración debería indicar que no hay migraciones pendientes. Una instalación anterior necesita seguir su ruta de actualización documentada. El anuncio de una versión no basta para confirmar que la base de datos está preparada.

## Usa GraphRAG cuando la respuesta dependa de una relación

El [repositorio de EdgeQuake](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/README.md) describe una implementación en Rust de la recuperación al estilo de LightRAG: incorpora documentos, extrae entidades y relaciones, y recupera contexto útil mediante operaciones vectoriales y sobre grafos. PostgreSQL guarda los datos; pgvector realiza la búsqueda vectorial y Apache AGE aporta la capa de grafos.

Considera este corpus de evaluación, creado como ejemplo ficticio:

| Documento | Dato registrado | Evidencia que debe aportar la respuesta |
| --- | --- | --- |
| Especificación del producto | El producto Atlas utiliza el componente C-17. | El vínculo entre producto y componente. |
| Contrato de proveedor | El contrato S-24 cubre el componente C-17. | El vínculo entre componente y contrato. |
| Registro de responsabilidades | El equipo de compras es responsable del contrato S-24. | El vínculo entre contrato y responsable. |

Pregunta: «¿Qué contrato afecta al producto Atlas y quién es responsable de él?». Un resultado útil debe respaldar cada conexión con la fuente correcta. Encontrar un párrafo que mencione Atlas es insuficiente. Una relación extraída también puede ser errónea: revisa el texto de origen antes de aceptar la respuesta.

La recuperación vectorial ya puede resolver algunas preguntas que abarcan varios documentos, sobre todo con una buena división en fragmentos y búsquedas sucesivas. Mide si añadir el grafo ayuda a responder tus preguntas reales. Nuestra [guía de ingeniería de grafos para agentes de IA](/es/blog/graph-engineering-ai-agents/) aborda la decisión de arquitectura más amplia; este artículo se centra en la operación de EdgeQuake.

## Qué incluye «un solo PostgreSQL» en la práctica

**Un almacén de datos sigue implicando varios procesos.** El [archivo Docker Compose de la versión etiquetada](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docker-compose.quickstart.yml) define PostgreSQL, la API en Rust, una interfaz web y un servicio de migración que se ejecuta antes de la API. La versión publica variantes de imagen para PostgreSQL 16, 17 y 18 con las extensiones necesarias. Una instancia convencional de PostgreSQL gestionado necesita soporte compatible con pgvector y Apache AGE.

El servidor Rust es un único binario. La interfaz web, el proveedor de identidad opcional y cualquier servidor local de modelos tienen sus propios requisitos de ejecución. «Un solo PostgreSQL» describe dónde residen los datos de recuperación; el presupuesto operativo también debe incluir el alojamiento de modelos, las copias de seguridad y las actualizaciones.

Para repetir la evaluación en las mismas condiciones, descarga el archivo Compose revisado y comprueba las imágenes seleccionadas antes de iniciarlo:

```
mkdir edgequake-0.34.0
cd edgequake-0.34.0
curl -fsSL \
  https://raw.githubusercontent.com/raphaelmansuy/edgequake/v0.34.0/docker-compose.quickstart.yml \
  -o docker-compose.quickstart.yml
export EDGEQUAKE_VERSION=0.34.0
docker compose -f docker-compose.quickstart.yml config --images
```

Guarda esa versión en la configuración del despliegue. De lo contrario, el archivo utiliza `latest`. Su configuración de demostración limita los puertos publicados a la interfaz de bucle local y desactiva la autenticación; configura el inicio de sesión antes de usarlo como servicio de conocimiento compartido. La sección de autenticación indica la configuración adicional de Compose necesaria.

## Memoria MCP: incorpora documentos, espera y recupera evidencias

La [guía de integración MCP](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/integrations/mcp.md) documenta la pasarela en `POST /mcp`, con `/api/v1/mcp` como alias. El flujo de trabajo es el siguiente:

1. Crea un espacio de trabajo mediante la interfaz o la API REST y concede acceso a la identidad que lo utilizará.
2. Con una identidad autorizada para escribir, `eq_ingest` envía texto; las herramientas `eq_upload_*` gestionan la carga de archivos.
3. Conserva el identificador de tarea devuelto y consulta `eq_task_get` periódicamente. El documento se puede buscar cuando la tarea indica `indexed`.
4. Utiliza `eq_search` y después `eq_fetch` con `view=toc` para revisar las evidencias disponibles. Recupera los fragmentos o las citas necesarios.
5. Deja que el agente que llama a las herramientas redacte la respuesta y conserva las referencias a las fuentes. Cada conversación nueva debe recuperar las evidencias de nuevo.

**Estas herramientas MCP devuelven evidencias que utiliza el agente.** La API específica de generación de respuestas constituye una vía independiente. «Segundo cerebro» resume la idea de un conocimiento persistente y recuperable; cada conversación necesita un mecanismo explícito para guardar información y cada respuesta requiere verificación.

Para un conector dedicado a la recuperación, configura `EDGEQUAKE_MCP_PROFILE=query` en el entorno del proceso de la API. El perfil predeterminado, `control`, también expone herramientas de escritura; `memory` es su alias. Un despliegue dedicado a consultas necesita otra vía de ingesta mediante la interfaz, la API REST u otro servicio configurado expresamente.

## Limita los permisos del agente al espacio de trabajo previsto

La [referencia de claves API](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/security/authentication/api-keys-and-mcp.md) distingue `edgequake:read`, `edgequake:query` y `edgequake:write`. Los permisos predeterminados de una clave son lectura y consulta. Crea una clave para una identidad dedicada que pertenezca únicamente a los espacios que necesita el agente.

Sigue la [guía rápida de autenticación](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/operations/auth-quickstart.md) para habilitar el inicio de sesión. En el despliegue Compose revisado, necesitas `EDGEQUAKE_AUTH_ENABLED=true`, `EDGEQUAKE_DEV_MODE=false`, un `JWT_SECRET` robusto y persistente, credenciales de inicialización y una configuración adicional de Compose que pase `EDGEQUAKE_CORS_ORIGINS` a la API. Incluye también el perfil MCP en esa configuración de la API; exportarlo solo en la terminal del host no lo transmite a través de este archivo Compose. Keycloak/OIDC permite utilizar SSO; su despliegue y la gestión del ciclo de vida de las cuentas requieren configuración propia.

**La cabecera del espacio de trabajo selecciona el contexto; los controles de autorización deben aplicar los permisos de acceso.** El [tipo de creación de claves API](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/edgequake/crates/edgequake-api/src/handlers/auth_types.rs) de la versión etiquetada acepta un nombre, permisos y una caducidad opcional, pero ningún identificador de espacio de trabajo. Si la clave pertenece a un usuario con permisos amplios, configurar un espacio predeterminado en el cliente no basta para limitarla a ese espacio.

Prueba un espacio autorizado y otro ajeno con la misma credencial. Repite la prueba omitiendo la cabecera del espacio de trabajo y después de revocar el acceso. Comprueba la recuperación de documentos y las herramientas de grafos además de la búsqueda. Para heredar permisos de los sistemas de origen a nivel de documento, consulta nuestra [guía de RAG con control de permisos](/es/blog/rag-permissions-sharepoint-confluence-drive/); separar espacios de trabajo no demuestra que se respeten esos permisos de origen.

### Una consulta HTTP contrastada con el código para un servidor autenticado

Cuando el servidor esté configurado y el corpus ficticio esté indexado, proporciona la clave, el identificador de tenant y el del espacio de trabajo mediante el entorno local. Esta petición de diagnóstico utiliza la [validación del transporte HTTP](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/edgequake/crates/edgequake-api/src/mcp/gateway/validate.rs) y el [esquema de argumentos de herramientas](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/edgequake/crates/edgequake-api/src/mcp/gateway/tools.rs) de esta versión. Mantén las credenciales fuera de la configuración del cliente que guardes en Git.

```
curl --fail-with-body -sS http://localhost:8080/mcp \
  -H "Authorization: Bearer $EDGEQUAKE_API_KEY" \
  -H "X-Tenant-ID: $EDGEQUAKE_TENANT_ID" \
  -H "X-Workspace-Id: $EDGEQUAKE_WORKSPACE_ID" \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -H 'MCP-Protocol-Version: 2026-07-28' \
  -H 'Mcp-Method: tools/call' \
  -H 'Mcp-Name: eq_search' \
  --data-binary @- <<'JSON'
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "eq_search",
    "arguments": {
      "query": "Which agreement affects Product Atlas, and who owns it?",
      "mode": "hybrid",
      "budget": "standard",
      "limit": 8
    }
  }
}
JSON
```

Este diagnóstico de la pasarela se ha contrastado con el código fuente; no se ha ejecutado contra un servidor activo. Un cliente MCP convencional también realiza el intercambio de inicialización. Utiliza HTTPS en un despliegue remoto. Revisa los identificadores de evidencias y los errores devueltos, incluidos `error` de JSON-RPC e `isError` de MCP; recibir una respuesta HTTP no demuestra que la recuperación haya tenido éxito.

`hybrid` combina la recuperación local y global del grafo. El modo predeterminado, `mix`, añade fusión de resultados y reordenación por relevancia; el benchmark que aparece más adelante utiliza Mix. Anota el modo junto con los resultados.

Comprueba la compatibilidad del transporte del cliente antes de elegir un puente. La [implementación del puente stdio](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/mcp/src/gateway-bridge.ts) de la versión etiquetada no envía las cabeceras de método y nombre utilizadas arriba ni transmite el tenant predeterminado configurado. Estos detalles limitan las garantías que ofrece el puente revisado para una conexión con varios tenants. Verifica el paquete instalado y sus peticiones salientes antes de confiar en un ejemplo genérico de instalación con `npx`.

## Un despliegue totalmente local exige revisar cada función del modelo

EdgeQuake admite proveedores en la nube y endpoints de modelos locales. La [referencia de funciones por espacio de trabajo](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/providers/roles.md) permite comprobar adónde se envían los datos:

| Función | Datos procesados | Detalle de configuración |
| --- | --- | --- |
| Extracción | Texto de los documentos y relaciones. | Las variables de entorno pueden prevalecer sobre la configuración del espacio. |
| Palabras clave y consultas | Preguntas; contexto recuperado para las respuestas generadas por el servidor. | Revisa ambas funciones y cualquier configuración específica de la petición. |
| Resumen | Descripciones de entidades que se están fusionando. | Esta función no utiliza una Connection guardada en la versión revisada. |
| Embeddings | Texto convertido en vectores. | Cambiar el modelo o las dimensiones exige regenerar los embeddings almacenados. |
| Visión | Imágenes de páginas PDF. | Comprueba la configuración de carga y el modelo de visión del espacio. |
| Reordenación por relevancia, si está activada | Candidatos recuperados y pregunta. | Se configura a nivel de servidor. |

La documentación describe el uso de valores predeterminados del espacio o del servidor cuando una Connection guardada no puede utilizarse. En un despliegue local con Ollama, LM Studio, MLX o llama.cpp, comprueba qué endpoints son accesibles y qué modelo se selecciona para cada función. Después, provoca un fallo del endpoint local y revisa si la petición llega a otro proveedor.

El modelo del propio agente es otro destino de datos. Un almacén de conocimiento local puede devolver fragmentos de las fuentes a un cliente MCP que utilice un modelo en la nube. Incluye esa llamada final al modelo al decidir si el flujo cumple tus requisitos de procesamiento local.

La [guía de seguridad de proveedores](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/providers/security.md) documenta el cifrado AES-256-GCM de las claves guardadas y respuestas que no permiten volver a leerlas. Conserva `EDGEQUAKE_SECRETS_KEY` de forma segura: cambiarla o perderla impide descifrar las claves almacenadas. El inicio rápido interactivo genera una clave nueva en cada ejecución, salvo que ya exista una exportada. El cifrado en reposo protege la credencial almacenada; el proveedor configurado sigue procesando las peticiones que recibe.

### Evalúa la extracción de PDF antes de confiar en el grafo

La [guía de procesamiento de PDF](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/deep-dives/pdf-processing.md) describe la extracción de texto y el procesamiento con visión para páginas escaneadas y diseños complejos. Prueba una tabla real, una página escaneada y un documento donde se haya revisado el código de un componente. Inspecciona el contenido extraído y sus referencias de origen antes de evaluar la respuesta. Una fila de tabla interpretada de forma incorrecta puede convertirse en una relación del grafo convincente, pero errónea.

## EdgeQuake frente a LightRAG: comprueba las condiciones de caché

El [registro de benchmarks publicado por el proyecto](https://github.com/raphaelmansuy/edgequake/blob/v0.34.0/docs/comparisons/eq-vs-lightrag-acc-bench.md) recoge los siguientes resultados. Son mediciones de los desarrolladores realizadas en ejecuciones distintas y reutilizadas en esta versión.

| Medición | EdgeQuake | LightRAG | Ejecución e interpretación |
| --- | --- | --- | --- |
| Exactitud de las respuestas | 0,792 | 0,786 | 15 de agosto de 2026, medical-mid, n=200. Sin un ganador claro. |
| Cobertura de evidencias (recall) | 0,932 | 0,949 | La evaluación de exactitud favorece a LightRAG en cobertura de evidencias. |
| Relevancia del contexto | 0,471 | 0,510 | La misma evaluación favorece a LightRAG en relevancia del contexto. |
| p50 de consulta con caché | 82 ms | 993 ms | 15 de agosto de 2026, n=200, cachés del LLM y de embeddings activadas. |
| p50 de consulta en frío | 4447 ms | 4359 ms | 23 de julio de 2026, n=40, cachés del LLM desactivadas. Medianas de latencia similares. |

La comparación de exactitud utiliza el mismo corpus, las mismas preguntas, el modo Mix, Mistral Small y `mistral-embed`. El intervalo de confianza del 95 % para la diferencia de exactitud es [-0,022; +0,034] e incluye el cero. Eso no demuestra que la calidad de recuperación sea equivalente.

En la ejecución con caché, las etapas de palabras clave, embeddings y generación registran cada una una mediana de cero milisegundos. Por tanto, los 82 ms no representan el tiempo necesario para responder una pregunta nueva con llamadas nuevas a los modelos. Las consultas repetidas pueden beneficiarse de la caché; mide las preguntas nuevas por separado.

## Una primera evaluación útil cabe en un espacio de trabajo

Recomendamos empezar con un conjunto pequeño de documentos cuyo uso esté autorizado y preguntas que exijan identificar relaciones concretas. Acuerda qué evidencias debe contener una respuesta correcta antes de incorporar los documentos. Incluye una pregunta que esos documentos no permitan responder.

- Verifica la cadena completa de relaciones del ejemplo Atlas y revisa cada fragmento citado.
- Prueba las mismas preguntas con el modo de grafo elegido y una base de comparación de recuperación más sencilla.
- Mide por separado la latencia de consultas nuevas, la de consultas repetidas, el tiempo de ingesta y el coste de los modelos.
- Utiliza una segunda identidad para comprobar el aislamiento entre espacios, las credenciales inválidas y la revocación de pertenencia.
- Cambia un dato en una fuente, procésala de nuevo y busca evidencias contradictorias u obsoletas.
- Restaura la base de datos y los secretos necesarios en un entorno de pruebas; después, repite la recuperación.

Utiliza `edgequake doctor` para revisar la configuración y la preparación de la base de datos. Sigue los pasos explícitos de migración antes de poner en servicio una API actualizada. La revisión del código y un proceso operativo ayudan a evaluar el sistema; las pruebas documentales, de acceso y de recuperación determinan si el despliegue sirve para tu trabajo.

Conviene evaluar EdgeQuake cuando el problema exige relacionar documentos y tu equipo puede operar PostgreSQL. Si necesitas principalmente compartir decisiones de programación entre IDE, nuestra [guía de configuración de mcp-memory-service](/es/blog/mcp-memory-service-claude-code-cursor/) aborda ese flujo más concreto. Para elegir entre un servicio de conocimiento propio y un producto existente, consulta la [guía de decisión entre software a medida y software estándar](/es/software-development-guide/custom-software-vs-off-the-shelf/).

## Preguntas frecuentes sobre EdgeQuake, PostgreSQL y MCP

### ¿Qué es EdgeQuake?

EdgeQuake es un servidor GraphRAG de código abierto escrito en Rust que utiliza PostgreSQL, pgvector y Apache AGE. Convierte los documentos incorporados en texto consultable y en un grafo de entidades y relaciones. Los clientes MCP pueden recuperar evidencias de ese almacén persistente.

### ¿Necesita EdgeQuake una base de datos de grafos separada?

El despliegue PostgreSQL revisado guarda los datos vectoriales y de grafos en PostgreSQL con pgvector y Apache AGE. El conjunto también incluye la API, la interfaz web y un servicio explícito de migración. Los servidores de modelos locales y el proveedor de identidad opcional añaden componentes de ejecución.

### ¿Es EdgeQuake más rápido o más exacto que LightRAG?

La comparación de exactitud publicada con n=200 no tiene un ganador estadísticamente claro. LightRAG obtiene mayor cobertura de evidencias y relevancia del contexto. La mediana de 82 ms de EdgeQuake utiliza cachés del LLM y de embeddings; la comparación en frío realizada por separado, con n=40, registra latencias similares.

### ¿Puede EdgeQuake MCP funcionar como memoria de agentes de solo lectura?

Configura EDGEQUAKE_MCP_PROFILE=query en la API y utiliza credenciales limitadas a los permisos de lectura y consulta necesarios. Restringe los espacios a los que pertenece la identidad y prueba el acceso a otro espacio. El conocimiento nuevo necesitará una vía de ingesta autorizada fuera de ese conector dedicado a consultas.

### ¿Un servidor local de EdgeQuake mantiene todos los datos en local?

Revisa extracción, palabras clave, resúmenes, embeddings, visión, reordenación y modelos de respaldo. Comprueba también el modelo del agente: un cliente en la nube puede recibir fragmentos recuperados aunque PostgreSQL y EdgeQuake se ejecuten localmente.

### ¿Qué novedades incluye EdgeQuake v0.34.0?

La versión del 11 de octubre de 2026 añade un recorrido visual. Sus notas de actualización mantienen el esquema 169 y el comportamiento de consultas y almacenamiento de v0.33.0. Las cifras del benchmark proceden de evaluaciones anteriores del proyecto; no constituyen una evaluación nueva de v0.34.0.

Modelos e infraestructura

## Qué leer después

Selección de modelos, economía de inferencia, despliegue local, compresión y serving.

[Empieza aquí**Alojar LLMs en la UE: Cuándo Salen a Cuenta los Open Weights**](/es/blog/self-hosting-llms-eu-cost/)

- [Google SAM ahora es Agent Mesh: MCP entre equipos](/es/blog/google-sam-agent-mesh-mcp-tools/)
- [BitNet en CPU: 2B4T, requisitos de RAM y la cifra de 100B](/es/blog/bitnet-cpu-llm-ram-requirements/)
- [SuperPenguin: costes de IA por PR, cliente y función](/es/blog/superpenguin-ai-roi-cost-per-pr-customer/)
- [Claude Dashboards y Motion: de métricas a vídeos](/es/blog/claude-dashboards-motion-product-kpi-video/)
- [OpenAI Intelligent UI vs OpenUI: UI generativa para empresas](/es/blog/openai-intelligent-ui-vs-openui/)

[Artículo anterior**Google SAM ahora es Agent Mesh: MCP entre equipos**](/es/blog/google-sam-agent-mesh-mcp-tools/) [Artículo siguiente**BitNet en CPU: 2B4T, requisitos de RAM y la cifra de 100B**](/es/blog/bitnet-cpu-llm-ram-requirements/)

[**Volver**](/es/blog/overview/)

[![Kevin Riedl](/img/team/kevin.webp)](/es/team/kevin-riedl/)

[Kevin Riedl](/es/team/kevin-riedl/) https://linkedin.com/in/wsdt

13 min de lectura · 12 oct 2026 Última revisión 12 de octubre de 2026

[**Siguiente**](/es/blog/graph-engineering-ai-agents/)