EdgeQuake: PostgreSQL GraphRAG for MCP agent memory

Back

Kevin Riedl

12 min read · 12 Oct 2026
Last reviewed October 12, 2026

Next

EdgeQuake is a Rust GraphRAG server that combines document search with a knowledge graph in PostgreSQL. Through MCP, an agent can retrieve evidence from that store across conversations. Its strongest reason to exist is a question whose answer spans several documents: which supplier agreement covers a component used by a particular product, for example.

The v0.34.0 release, published on 11 October 2026, is a useful point to assess that architecture. For a team already operating PostgreSQL, keeping graph, vector and document data in one datastore can make the deployment easier to own.

Reviewed on 12 October 2026. This article checks the tagged documentation and implementation. The examples below are proposed evaluation steps; Wavect has not run this EdgeQuake deployment or independently reproduced its benchmarks.

What changed in EdgeQuake v0.34.0?

v0.34.0 adds a visual tour and retains database schema 169. The version-specific upgrade notes say query and storage behavior are unchanged. The release carries forward existing accuracy evidence from August. Features such as encrypted provider connections, workspace isolation and MCP belong to the accumulated product, rather than all being new in this release.

That distinction helps an operator plan an upgrade. From v0.33.0 on schema 169, the migration command should have nothing pending. An older installation needs its documented upgrade path. A release announcement alone does not establish that your database is ready.

Use GraphRAG when the missing answer is a relationship

The EdgeQuake repository describes a Rust implementation of LightRAG-style retrieval: ingest documents, extract entities and relationships, and retrieve useful context through vector and graph operations. PostgreSQL holds the data; pgvector handles vector search and Apache AGE provides the graph layer.

Consider this deliberately fictional evaluation corpus:

Ask: “Which agreement affects Product Atlas, and who owns it?” A useful result must support every connection with the right source. Finding a paragraph that mentions Atlas is insufficient. An extracted edge can also be wrong, so inspect the underlying text before accepting the answer.

Vector retrieval can already solve some cross-document questions, particularly with good chunking and repeated retrieval. Measure whether adding the graph helps your actual questions. Our guide to graph engineering for AI agents covers the broader architecture decision; this article focuses on operating EdgeQuake.

What “one PostgreSQL” includes in practice

One datastore still comes with several processes. The tagged Docker Compose file defines PostgreSQL, the Rust API, a web frontend and a migration service that runs before the API. The release publishes PostgreSQL 16, 17 and 18 image variants with the required extensions. An ordinary managed PostgreSQL instance needs compatible pgvector and Apache AGE support.

The Rust server is one binary. The frontend, optional identity provider and any local model server have their own runtime requirements. “One PostgreSQL” describes where retrieval data lives; it does not remove model hosting, backups or upgrades from the operating budget.

For a repeatable evaluation, download the reviewed Compose file and inspect the image selection before starting it:

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

Record that version in your deployment configuration. The file otherwise defaults to latest. Its demo settings bind published ports to loopback and disable authentication; configure login before using it as a shared knowledge service. The authentication section below points to the required Compose override.

MCP memory: ingest, wait, retrieve evidence

The MCP integration guide documents the gateway at POST /mcp, with /api/v1/mcp as an alias. The important workflow is:

1. Create a workspace through the UI or REST API and give the intended identity access.
2. For an authorized writer, eq_ingest submits text; the eq_upload_* tools handle uploaded files.
3. Keep the returned task identifier and poll eq_task_get. The document becomes searchable when the task reports indexed.
4. Use eq_search, then eq_fetch with view=toc to inspect the available evidence. Fetch the required chunks or citations.
5. Let the host agent compose the answer and retain the source references. A new conversation must retrieve the evidence again.

These MCP tools return evidence for the host agent to use. The separate answer-generation API is a different path. The phrase “second brain” is useful shorthand for persistent, retrievable knowledge; it does not mean every conversation is automatically captured or every answer is automatically correct.

For a retrieval-only connector, set EDGEQUAKE_MCP_PROFILE=query in the API process environment. The default control profile also exposes write tools; memory is its alias. A query-only deployment needs an ingestion path through the UI, REST API or another deliberately configured service.

Bind the agent's permissions to the intended workspace

The API-key reference distinguishes edgequake:read, edgequake:query and edgequake:write. The default key scopes are read and query. Issue a key for a dedicated identity with only the memberships the agent needs.

Use the authentication quickstart to enable login. For the reviewed Compose deployment, that includes EDGEQUAKE_AUTH_ENABLED=true, EDGEQUAKE_DEV_MODE=false, a strong persistent JWT_SECRET, bootstrap credentials and a Compose override that passes EDGEQUAKE_CORS_ORIGINS into the API. Set the MCP profile in that API override too; exporting it in the host shell alone does not pass it through this Compose file. SSO is available through Keycloak/OIDC; its deployment and account lifecycle need their own configuration.

