Skip to main content
EdgeQuake
Apache 2.0 1,487 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,487 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

Vector search breaks context into isolated chunks, so answers miss the entity relationships, dependencies, and provenance users actually care about.

Slow at Scale

Pipelines that feel fine in demos become slow and brittle on real corpora, where ingestion, extraction, and reprocessing all compound latency.

Single Query Mode

Real questions are not all the same. Some need local evidence, others need global context, and many need both in the same retrieval flow.

No Multi-Tenancy

Once multiple teams or clients share the same system, weak workspace isolation turns into operational risk and trust issues.

PDF Pain

PDFs still break many RAG pipelines, especially when tables, figures, layout structure, and scanned pages matter to the final answer.

Cloud-Only Cost

If the stack only works with one hosted provider, experimentation gets expensive and production cost becomes hard to control.

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

Use a Rust-native ingestion pipeline designed for throughput, low memory pressure, and repeatable performance on large document sets.

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)
6
Query modes

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

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
src/main.rs
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(())
}

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.3.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