Graph-RAG.
Built to ship.

EdgeQuake reads your PDFs and text, builds a knowledge graph in PostgreSQL, and answers questions with sources, on any LLM, cloud or fully local.

Get started Try the demo 2,277 stars

licensed: Apache-2.0
GitHub stars: 2,277
current release: v0.36.0
retrieval modes: 6

EdgeQuake knowledge graph: 13,200 entities and 12,023 relationships extracted from uploaded documents

The public demo at demo.edgequake.com is a real graph you can open and explore, with naive, local, global, hybrid, mix, bypass retrieval over one Postgres store.

Similarity search loses the thread

Vector search finds nearby text. It struggles when the answer lives in relationships, spans documents, or hides inside a messy PDF, and when production needs clear workspace boundaries.

Relationships get lost

Ask how service A depends on team B's contracts and vector search returns unrelated paragraphs. It holds text proximity, not edges, ownership, or causality between entities.

It slows down at scale

A 10,000-document import that was fine at 100 docs takes hours in Python. Extraction, embedding, and re-ingestion compound as the corpus grows — before a single query runs.

One retrieval mode fits nothing

Some questions need a precise paragraph, others a cross-document overview. Forcing every query through the same path guarantees a wrong answer for one of them.

Tenancy is an afterthought

Sharing one index across projects quietly bleeds context between workspaces. Adding isolation later means rebuilding the index from scratch.

PDFs break the pipeline

Multi-column layouts, embedded figures, and scanned pages defeat naive extraction. The answer you need ends up locked in a table that became garbage text on import.

Cloud-only costs add up

Every retrieval that needs a remote embedding API compounds cost at scale — and when the provider rate-limits or goes down, your search degrades with it.

Built for real Graph-RAG work

Ingest once, keep structure and lineage, then answer with the retrieval mode that fits the question — on a stack you can run and upgrade.

A knowledge graph on Postgres
Entities and relationships live in ordinary PostgreSQL tables with pgvector. Apache AGE is optional — product images run without it.
Read in docs
Members, invites, and magic links
Invite teammates, set roles, suspend accounts, and issue one-time sign-in or reset links — without wiring SMTP first.
Read in docs
SSO and workspace isolation
OIDC and Keycloak sign-in plus Postgres row-level security keep tenants and workspaces separated across the UI, API, and MCP.
Read in docs
MCP for AI agents
Assistants can search, ingest, upload, delete, poll jobs, download documents, and fetch graph images through MCP.
Read in docs
PDF vision and manuscripts
Turn hard PDFs into usable markdown — tables, layouts, and scanned or handwritten pages through a dedicated manuscript path.
Read in docs
Any LLM, encrypted connections
OpenAI, Anthropic, Mistral, Gemini, or Ollama and LM Studio. Save connections with encrypted keys; the wizard finds local servers.
Read in docs

Plus explicit edgequake migrate upgrades, hybrid cloud LLM with local embeddings, and side-by-side PDF citations. See what’s new.

Your documents, as a living graph

This is the public demo at demo.edgequake.com, with entities and relationships pulled from real PDFs that you can explore right in the browser.

EdgeQuake knowledge graph: a dense network of color-coded entities connected by relationships

15
documents: 13,200
entities: 12,023
relationships: 591
chunks

EdgeQuake dashboard showing document, entity, relationship, and chunk counts — The dashboard keeps live counts for the whole corpus.

EdgeQuake query console with six retrieval modes — Query returns answers with the sources they came from.

From files to answers with sources

Ingest once. Keep structure and lineage in PostgreSQL with pgvector and graph tables. Serve six retrieval modes from the same store.

Documents
Ingestion Pipeline
PostgreSQL Storage
Query Engine
REST API

LLM ProviderClients

Ingest once, keep structure and lineage in Postgres, then serve multiple retrieval modes from a storage layer built for production rather than a prototype glue stack.

Honest numbers

Same GraphRAG-Bench medical-mid quality as LightRAG Python, productionised as a Rust binary with Postgres, auth, MCP, and explicit upgrades. When the confidence interval includes zero, we call it a tie rather than a win.

0.824

EdgeQuake Acc, medical-mid

0.802