A workspace header selects context; the authorization checks must enforce access. The tagged API-key creation type accepts a name, scopes and optional expiry, but no workspace identifier. Do not assume a broadly privileged user's key is confined to one workspace because the client has a default workspace setting.

Test an allowed workspace and a neighboring workspace with the same credential. Repeat with the workspace header omitted and after revoking access. Check document fetches and graph tools as well as search. For document-level access inherited from upstream systems, use our separate permission-aware RAG guide; workspace separation alone does not establish those source permissions.

A source-checked HTTP query for an authenticated server

Once the server is configured and the fictional corpus is indexed, supply the key, tenant ID and workspace ID through your local environment. This diagnostic request uses the version's HTTP transport validation and tool argument schema. Keep credentials out of committed client configuration.

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

This is a gateway diagnostic, checked against source rather than executed against a live server. A normal MCP client also performs its initialization handshake. Use HTTPS for a remote deployment. Inspect the returned evidence handles and errors, including JSON-RPC error and MCP isError; an HTTP response alone does not prove retrieval succeeded.

hybrid combines local and global graph retrieval. The default mix mode adds fused retrieval and reranking; the benchmark below uses Mix. Keep the mode recorded alongside your results.

Check client transport compatibility before choosing a bridge. The tagged stdio bridge implementation does not send the method/name headers used above or forward the configured default tenant. Those details limit what this reviewed bridge establishes for a multi-tenant connection. Verify the package actually installed and its outgoing requests before relying on a generic npx setup snippet.

Fully local requires checking every model role

EdgeQuake supports cloud providers and local model endpoints. The workspace-role reference is more useful than a provider-logo list because it shows where your data goes:

The role documentation describes fallback to workspace or server defaults when a saved Connection cannot be used. For a local deployment with Ollama, LM Studio, MLX or llama.cpp, verify reachable endpoints and actual role selection. Then test a failed local endpoint and inspect whether another provider receives the request.

The agent's own model is another data destination. A locally hosted knowledge store can return source passages to a cloud-hosted MCP client. Include that final model call when deciding whether the workflow meets your locality requirement.

The provider-security guide documents AES-256-GCM encryption for saved provider keys and write-only key responses. Persist EDGEQUAKE_SECRETS_KEY securely: changing or losing it prevents decryption of stored keys. The interactive quickstart generates a new key on each run unless one is already exported. Encryption at rest protects the stored credential; the configured provider still processes the requests sent to it.

Evaluate PDF extraction before trusting the graph

The PDF processing guide describes text extraction and vision-based processing for scanned pages and complex layouts. Test a real table, a scanned page and a document with a revised component code. Inspect the extracted content and its source references before evaluating the answer. A mistaken table row can become a convincing but incorrect graph relationship.

EdgeQuake vs LightRAG: read the cache labels

The project's published benchmark record reports the following. These are upstream measurements from separate runs, carried into the release.

The accuracy comparison uses the same corpus, questions, Mix mode, Mistral Small and mistral-embed. Its 95% confidence interval for the accuracy difference is [-0.022, +0.034], spanning zero. That does not establish equivalent retrieval quality.

In the warm run, median keyword, embedding and generation stages are each recorded as zero milliseconds. The 82 ms result therefore does not establish the time to answer a new question with fresh model calls. Repeated queries can benefit from that cache path; measure fresh questions separately.

A useful first evaluation fits in one workspace

Our recommendation is to start with a small, approved document set and questions that require named relationships. Agree what evidence a correct answer must contain before ingestion. Include a question the documents cannot answer.

• Verify the full relationship chain in the Atlas example and inspect every cited passage.
• Try the same questions with the selected graph mode and a simpler retrieval baseline.
• Separate fresh-query latency, repeated-query latency, ingestion time and model cost.
• Use a second identity to check workspace isolation, failed credentials and revoked membership.
• Change one source fact, reprocess it and check for contradictory or obsolete evidence.
• Restore the database and required secrets in a test environment, then repeat retrieval.

Use edgequake doctor to inspect configuration and database readiness, and follow explicit migration steps before serving an upgraded API. Source checks and a healthy process support that review; the document, access and recovery tests establish whether the deployment fits your work.

EdgeQuake is worth evaluating when document relationships and a PostgreSQL operating model match the problem. If your main need is sharing coding decisions across IDEs, our mcp-memory-service setup guide addresses that narrower workflow. For choosing between an owned knowledge service and an existing product, use the custom software versus off-the-shelf decision guide.