Knowledge graph framework for RAG using semantic aggregation and hierarchical retrieval

https://t.co/5Ebpd0rmIz https://t.co/9Q4drMArs5

KnowledgeXLab/LeanRAG

Source: https://github.com/KnowledgeXLab/LeanRAG

LeanRAG: Knowledge-Graph-Based Generation with Semantic Aggregation and Hierarchical Retrieval

🎉 This paper has been accepted by AAAI-26! 🎉

LeanRAG is an efficient, open-source framework for Retrieval-Augmented Generation, leveraging knowledge graph structures with semantic aggregation and hierarchical retrieval to generate context-aware, concise, and high-fidelity responses.

✨ Features

• Semantic Aggregation: Clusters entities into semantically coherent summaries and constructs explicit relations to form a navigable aggregation-level knowledge network.
• Hierarchical, Structure-Guided Retrieval: Initiates retrieval from fine-grained entities and traverses up the knowledge graph to gather rich, highly relevant evidence efficiently.
• Reduced Redundancy: Optimizes retrieval paths to significantly reduce redundant information—LeanRAG achieves ~46% lower retrieval redundancy compared to flat retrieval baselines (based on benchmark evaluations).
• Benchmark Performance: Demonstrates superior performance across multiple QA benchmarks with improved response quality and retrieval efficiency.

🏛️ Architecture Overview

LeanRAG’s processing pipeline follows these core stages:

1. Semantic Aggregation

   • Group low-level entities into clusters; generate summary nodes and build adjacency relations among them for efficient navigation.

2. Knowledge Graph Construction

   • Construct a multi-layer graph where nodes represent entities and aggregated summaries, with explicit inter-node relations for graph-based traversal.

3. Query Processing & Hierarchical Retrieval

   • Anchor queries at the most relevant detailed entities (“bottom-up”), then traverse upward through the semantic aggregation graph to collect evidence spans.

4. Redundancy-Aware Synthesis

   • Streamline retrieval paths and avoid overlapping content, ensuring concise evidence aggregation before generating responses.

5. Generation

   • Use retrieved, well-structured evidence as input to an LLM to produce coherent, accurate, and contextually grounded answers.

🚀 Getting Started

Prerequisites

• Python 3.10+
• Conda for environment management

Installation

1. Clone the repository:

   git clone https://github.com/RaZzzyz/LeanRAG.git
   cd LeanRAG
   

2. Create a virtual environment:

   conda install -n leanrag python=3.11
   conda activate leanrag
   

3. Install the required dependencies:

   pip install -r requirements.txt
   

💻 Usage Workflow

Here’s a typical pipeline flow:

Step 1: Document Chunking

In file_chunk.py, split the document into chunks:

• Chunk size: 1024
• Sliding step: 128 (i.e., use a sliding window with step 128)

Each dictionary in the resulting chunk file contains two attributes:

• hash_code: hash calculated from the text content for traceability
• text: the chunk text content

Step 2: Extract Triples and Entity Descriptions

Two knowledge graph extraction methods are currently provided:

Method 1: CommonKG

Based on Wikipedia entities. First, define a head entity list, then extract triples from the document.

Usage:

1. Edit the configuration file:
   CommonKG/config/create_kg_conf_test.yaml
   Fill in the model’s url and name, and the path to the chunk file.
2. Run extraction:

   python CommonKG/create_kg.py
   

   The extraction result will be saved in output_dir.
3. Process 6-tuples with descriptions:

   python CommonKG/deal_triple.py
   

   Outputs include:
   • entity.jsonl
   • relation.jsonl

Method 2: GraphRAG

Relies on LLM capability to perform few-shot extraction with given examples in the prompt.

Usage:

1. Edit GraphExtraction/chunk.py to fill in url and model. The chunk_file is the same as in CommonKG, generated from Step 1.
2. Deduplicate extraction results:

   python GraphExtraction/deal_triple.py
   

   Outputs include:
   • entity.jsonl
   • relation.jsonl

Step 3: Build the Graph

python build_graph.py

• Cluster extracted entity and relation descriptions and generate relationships.

• Construct a tree-structured knowledge graph, supporting retrieval and Q&A.

Step 3: Retrieval

python query_graph.py

1. Select the correct chunks_file.

2. Query the graph for Top-K entities based on query.

3. Generate paths between nodes according to the tree structure.

4. Return same-level relationships and aggregated entity information along the paths to the LLM for final answer generation.

📊 Results & Benchmarks

On four challenging QA benchmarks spanning diverse domains, LeanRAG consistently delivers:

Score

Mix

CS

Legal

Agriculture

Winrate

NaiveRAG vs LeanRAG

GraphRAG vs LeanRAG

LightRAG vs LeanRAG

FastGraphRAG vs LeanRAG

KAG vs LeanRAG

HiRAG vs LeanRAG

Tokens Consumption

Acknowledgement

We gratefully acknowledge the use of the following open-source projects in our work:

• nano-graphrag: a simple, easy-to-hack GraphRAG implementation

• HiRAG: a novel hierarchy entity aggregation and optimized retrieval RAG method

📄 Citation

If you find LeanRAG useful, please cite our paper:

@inproceedings{zhang2026leanrag,
  title={Leanrag: Knowledge-graph-based generation with semantic aggregation and hierarchical retrieval},
  author={Zhang, Yaoze and Wu, Rong and Cai, Pinlong and Wang, Xiaoman and Yan, Guohang and Mao, Song and Wang, Ding and Shi, Botian},
  booktitle={Proceedings of the AAAI Conference on Artificial Intelligence},
  volume={40},
  number={41},
  pages={34862--34869},
  year={2026}
}

Star History