LightRAG Acc, same pack

Tie

95% CI includes zero

82 ms

warm query p50, cached

Metric	EdgeQuake	LightRAG	Verdict
Answer accuracy (Acc)	0.8240	0.8016	Statistical tie
Evidence recall	0.923	0.969	LightRAG ahead
Warm query p50	82 ms	993 ms	EdgeQuake faster when cached

Pack: medical-mid, n=200, on the v0.36.0 cut. Methodology:EQ vs LightRAG Acc.

Historical ingestion micro-bench (EdgeQuake 0.7.0)

An older directional comparison on 100 Wikipedia articles (~50k tokens), Apple M3 Pro: EdgeQuake ingestion throughput ran roughly 10× LightRAG Python on that hardware and set. It is not a substitute for Acc or your own workload.

Prefer the Acc table above for quality claims.

Up and running in minutes

One Docker command starts the full stack. Or call the REST API, or follow the web UI after the wizard detects your local models.

One script pulls the stack. No git clone, Rust, or Node.js required.

# Needs Docker only
curl -fsSL https://raw.githubusercontent.com/raphaelmansuy/edgequake/edgequake-main/quickstart.sh | sh

# Pin this release:
# EDGEQUAKE_VERSION=0.36.0 sh quickstart.sh

# Then open http://localhost:3000
# API / Swagger → http://localhost:8080 · /swagger-ui

# Headless / CI examples:
# quickstart.sh --yes --provider ollama
# EDGEQUAKE_LLM_PROVIDER=openai OPENAI_API_KEY=sk-... quickstart.sh --yes

Upload a PDF, then ask a hybrid query.

# Upload a document
curl -X POST http://localhost:8080/api/v1/documents/upload \
  -F "file=@your-document.pdf"

# Query the knowledge graph
curl -X POST http://localhost:8080/api/v1/query \
  -H "Content-Type: application/json" \
  -d '{"query": "What are the main concepts?", "mode": "hybrid"}'

After quickstart, walk the UI — or follow the picture tour with screenshots.

# 1. Open http://localhost:3000
# 2. Finish the connection wizard (Ollama / cloud key)
# 3. Drop a PDF on Documents
# 4. Ask a question on Query (try hybrid)
# 5. Open Knowledge Graph to see entities

# Picture tour with screenshots:
# https://edgequake.com/tutorial/

One product, clear surfaces

Run the full stack from Docker, or embed the Rust crates. Everything below ships as v0.36.0.

Web UI

Documents, query, knowledge graph, members, connections, and settings in one app.

REST + OpenAPI

Ingest, query, stream, and manage workspaces. Swagger at /swagger-ui.

MCP

Search, ingest, upload, delete, poll tasks, download docs, and graph images for agents.

GHCR images

api, frontend, postgres (pg16/17/18), and keycloak — multi-arch amd64 + arm64.

Rust workspace crates

edgequake-core

Pipeline orchestration, workspaces, and top-level APIs.

edgequake-api

HTTP service: ingest, query, health, streaming, auth.

edgequake-storage

KV, vector, and graph storage on PostgreSQL + pgvector.

edgequake-pipeline

Chunking, extraction, relationships, and graph build.

edgequake-query

naive, local, global, hybrid, mix, and bypass retrieval.

edgequake-llm

Provider adapters: OpenAI, Ollama, Anthropic, mocks, and more.

edgequake-pdf

PDF to markdown, vision layouts, manuscript pages.

edgequake-auth

Sessions, SSO (OIDC), members, invitations, magic links.

Taking Graph-RAG into production?

Internal platforms, customer copilots, and regulated installs that need more than a demo stack.

SSO, members, and audit

OIDC and Keycloak, invitations, role guards, and audit trails for teams that need real access boundaries.

Priority support

Architecture reviews, rollout plans, troubleshooting, and production issues with the team that builds EdgeQuake.

Your models, your network

Private LLMs, encrypted connections, on-prem Docker or Kubernetes, and explicit migrations — no forced cloud path.

Talk to the team

Apache-2.0 licensed, so there is no lock-in
Runs on-premise, so your data stays on your network
Works without any cloud embedding dependency

Graph-RAG.Built to ship.