█

AI/TLDR

Buy me a coffee
Buy me a coffee

EdgeQuake

A Rust implementation of the LightRAG algorithm that turns documents into a knowledge graph and answers questions over it through a REST API and web UI

RAG Frameworks & PlatformsOpen source
Latest
v0.28.5
Updated
30 Sep 2026
Language
Rust
License
Apache-2.0

What's new

v0.28.530 Sep 2026

Release v0.28.5 publishes multi-arch (amd64 and arm64) API and frontend images to GHCR, installable through the Docker quickstart or `make stack`.

IN SHORT

What is EdgeQuake?

EdgeQuake is an open-source Graph-RAG framework written in Rust that implements the LightRAG algorithm. It sits in the RAG Frameworks & Platforms category of the Retrieval & Knowledge (RAG) tools and is open-source, written in Rust and licensed Apache-2.0. To get started: run the quickstart wizard.

Updated Markdown version ↗

Overview

The EdgeQuake web UI on its Knowledge Graph page: a sidebar with Dashboard, Documents, Pipeline, Query and Workspace, a sortable list of extracted entities tagged by type such as product, person and organization, and a large interactive graph of connected entity nodes.
The knowledge graph EdgeQuake builds from ingested documents, browsable by entity in the web UI.EdgeQuake README ↗

EdgeQuake is an open-source Graph-RAG framework written in Rust that implements the LightRAG algorithm. Its README makes the case plainly: retrieving chunks by vector similarity alone works for keyword lookups but struggles with multi-hop reasoning, thematic questions and questions about relationships, because vectors capture similarity but lose structure. EdgeQuake instead decomposes each document into a knowledge graph of entities and relationships, and at query time traverses both the vector space and the graph before handing context to an LLM for an answer with sources.

It ships as a full stack rather than a library: an Axum REST API (OpenAPI 3.0, SSE streaming, batch ingestion, health checks), a React 19 web UI with drag-and-drop upload and an interactive Sigma.js graph view, and PostgreSQL 16/17/18 with pgvector for embeddings and Apache AGE for the graph. The backend is split into 11 Rust crates covering the pipeline, query engine, PDF handling, auth, audit, task queue, rate limiting and observability, and LLM access goes through the separate edgequake-llm crate, which supports OpenAI, Anthropic, Gemini, Mistral, Ollama, LM Studio, xAI, Azure and Vertex AI.

The project is aimed at teams that want to run graph-based retrieval as a service: it has multi-tenant workspaces with fail-closed isolation, built-in authentication and audit logging, multi-arch Docker images on GHCR, an MCP server so agents can call it, and client SDKs for Python, TypeScript, Rust and several other languages. The maintainers publish their own benchmark against LightRAG and describe the accuracy result as a statistical tie, explicitly not a win.

What it does

  • LLM-powered entity and relationship extraction with a second gleaning pass, Louvain community detection for thematic queries, custom entity types with domain presets, and injectable glossaries, acronyms and synonyms
  • Six query modes — naive, local, global, hybrid (the default), mix and bypass — with a Personalized PageRank graph walk for expanding entity neighbourhoods
  • PDF pipeline with fast pdfium text extraction by default and an optional vision mode in which GPT-4o, Claude or Gemini read each page as an image to recover tables and multi-column layouts, falling back to text on failure
  • REST API with OpenAPI 3.0 docs, Swagger UI, SSE streaming and batch ingestion, plus a React web UI for upload, querying and interactive graph exploration
  • PostgreSQL storage (pgvector plus Apache AGE), multi-tenant workspaces, authentication and audit logging, and multi-arch Docker images for linux/amd64 and linux/arm64
  • MCP server integration and SDKs for Python, TypeScript, Rust, Go, Java, Kotlin, C#, PHP, Ruby and Swift

Getting started

The README's quick start needs only Docker: a wizard picks an LLM provider (OpenAI or Ollama) and a model, then starts the API, web UI and PostgreSQL together. The quickstart runs with an open API and no login, so it is for local use.

Run the quickstart wizard

The script guides you through provider and model choice and starts the full stack. The web UI opens at http://localhost:3000 and the REST API at http://localhost:8080 (Swagger at /swagger-ui).

bashbash
curl -fsSL https://raw.githubusercontent.com/raphaelmansuy/edgequake/edgequake-main/quickstart.sh | sh

Or start it headless with Docker Compose

Download the quickstart compose file and pass the provider through environment variables — the README shows OpenAI and a local Ollama.

bashbash
curl -fsSL https://raw.githubusercontent.com/raphaelmansuy/edgequake/edgequake-main/docker-compose.quickstart.yml \
  -o docker-compose.quickstart.yml

# OpenAI
EDGEQUAKE_LLM_PROVIDER=openai \
  OPENAI_API_KEY=sk-... \
  docker compose -f docker-compose.quickstart.yml up -d

# Ollama (on host)
EDGEQUAKE_LLM_PROVIDER=ollama \
  EDGEQUAKE_LLM_MODEL=gemma4:e4b \
  EDGEQUAKE_EMBEDDING_PROVIDER=ollama \
  OLLAMA_EMBEDDING_MODEL=embeddinggemma \
  docker compose -f docker-compose.quickstart.yml up -d

Check that the API is healthy

bashbash
curl -s http://localhost:8080/health | python3 -m json.tool

Upload a document

PDF, TXT and Markdown files are accepted. You can also drag and drop files into the web UI.

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

Query the knowledge graph

Pick a query mode per request; hybrid is the default and balances graph and vector retrieval.

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

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

When to use it

  • Answer multi-hop and relationship questions over a document collection, where plain vector search returns related chunks but misses how entities connect
  • Ingest PDFs with complex tables or multi-column layouts using the vision mode, then query them through one REST API
  • Run a self-hosted, multi-tenant Graph-RAG service on PostgreSQL with login, audit logs and per-workspace isolation
  • Give AI agents graph-backed retrieval over your documents through EdgeQuake's MCP server or one of its client SDKs

How EdgeQuake compares

EdgeQuake alongside other open-source rag frameworks & platforms tools AI/TLDR tracks, ranked by GitHub stars.

ToolStarsWhat it does
Dify★ 162kAn open-source platform with a visual workflow builder for creating LLM and RAG applications without writing much code.
graphify★ 151kTurns a folder of code, docs, PDFs and images into a local knowledge graph with tree-sitter AST parsing and Leiden communities — queryable by agents over MCP, no vector store.
RAGFlow★ 94.4kA RAG engine built around deep document understanding that turns complex files into a grounded, citation-backed question-answering layer.
Context7★ 65.1kContext7 pulls current, version-specific documentation and code examples for any library and feeds them into your LLM, available as a CLI skill or an MCP server.
Pathway★ 62kA Python framework with a Rust streaming engine that keeps ETL, real-time analytics and RAG pipelines continuously up to date as source data changes.
LightRAG★ 40.8kA graph-based RAG system that builds an entity-and-relationship knowledge graph for fast retrieval and easy incremental updates.
PageIndex★ 40.5kPageIndex turns long PDFs into a table-of-contents tree and uses LLM reasoning to retrieve relevant sections, with no vector database and no chunking.
EdgeQuake★ 2.3kA Rust implementation of the LightRAG algorithm that turns documents into a knowledge graph and answers questions over it through a REST API and web UI