raphaelmansuy

EdgeQuake: Build LightRAG Knowledge Graphs in Rust

EdgeQuake implements the LightRAG algorithm in Rust, turning documents into knowledge graphs for answers grounded in sources. It combines graph traversal and vector search, using PostgreSQL for storage and supporting cloud or local LLMs.

ActiveRustApache-2.0RAGDatabaseKnowledge Graph
Stars
2.3k
Forks
275
Last commit
4 days ago
Contributors
14
Releases, 12 months
100+

Our take

Activeregular commits and releases

Health score

60/100

How it is scored
Activity
90
Community
34
Issues
62
Pull requests
55
  • Releases more often than 93% of the projects we track
  • Merges more pull requests than 76% of the projects we track

EdgeQuake is an actively maintained, broad Graph-RAG implementation with production-oriented features, but its contributor base is highly concentrated.

Good fit if

  • You need LightRAG-style retrieval that combines a knowledge graph with vector search and want a Rust service with a web UI and API.
  • PostgreSQL is an appropriate datastore for your deployment, and you value keeping graph and vector storage in that system.
  • You want cloud or local model options and can work with the project's Docker-based quickstart.

Look elsewhere if

  • You need a retrieval system without graph extraction, graph storage, or the associated PostgreSQL setup.
  • You require a project with development effort distributed across contributors. Most contributions currently come from one person.
  • Your use case depends on the measured benchmark showing a clear accuracy lead over LightRAG. The project reports comparable accuracy, not a decisive advantage.
All health signals
Last commit2026-11-06 (4 days ago)
Commits, last 90 days100+
Releases, last 12 months100+ (latest v0.40.12, 2026-11-09)
Contributors14 (top contributor: 88% of commits)
Issues closed, last 90 days6+ (typically closed in 2 days)
Pull requests merged, last 90 days56 (typically merged in 1 day)
Project age11 months

Checked on 2026-11-11 with the GitHub API.

Overview

EdgeQuake is a Rust implementation of the LightRAG algorithm, which was introduced by Zirui Guo, Lianghao Xia, Yanhua Yu, Tu Ao, and Chao Huang. It turns documents into entities and relationships, then combines knowledge-graph traversal with vector search to answer questions that depend on connections across documents, with sources.

The project is framed as a deployable Graph-RAG service: one binary, PostgreSQL, and a choice of cloud or locally hosted LLMs. It includes a web UI and REST API, with SDKs and an MCP server for integration. This suits teams that need graph-based retrieval without operating a separate graph database.

Key Features

  • Extracts entities and relationships from document chunks to build a knowledge graph.
  • Combines graph traversal and vector search, with query modes for local, global, hybrid, and other retrieval strategies.
  • Uses PostgreSQL with pgvector and Apache AGE for vector and graph storage.
  • Supports cloud and local LLM providers, with separate model roles for tasks such as extraction, embedding, and querying.
  • Provides a web UI, REST API with streaming, and batch ingestion.
  • Includes SDKs, an MCP server, and integrations such as OpenWebUI and LangChain.
  • Offers multi-tenant workspace isolation, authentication, audit logging, and encrypted provider keys.

Use Cases

  • Research teams can search across a collection of papers for themes and connections that span many documents.
  • Organizations can query relationships across contracts, products, or other internal documents rather than relying only on similar text chunks.
  • Developers can add source-grounded Graph-RAG to an application through the REST API, SDKs, or MCP server.
  • Teams with privacy requirements can run the service locally and use local LLM providers, provided they can supply the required infrastructure.

What you need

Detected in the repository

  • Rust (main language on GitHub)
  • A test suite and automated checks on GitHub Actions

License in plain words

Apache-2.0permissive

  • Commercial use: yes
  • Modify and redistribute: yes
  • You must keep: the license, the NOTICE file and a note of your changes
  • Share your changes: no
  • Includes an explicit patent grant from the contributors:

A summary, not legal advice: the LICENSE file is what applies.

Getting Started

The quickstart uses Docker and opens the UI at http://localhost:3000:

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

See the README for provider setup, deployment options, and API examples.

Alternatives

  • utopia: Utopia focuses on ontology-guided, bitemporal knowledge management and human review, while EdgeQuake implements LightRAG for source-grounded answers.
  • KAG: KAG targets professional-domain, multi-step Q&A with modeled domain knowledge and the OpenSPG engine, rather than LightRAG in Rust.
  • graphrag: Microsoft GraphRAG is a Python indexing pipeline for graph-based retrieval, while EdgeQuake is a Rust LightRAG system using PostgreSQL.
ProjectLanguageLicenseStarsStatus
EdgeQuakeRustApache-2.02.3kActive
utopiaRustApache-2.08kNew
KAGPythonApache-2.09.1kQuiet
graphragPythonMIT36.4kActive

Considerations

The quickstart requires Docker, and deployments use PostgreSQL with pgvector and Apache AGE. Local inference may require downloading model files, while cloud providers require credentials. The project is active, with regular commits and releases, and reported issue and pull-request turnaround is short; however, most of the code comes from one person, which is a maintenance concentration risk. The README's benchmark reports similar accuracy to LightRAG, with different results for latency and evidence recall, so evaluate it on your own workload before relying on performance claims. The project is licensed under Apache-2.0; review the license terms when incorporating or distributing it.

Found this useful?

Share it with someone who would like EdgeQuake.