AtomicRAG: Atom-Entity Graphs for Retrieval-Augmented Generation

Yanning Hou, Duanyang Yuan, Sihang Zhou, Xiaoshu Chen, Ke Liang, Siwei Wang, Xinwang Liu, Jian HuangarXiv 2026 · arXiv

TL;DR

AtomicRAG introduces a new paradigm for Retrieval-Augmented Generation by replacing coarse text chunks and brittle knowledge graph triples with "knowledge atoms"—minimal, self-contained factual units. By organizing these atoms into an Atom-Entity Graph (AEG) and using entity-resonance propagation, it achieves superior accuracy and efficiency in complex multi-hop reasoning tasks while significantly reducing retrieval noise.

What Problem Does This Paper Address?

Current Retrieval-Augmented Generation (RAG) systems generally fall into two camps, both of which have significant flaws:

  1. Naive RAG (Chunk-based): Documents are split into fixed-length blocks. These chunks often contain "mixed topics" (irrelevant info alongside relevant info) or "fragmented evidence" (a single fact split across two chunks), leading to context redundancy and noise.
  2. GraphRAG (Triple-based): These systems extract (Subject, Predicate, Object) triples to build a Knowledge Graph. However, extracting accurate relationship labels is notoriously difficult. A single mis-typed relation or a "compressed triple" that omits nuance can break the reasoning path entirely.

The authors argue that there is a fundamental mismatch between how we store knowledge (representation) and how we find it (indexing). AtomicRAG aims to decouple these, using atoms for semantic content and a graph for reachability.

Comparison of knowledge representation and indexing across Naive RAG, GraphRAG, and AtomicRAG.

Methods

AtomicRAG operates in two main phases:

1. Offline: Atom-Entity Graph Construction

Instead of standard chunks, the system uses an LLM to extract knowledge atoms—the smallest possible independent natural language statements (e.g., "Basal cell skin cancer is caused by UV radiation"). It then builds the AEG, a heterogeneous graph featuring:

  • Nodes: Atoms and Entities.
  • Edges: Unlabeled co-occurrence links. These include Containment Edges (atom to its entities), Relevance Edges (entity to entity based on shared triples), and Synonym Edges (connecting similar entities via embeddings). By omitting textual predicate labels, the graph becomes a robust "scaffold" for navigation rather than a brittle logical map.

2. Online: Retrieval & Generation

  • Atomic Question Decomposition: Complex queries are broken down into simpler, atom-aligned sub-questions.
  • Entity-Resonance Graph Retrieval: The system uses Personalized PageRank (PPR) to propagate signals from the query entities across the AEG. This identifies atoms that are structurally well-supported by the entities mentioned in the query.
  • Atomic Sieve: A final LLM-based filtering step removes any remaining redundant or irrelevant atoms, ensuring the generator receives only high-utility evidence.
The AtomicRAG pipeline, showing offline graph construction and the online retrieval/generation flow.

Datasets

The authors evaluated AtomicRAG against five public benchmarks:

  • Graph-Bench (Medical & Novel): Specifically designed to test graph-based retrieval across different domains.
  • Multi-hop QA: HotpotQA, 2WikiMultiHopQA, and MuSiQue, which require connecting multiple pieces of evidence to find an answer.

Key Insights and Ideas

  • Granularity Alignment: The "aha moment" is that retrieval works best when the size of the stored unit (atom) matches the size of the query's information need (sub-question). This reduces "semantic drift" where the retriever gets distracted by irrelevant text within a large chunk.
  • Robustness through Simplicity: By treating edges as simple indicators of relatedness rather than specific relationships (like "is_a" or "caused_by"), AtomicRAG avoids the cascading failures caused by relation extraction errors in traditional GraphRAG.
  • Purity over Volume: Atomic units have higher "purity"—a higher ratio of relevant to irrelevant information. This makes the LLM's job much easier during the final generation phase.

Key Results

AtomicRAG consistently outperformed strong baselines, including Microsoft’s GraphRAG and HippoRAG:

  • Accuracy: On Graph-Bench Medical, it achieved a 73.1% accuracy, an 8.3-point improvement over the best baseline.
  • Efficiency: It is significantly faster than other graph-based methods. Retrieval latency was just 0.79 seconds per query, compared to 4.5s for HippoRAG2 and nearly 14s for LightRAG.
  • Budget Efficiency: As shown in Figure 5, AtomicRAG reaches high accuracy even with very small context windows (e.g., 512 tokens), whereas other methods require much more text to achieve similar results.
Accuracy of various RAG methods under limited context lengths.

Limitations and Future Work

  • Extraction Dependency: The system relies heavily on the initial LLM call to correctly "atomize" the corpus and identify entities. Errors at this stage can seep into the graph structure.
  • Semantic Loss: By discarding relation labels on edges, the system might struggle with tasks requiring extremely fine-grained temporal or causal logic (e.g., "Did X happen before or after Y?").
  • Dynamic Updating: While the paper focuses on static benchmarks, the authors note that scaling to frequently updated corpora (where facts change or are deleted) will require further engineering for incremental graph updates.

Summary updated

Abstract

Recent GraphRAG methods integrate graph structures into text indexing and retrieval, using knowledge graph triples to connect text chunks, thereby improving retrieval coverage and precision. However, we observe that treating text chunks as the basic unit of knowledge representation rigidly groups multiple atomic facts together, limiting the flexibility and adaptability needed to support diverse retrieval scenarios. Additionally, triple-based entity linking is sensitive to relation-extraction errors, which can lead to missing or incorrect reasoning paths and ultimately hurt retrieval accuracy. To address these issues, we propose the Atom-Entity Graph, a more precise and reliable architecture for knowledge representation and indexing. In our approach, knowledge is stored as knowledge atoms, namely individual, self-contained units of factual information, rather than coarse-grained text chunks. This allows knowledge elements to be flexibly reassembled without mutual interference, thereby enabling seamless alignment with diverse query perspectives. Edges between entities simply indicate whether a relationship exists. By combining personalized PageRank with relevance-based filtering, we maintain accurate entity connections and improve the reliability of reasoning. Theoretical analysis and experiments on five public benchmarks show that the proposed AtomicRAG algorithm outperforms strong RAG baselines in retrieval accuracy and reasoning robustness. Code: https://github.com/7HHHHH/AtomicRAG.
BibTeX
@misc{hou2026atomicrag,
  author = {Yanning Hou and Duanyang Yuan and Sihang Zhou and Xiaoshu Chen and Ke Liang and Siwei Wang and Xinwang Liu and Jian Huang},
  title = {{AtomicRAG: Atom-Entity Graphs for Retrieval-Augmented Generation}},
  year = {2026},
  eprint = {2604.20844},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2604.20844},
}

Loading related content...

Figure