Apache 2.0 1,498 GitHub stars 1000+ docs/min 6 Retrieval Modes Rust-native

Graph-RAG. Built to Ship.

Turn PDFs, markdown, and raw text into lineage-aware knowledge graphs. Query with local, global, hybrid, naive, mix, and graph-aware retrieval. Run the full stack in Rust on PostgreSQL.

Built for teams that want Graph-RAG quality without Python pipeline fragility, cloud lock-in, or opaque retrieval behavior.

Read the Docs Explore the Demo Path GitHub · 1,498 stars

Start with installation Browse the crate ecosystem See enterprise deployment paths

Traditional RAG Breaks the Thread

Similarity search alone is not enough when users need grounded answers, entity relationships, source traceability, and predictable operations.

Lost Relationships

You ask "How does service A depend on team B's contracts?" and get back unrelated paragraphs. Vector search holds text proximity — not edges, ownership, or causality between entities.

Slow at Scale

A 10,000-document import that works fine at 100 docs takes hours in Python. Extraction, embedding, and re-ingestion compound as your corpus grows — before a query is ever run.

Single Query Mode

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

No Multi-Tenancy

Sharing one index across projects silently bleeds context between workspaces. Adding isolation after the fact means rebuilding the index from scratch.

PDF Pain

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

Cloud-Only Cost

Every retrieval call requiring 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

EdgeQuake combines ingestion, extraction, storage, and retrieval into a stack that is easier to reason about, easier to operate, and easier to extend.

Knowledge Graph Engine

Extract entities, relationships, and lineage into a graph-backed retrieval layer built on PostgreSQL and Apache AGE.

10x Faster

Rust-native ingestion pipeline built for throughput, low memory pressure, and repeatable performance on large document sets — 10x vs LightRAG Python on the same hardware and dataset.

6 Query Modes

Choose the retrieval strategy that fits the question: local, global, hybrid, naive, mix, or graph-aware.

Multi-Tenant

Run multiple teams, projects, or clients on one deployment with workspace boundaries designed into the core architecture.

PDF Vision Pipeline

Convert difficult PDFs into usable markdown with built-in vision support for tables, figures, and layout-sensitive extraction.

MCP Integration

Expose your graph and document context through MCP so assistants and internal tools can work against the same retrieval system.

From Source Files to Grounded Answers

Documents move through ingestion, extraction, graph storage, retrieval, and API delivery in one coherent pipeline.

Documents
Ingestion Pipeline
PostgreSQL Storage
Query Engine
REST API

LLM Provider Clients

The key idea is simple: ingest source material once, preserve structure and lineage, then serve multiple retrieval strategies from a storage layer designed for production rather than prototypes.

Built for Performance

Designed for ingestion-heavy workloads where throughput, latency, and memory all matter at the same time.

10x

Faster ingestion

300MB

Memory per core

<100ms

Query latency (p95)

Query modes

Use these figures as directional reference points for the architecture, not as a substitute for workload-specific testing.

Benchmark methodology ▾

Hardware: Apple M3 Pro · 12-core CPU · 36 GB unified memory

Dataset: 100 Wikipedia articles (~50,000 tokens total)

What is measured: Wall-clock ingestion time — extract + embed + store

Versions: EdgeQuake 0.7.0 · LightRAG 1.3.0 · GraphRAG 1.0.0 (Semantic Kernel)

Embedding model: text-embedding-3-small via Ollama (same model for all frameworks)

Results are directional. Run your own workload-specific benchmark before making production decisions.

Throughput (docs/min)

EdgeQuake 1000

LightRAG 100

GraphRAG 50

Traditional RAG 200

Memory Usage

EdgeQuake 300MB

LightRAG 3GB

GraphRAG 1.5GB

Up and Running in Minutes

Start where you are: embed the Rust crate, launch the full stack with Docker, or hit the API directly.

Create an EdgeQuake client, ingest text, and run a graph-aware query.

Rust

use edgequake::EdgeQuake;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let eq = EdgeQuake::new("postgres://localhost/edgequake").await?;
    let document = "GraphRAG combines vector search with knowledge graphs to deliver more accurate and contextual retrieval.";

    // Ingest documents
    eq.insert(document).await?;

    // Query with different modes
    let result = eq.query("How does GraphRAG work?").await?;
    println!("{}", result);

    Ok(())
}

Download the Compose file, launch the services, and verify API health.

Docker

# Start EdgeQuake with Docker Compose
curl -O https://raw.githubusercontent.com/raphaelmansuy/edgequake/edgequake-main/docker-compose.yml

# Launch all services
docker compose up -d

# Check health
curl http://localhost:8080/health

Post a document, then send a retrieval request to the query endpoint.

REST API

# Insert a document
curl -X POST http://localhost:8080/api/v1/documents \
  -H "Content-Type: application/json" \
  -d '{"content": "EdgeQuake is a Graph-RAG framework."}'

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

Modular by Design

8 focused crates. Adopt the whole platform or pull in the pieces you need for your own retrieval stack.

edgequake-core

v0.7.0

Coordinates the pipeline, workspace lifecycle, and top-level APIs used to assemble the full system.

edgequake-api

v0.7.0

Exposes ingestion, query, health, and streaming endpoints for applications that need a service boundary.

edgequake-storage

v0.7.0

Implements unified key-value, vector, and graph storage on top of PostgreSQL and Apache AGE.

edgequake-pipeline

v0.7.0

Handles chunking, extraction, relationship mapping, normalization, and the work required to build graph context from source files.

edgequake-query

v0.7.0

Contains the retrieval engine behind local, global, hybrid, naive, mix, and graph-aware querying.

edgequake-llm

v0.7.0

Abstracts LLM providers so teams can move between OpenAI, Ollama, LM Studio, and mocks without rewriting the stack.

edgequake-pdf

v0.7.0

Turns PDFs into markdown and structured extraction inputs, including layout-heavy documents and vision-assisted flows.

edgequake-graph

v0.7.0

Provides graph algorithms, traversal, community detection, and entity resolution primitives for graph-aware retrieval.

Taking Graph-RAG Into Production?

EdgeQuake can support internal platforms, customer-facing copilots, and regulated deployments that need more than a demo stack.

Enterprise Security

Support for regulated environments that need stronger auditability, access boundaries, and deployment control.

Priority Support

Work directly with the team on architecture reviews, rollout plans, troubleshooting, and production issues.

Custom Integrations

Integrate private models, internal systems, and custom deployment patterns without forcing your workflow into a template.

Talk to the Team

Apache 2.0 — no license lock-in On-premise deployment — your data stays on your network No cloud embedding dependency required