# 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

- Category: Retrieval & Knowledge (RAG) / RAG Frameworks & Platforms
- Language: Rust
- Licence: Apache-2.0
- Repository: https://github.com/raphaelmansuy/edgequake
- Website: https://edgequake.com
- Canonical page: https://ai-tldr.dev/tools/edgequake/
- Updated: 2026-09-30

## In short

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.

## Overview

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.

1. 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).

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

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

```bash
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
```

3. Check that the API is healthy

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

4. Upload a document

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

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

5. Query the knowledge graph

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

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

## 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

## Version history

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