LinearRAG: Linear Graph Retrieval Augmented Generation on Large-scale Corpora

## Abstract

Abstract Retrieval-Augmented Generation (RAG) is widely used to mitigate hallucinations of Large Language Models (LLMs) by leveraging external knowledge. While effective for simple queries, traditional RAG systems struggle with large-scale, unstructured corpora where information is fragmented. Recent advances incorporate knowledge graphs to capture relational structures, enabling more comprehensive retrieval for complex, multi-hop reasoning tasks. However, existing graph-based RAG (GraphRAG) methods rely on unstable and costly relation extraction for graph construction, often producing noisy graphs with incorrect or inconsistent relations that degrade retrieval quality. In this paper, we revisit the pipeline of existing GraphRAG systems and propose Linear Graph-based R etrieval- A ugmented G eneration ( LinearRAG ), an efficient framework that enables reliable graph construction and precise passage retrieval. Specifically, LinearRAG constructs a relation-free hierarchical graph, termed Tri-Graph, using only lightweight entity extraction and semantic linking, avoiding unstable relation modeling. This new paradigm of graph construction scales linearly with corpus size and incurs no extra token consumption, providing an economical and reliable indexing of the original passages. For retrieval, LinearRAG adopts a two-stage strategy: (i) relevant entity activation via local semantic bridging, followed by (ii) passage retrieval through global importance aggregation. Extensive experiments on four datasets demonstrate that LinearRAG significantly outperforms baseline models. Our code and datasets are available at https://github.com/DEEP-PolyU/LinearRAG.git .

## 1 Introduction

Retrieval-Augmented Generation (RAG) has emerged as a promising approach to enhance Large Language Models (LLMs) by leveraging external knowledge bases (gao2023retrieval; lewis2020retrieval; zhou-etal-2025-taming; zhang2025faithfulrag). However, existing RAG systems struggle with the complexities of large-scale, unstructured corpora in real-world scenarios, where the relevant information is frequently distributed unevenly across heterogeneous documents. The context retrieved by RAG systems is often voluminous, intricate, and lacks clear organization, leading to issues of variability in accuracy and coherence  (sun2024thinkongraph; zhang2024knowgpt).
Although recent advances attempt to manage this by segmenting documents into smaller chunks for efficient indexing (borgeaud2022improving; izacard2023atlas; jiang2023active), this strategy often results in the loss of critical contextual details, impairing retrieval accuracy and reasoning capabilities for complex tasks (han2024retrieval; zhang2025survey).

To address this, Graph Retrieval-Augmented Generation (GraphRAG) (zhang2025survey; procko2024graph; xiao2025graphragbenchchallengingdomainspecificreasoning; xiang2025use) has recently emerged as a powerful paradigm that leverages external structured graphs to model the hierarchical structure of background knowledge (han2024retrieval). Specifically, early work, like RAPTOR (sarthi2024raptor) and Microsoft’s GraphRAG (edge2024local), organizes knowledge through recursive summarization and community detection with LLM-generated synopses, enabling coarse-to-fine retrieval for comprehensive responses.
Building on this, recent approaches, including GFM-RAG (luo2025gfm), G-Retriever (he2024g), and LightRAG (guo2024lightrag), integrate specialized encoders and objectives, such as query-dependent GNNs, Prize Collecting Steiner Trees, and dual-level indexing, to improve multi-hop generalization, scalability, and efficiency. More recently, HippoRAG (hipporag) and its enhancement HippoRAG2 (gutiérrez2025hipporag2) draw inspiration from cognitive processes to utilize personalized PageRank for multi-hop retrieval. These strategies significantly improve retrieval precision and contextual depth, enabling LLMs to address complex, multi-hop queries more effectively.

Figure: Figure 1: Three paradigms of RAG systems.
Refer to caption: x1.png

Despite its conceptual promise and theoretical superiority, recent studies reveal that GraphRAG models frequently underperform even naive RAG approaches on many real-world applications (han2025rag; zhou2025depth; xiang2025use; zhuang2025losemb).
This performance degradation mainly stems from the poor quality of automatically constructed knowledge graphs. While graph-based retrieval increases recall of relevant knowledge, it concurrently introduces substantial noise and ambiguities into the retrieved contexts, due to errors in graph construction. Specifically, two critical deficiencies undermine graph quality, including (i) local inaccuracy: relation extraction processes exhibit significant error rates, resulting in inaccurate semantic relationships between entities. (ii) global inconsistency: the absence of mechanisms to enforce hierarchical consistency and global coherence during extraction leads to structurally fragmented graphs with poor connectivity. These deficiencies collectively manifest as structural conflicts and semantic ambiguity within the knowledge graph, which subsequently corrupt the retrieval and generation processes.
Although recent attempts have been made to refine graph quality via bottom-up clustering-based community summarization (edge2024local; gutiérrez2025hipporag2; wang2025archrag) or topic modeling (sarthi2024raptor) to offer a broader, macro-level view of data, these unsupervised methods are vulnerable to error propagation, where inaccuracies in entity relationships are amplified at higher levels of abstraction.

In this paper, we revisit the pipeline of existing GraphRAG systems and propose Linear Graph-based Retrieval-Augmented Generation (LinearRAG), a framework that enables efficient, reliable graph construction and precise corpus retrieval with multi-hop reasoning. The core idea of LinearRAG is to simplify the complex relational graph into a linear, easy-to-index view by focusing solely on modeling the semantics between target entities and the underlying text passages. Instead of relying on costly relation extraction, LinearRAG constructs a hierarchical graph from entities, sentences, and passages, using only lightweight entity extraction and semantic linking. On top of this graph, LinearRAG introduces a two-stage passage retrieval technique: ❶ local semantic bridging for entity activation, which identifies contextually relevant entities beyond literal matches by propagating semantic similarity in sentences to mine multihop contextual association;
and ❷ global importance aggregation for passage retrieval, which applies personalized PageRank over the activated subgraph to aggregate passage importance from a holistic perspective.
Together, these modules enable LinearRAG to achieve scalable, accurate, and noise-resilient retrieval for complex queries. Our overall contributions are summarized as follows:

- •
We identify key limitations in existing GraphRAG systems, specifically highlighting how reliance on unstable relation extraction introduces noise and structural inconsistencies. This motivates the design of LinearRAG, a novel framework that enables reliable graph construction and precise passage retrieval while maintaining linear scalability.
- •
LinearRAG constructs a relation-free hierarchical graph, called Tri-Graph, using only lightweight entity extraction and semantic linking, which avoids the instability of traditional relation modeling and reduces indexing time by over $77\%$.
- •
On top of the constructed graph, we design a two-stage retrieval mechanism that combines local semantic bridging for precise entity activation with global importance aggregation for passage recall. This integrated strategy enables more accurate, noise-resilient, and single-pass multi-hop retrieval.
- •
We conduct extensive experiments on four benchmark datasets, demonstrating that LinearRAG consistently outperforms state-of-the-art baselines in terms of retrieval quality, generation accuracy, and scalability, validating its practicality for real-world applications.

## 2 Preliminary Study

In this section, we conducted a series of preliminary studies to investigate the effect of graphs used in RAG systems. Our findings reveal critical flaws in graph construction that explain the underlying causes of GraphRAG’s frequent underperformance compared to naive RAG in traditional tasks.

Figure: (a) Retrieval and Generation Performance (%) of vanilla RAG v.s. typical GraphRAG baselines.
Refer to caption: x2.png

### 2.1 Performance Degradation in GraphRAG Systems

GraphRAG models frequently underperform traditional RAG approaches on many real-world tasks. Specifically, our experiments on GraphRAG-Bench (xiang2025use) demonstrate that while GraphRAG leverages graph structures to enhance recall by retrieving a wider array of potentially relevant passages, this gain is offset by a significant introduction of noisy and ambiguous contextual information. Specifically, GraphRAG methods such as LightRAG and HippoRAG achieve moderate improvements in evidence recall, but exhibit significantly lower context relevance, ranging from 36.86% to 54.61%, compared to Vanilla RAG, which attains 62.87% performance. This suggests that although graph-based retrieval expands the scope of contextual information, it introduces substantial noise that compromises the relevance and reliability of generated answers. For example, in a question-answering task about “climate change impacts”, GraphRAG might retrieve passages related to “economic policies” due to tenuous graph links. In contrast, vanilla RAG preserves tighter alignment with the query context, leading to more accurate and stable outputs.

### 2.2 Graph Quality and Error Analysis

To diagnose the root cause of performance degradation observed in Figure [2(a)](https://arxiv.org/html/2510.10114v4#S2.F2.sf1), we performed a fine-grained error analysis on the knowledge graphs used in GraphRAG. Our analysis revealed that this performance degradation stems directly from deficiencies in knowledge graph construction. Traditional GraphRAG pipelines rely on explicit relation extraction to construct relational graphs, which usually introduce errors at two levels:
(i) Local Inaccuracies: relation extraction models often produce factually incorrect triples. For example, as shown in Figure [2(b)](https://arxiv.org/html/2510.10114v4#S2.F2.sf2), the sentence “Einstein did not win the Nobel Prize for his theory of relativity” may be misrepresented as (Einstein, won Nobel Prize for, theory of relativity), fundamentally altering factual meaning.
(ii) Global Inconsistencies: existing relation extraction is performed locally on individual text passages, with no mechanism to validate or reconcile connections across the entire corpus, leading to redundant or contradictory relations. For example, “AI” may be linked to “Unsupervised Learning,” “NLP,” and “CV” as parallel subcategories without hierarchical coherence (e.g., that NLP and CV are subfields of AI, while “Unsupervised Learning” is a technique used within them). This structural ambiguity directly misleads the retrieval process, introducing semantic noise based on these inconsistent connections.

### 2.3 Discussion

wThe conventional GraphRAG pipeline relies heavily on explicit relation extraction and triple-based knowledge representation. While this approach aims to summarize passages into structured relational forms, it faces two fundamental issues: First, extracting concise and accurate relational triples is computationally expensive and linguistically challenging. Relations expressed in natural language are often complex and context-dependent, and often nuanced or compositional to be accurately distilled into atomic triples; for example, the sentence “Rachel reluctantly agreed to go running with Phoebe” cannot be cleanly reduced to a single atomic triple without losing critical semantic nuance.
Second, explicit relation extraction is unnecessary. Aligned entities, rather than relations, serve as the primary anchors connecting information distributed across passages. The original text preserves relational semantics in full context, which can be interpreted dynamically by large language models during inference, without relying on error-prone extraction.

Figure: Figure 3: The overall pipeline of the proposed LinearRAG framework. I. Offline Construction. Initially, we construct a Tri-graph containing entity, sentence, and passage nodes, with edges connecting entities to sentences and entities to passages. II. Online Retrieval. We first activate relevant entities via local semantic bridging on the entity-sentence subgraph while fixing passage nodes, then using the activated entities to aggregate global importance scores, finally, perform passage retrieval via personalized PageRank on the entity-passage subgraph while fixing sentence nodes.
Refer to caption: x4.png

## 3 The Framework of LinearRAG

Preliminary findings indicate that explicit relation extraction is not only computationally expensive but also largely unnecessary. These insights inform our revisit of the design of GraphRAG components, culminating in two central claims: (i) Aligned entities serve as the primary anchors connecting information distributed across passages. (ii) Contextual relations are best preserved within the original passages, eliminating the need for explicit relation extraction.

Motivated by this idea, we introduce a new GraphRAG paradigm as in Figure [3](https://arxiv.org/html/2510.10114v4#S2.F3). It constructs a graph that contains three types of nodes: entity nodes, sentence nodes, and passage nodes. Edges connect entities to sentences and entities to passages, represented as two adjacency matrices. Retrieval proceeds in two stages: ❶ entity activation stage, where we fix the passage nodes and use local semantic bridging on the entity–sentence subgraph to identify intermediate entities that connect different passages; and ❷ passage retrieval stage, where we fix the sentence nodes and apply personalized PageRank on the entity–passage subgraph, exploiting the activated entities in the first stage as seeds for global importance aggregation. This framework exhibits linear scalability in both graph construction and retrieval (detailed analysis in Appendix [D](https://arxiv.org/html/2510.10114v4#A4)), and we refer to it as LinearRAG.

### 3.1 Token-free Graph Construction

We construct a hierarchical graph, called Tri-graph, with multiple granularities that is efficient to maintain and update. Given a corpus with a set of passages ${\mathcal{P}}$, we first segment each passage into sentences using punctuation (e.g., periods or exclamation marks), obtaining a sentence set ${\mathcal{S}}$. We then apply lightweight models (e.g., spaCy (honnibal2020spacy)) for named entity recognition (NER) to derive an entity set ${\mathcal{E}}$. The passages, sentences, and entities constitute three types of nodes in the graph, denoted as $V_{p}$, $V_{s}$, and $V_{e}$, respectively.

Edges are constructed according to the following rules: if a passage $p_{i}$ contains an entity $e_{j}$, we add an edge $(V_{p_{i}},V_{e_{j}})$; likewise, if a sentence $s_{i}$ mentions an entity $e_{j}$, we add an edge $(V_{s_{i}},V_{e_{j}})$. These relations correspond to two adjacency matrices: the contain matrix $C$ between passages and entities, and the mention matrix $M$ between sentences and entities.

Formally, the contain matrix $C$ is defined as an $|V_{p}|\times|V_{e}|$ matrix:

$$ $C=[C_{ij}]_{|V_{p}|\times|V_{e}|},\quad\text{where}\quad C_{ij}=\mathbb{1}_{\{p_{i}\text{ contains }e_{j}\}}.$ (1) $$

Here, $\mathbb{1}$ denotes the indicator function, with $C_{ij}=1$ if $p_{i}$ contains $e_{j}$, and $C_{ij}=0$ otherwise.

Similarly, the mention matrix $M$ is defined as an $|V_{s}|\times|V_{e}|$ matrix:

$$ $M=[M_{ij}]_{|V_{s}|\times|V_{e}|},\quad\text{where}\quad M_{ij}=\mathbb{1}_{\{s_{i}\text{ mentions }e_{j}\}}.$ (2) $$

This design enables efficient graph updates as the corpus grows. When new passages arrive, only those passages undergo sentence segmentation, NER, and edge construction, yielding overall linear complexity. Notably, NER is both precise and efficient compared with OpenIE, and can be performed using lightweight language models (e.g., BERT-based models in spaCy) without incurring LLM token costs. In addition, the adjacency matrices $C$ and $M$ are implemented in sparse form, exploiting their intrinsic sparsity to further reduce memory usage to a linear-scalability. Finally, by retaining the original passages as knowledge carriers, the resulting graph preserves all contextual information, thereby ensuring information-lossless construction.

### 3.2 Passage Retrieval

With the constructed graphs serving as lossless knowledge carriers, the objective becomes identifying the most informative passages effectively. The design of graph-based retrieval is critical, as it must balance precision and recall of relevant context, particularly in the case of multihop queries. We decompose the retrieval process into two stages: a precise entity activation stage via local semantic bridging followed by a passage retrieval stage to recall globally important passages.

#### 3.2.1 First Stage : Relevant Entity Activation via Semantic Bridging

Generally, direct entity matching can miss relevant intermediate entities that bridge multihop relations, which are essential for multihop queries. Therefore, it is crucial to identify these latent connectors. However, such intermediate entities cannot be directly mined, and the massive number of entities challenges the precision of identifying them. To tackle this, we propose relevant entity activation via semantic bridging. For an incoming query $q$, the process is as follows:

Initial entity activation that identifies entities contained in the query $q$ and represents their activation in the knowledge graph as a sparse vector. Specifically, we first use SpaCy to extract entities from $q$, denoted as $E_{q}$. Then for each extracted entity, we find the most similar entity in the knowledge graph. The initial activation score of the matched entity is set to its similarity score:

$$ $\mathbf{a}_{q}=[\mathbf{a}_{q,i}]_{|V_{e}|\times 1},\quad\text{where}\quad\mathbf{a}_{q,i}=\mathbb{1}_{i=\arg\max_{e_{j}\in V_{e}}\texttt{sim}(e_{q},e_{j})}\cdot\texttt{sim}(e_{q},e_{i}).$ (3) $$

Query-sentence relevance distribution that computes the contextual association between the query $q$ and each sentence $s_{i}\in S$, where $S=\{s_{1},s_{2},\dots,s_{|S|}\}$ is the set of sentences in the corpus. Represent these similarities as a vector:

$$ $\mathbf{\sigma}_{q}=[\sigma_{q,i}]_{|S|\times 1},\quad\text{where}\quad\sigma_{q,i}=\texttt{sim}(q,s_{i}).$ (4) $$

Semantic propagation that propagates the similarities in $\mathbf{\sigma}_{q}$ through semantic similarity extraction to activate relevant intermediate entities, enabling the bridging of multihop relations in the knowledge graph. The entity activation vector $\mathbf{a}_{q}$ is updated with the weighted aggregation of their associated neighbors in the sentence-entity bipartite graph:

$$ $\mathbf{a}_{q}^{t}=\texttt{MAX}(M^{T}(\sigma_{q}\odot(M\mathbf{a}_{q}^{t-1})),\mathbf{a}_{q}^{t-1}),$ (5) $$

where $\mathbf{a}_{q}^{t}$ is the activation vector of the entities in the $t_{th}$ iteration of semantic propagation. With a few iterations, we identify a set of contextually relevant entities that anchors a subgraph in the corpus that aligns with the reasoning structure of the query. This solution mimics the relation-matching process in the GraphRAG algorithms for multi-hop reasoning. Differently, our strategy performs implicit relation matching and does not rely on explicitly constructed relational knowledge graph.

Noteworthy, the vectorized formulation of equation [5](https://arxiv.org/html/2510.10114v4#S3.E5) enables $n$-hop entity activation within only $n$ iterations, where $n$ is generally small ($\leq 4$). Each iteration involves three MatMul (matrix multiplication) and one MAX operation, which can be efficiently implemented and executed in parallel on popular machine learning platforms. Furthermore, due to the intrinsic sparsity of the matrix $M$ and the activation vector $\mathbf{a}_{q}^{t}$, we can store it in a sparse format to reduce memory consumption, and reduce computation cost by applying SpMM (sparse matrix multiplication) to replace MatMul.

Dynamic pruning.
While the above semantic bridging successfully establishes initial associations from query entities to potentially relevant intermediates, it also introduces a major challenge: the exponential growth of the search space as propagation deepens. Without proper control, irrelevant entities may repeatedly serve as new seeds, causing the process to expand combinatorially and drift into semantic regions unrelated to the original query intent. To address this issue, we perform graph pruning that constrains expansion to high-quality semantic paths. Specifically, at each propagation step, we introduce a threshold $\delta$. A newly activated entity is retained for the next iteration only if its relevance score exceeds $\delta$; otherwise, it is pruned. Moreover, the process terminates automatically once no new entity surpasses the threshold. This adaptive mechanism ensures that propagation proceeds only along the most relevant semantic paths, while dynamically tailoring the iteration range to the complexity of each query.

#### 3.2.2 Second Stage : Passage Retrieval via Global Importance Aggregation

In the first stage, relevant entities are extracted via local semantic-bridged subgraph expansion in the sentence-entity graph. These entities are used to initialize importance scores in a passage-entity graph, a bipartite graph where nodes represent passages ($V_{p}$) and entities ($V_{e}$), with edges connecting passages to their contained entities based on occurrence. The second stage performs global importance aggregation with hybrid initialization for passage nodes to retrieve important passages using Personalized PageRank (PPR) on the passage-entity graph to compute refined global importance scores for each node $v_{i}\in V_{p}\cup V_{e}$:

$$ $I(v_{i})=(1-d)+d\cdot\sum_{v_{j}\in B(v_{i})}\frac{I(v_{j})}{\text{deg}(v_{j})}$ (6) $$

Here, $d$ is the damping factor (typically 0.85), $B(v_{i})$ is the set of nodes linking to $v_{i}$, and $\text{deg}(v_{j})$ is the number of outgoing links from node $v_{j}$. The initial importance score for entity node $v_{i}\in V_{e}$ is set to $I(v_{i}|v_{i}\in V_{e})=\mathbf{a}_{q}^{(i)}$, where $\mathbf{a}_{q}=(\mathbf{a}_{q}^{(1)},\mathbf{a}_{q}^{(2)},\dots)$ is a vector of entity relevance scores for query $q$ computed in the first stage. For passage nodes $v\in V_{p}$, the initial importance score is:

$$ $I(v|v\in V_{p})=\left(\lambda\cdot\texttt{sim}(q,v)+\ln\left(1+\sum_{e_{i}\in E_{a}}\frac{\mathbf{a}_{q}^{(i)}\cdot\ln(1+N_{e_{i}})}{L_{e_{i}}}\right)\right)\cdot W_{p},$ (7) $$

where $\texttt{sim}(q,v)$ is the PPR base score capturing similarity between passage $v$ and query $q$, $E_{a}$ is the set of activated entities from the first stage, $N_{e_{i}}$ is the occurrence count of entity $e_{i}$ in passage $v$, $L_{e_{i}}$ is the hierarchical level of entity $e_{i}$, and $W_{p}$ is the passage node weight coefficient, $\lambda$ is a trade-off coefficient. Passages are ranked by their PPR scores $I(v|v\in V_{p})$, and the top-$k$ passages with the highest scores are selected for retrieval.

## 4 Experiments

In this section, we conduct comprehensive experiments to verify the effectiveness and efficiency of LinearRAG. Specifically, we aim to answer the following questions. Q1 (Generation Accuracy): How does LinearRAG perform compared to state-of-the-art GraphRAG methods in terms of generation performance? Q2 (Efficiency Analysis): How cost-efficient and time-efficient is LinearRAG relative to existing GraphRAG approaches? Q3 (Ablation Study): What contribution does each component of LinearRAG make to the overall performance? ( Note that for a comprehensive evaluation of LinearRAG, additional experiments on retrieval quality, parameter sensitivity, backbone analysis, large-scale efficiency analysis and case studies are presented in Appendix [E](https://arxiv.org/html/2510.10114v4#A5).)

**Table 1: Result (%) of baselines and LinearRAG on four benchmark datasets in terms of both Contain-Match and GPT-Evaluation Accuracy. The best result for each dataset is highlighted in bold, while the second result is indicated with an underline.**
| Method | HotpotQA | 2Wiki | MuSiQue | Medical |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Contain-Acc. | GPT-Acc. | Contain-Acc. | GPT-Acc. | Contain-Acc. | GPT-Acc. | GPT-Acc. |  |
| Direct Zero-shot LLM Inference |  |  |  |  |  |  |  |
| llama-8B | 31.10 | 27.30 | 33.60 | 16.20 | 7.40 | 8.10 | 27.31 |
| llama-13B | 24.20 | 16.80 | 21.90 | 10.50 | 3.30 | 4.40 | 28.86 |
| GPT-3.5-turbo | 33.40 | 43.20 | 28.70 | 31.00 | 10.30 | 21.90 | 45.60 |
| GPT-4o-mini | 38.90 | 40.20 | 36.30 | 31.40 | 13.60 | 15.80 | 42.10 |
| Vanilla Retrieval-Augmented-Generation |  |  |  |  |  |  |  |
| Retrieval (Top-1) | 46.30 | 49.10 | 36.60 | 31.70 | 17.80 | 21.10 | 48.01 |
| Retrieval (Top-3) | 53.00 | 56.00 | 44.90 | 39.70 | 25.10 | 27.50 | 59.07 |
| Retrieval (Top-5) | 55.70 | 58.60 | 48.60 | 43.00 | 26.10 | 29.60 | 61.68 |
| Graph-based Retrieval-Augmented-Generation Methods |  |  |  |  |  |  |  |
| KGP | 61.50 | 60.90 | 31.60 | 30.00 | 25.60 | 30.10 | 54.22 |
| G-retriever | 42.20 | 40.60 | 46.60 | 27.10 | 14.40 | 15.50 | 50.36 |
| RAPTOR | 55.90 | 58.30 | 50.10 | 42.10 | 23.30 | 27.40 | 55.75 |
| E^2GraphRAG | 61.00 | 63.90 | 54.30 | 38.10 | 23.80 | 26.20 | 58.00 |
| LightRAG | 60.30 | 59.50 | 55.20 | 39.00 | 27.40 | 28.60 | 54.36 |
| HippoRAG | 57.00 | 59.30 | 66.10 | 59.90 | 29.30 | 24.10 | 55.04 |
| GFM-RAG | 62.70 | 65.60 | 66.80 | 59.60 | 29.90 | 34.60 | 56.07 |
| HippoRAG2 | 62.90 | 64.30 | 62.70 | 55.00 | 31.00 | 35.00 | 60.77 |
| LinearRAG (Ours) | 64.30 | 66.50 | 70.20 | 63.70 | 33.90 | 37.00 | 63.72 |

### 4.1 Experimental Setting

Datasets. We first evaluate the effectiveness of LinearRAG on three widely-used multi-hop QA datasets and one domain-specific dataset, including HotpotQA (yang2018hotpotqa), 2WikiMultiHopQA (2Wiki) (2wikimqa), MuSiQue (trivedi2022MuSiQue), and the Medical dataset from GraphRAG-Bench (xiang2025use). We follow the same evaluation method as HippoRAG, using the same corpus for retrieval and choosing 1,000 questions from each validation set. This setup allows for a fair comparison between different methods. We also test our approach on the domain-specific Medical dataset from GraphRAG-Bench (xiang2025use), showing that LinearRAG improves both generation results and retrieval quality.

Baselines. We categorize all the baselines into three groups: (i) Zero-shot LLM Inference: We evaluate several foundational models including LLaMA3 (8B) and LLaMA3 (13B)  (dubey2024llama3), as well as GPT-3.5-turbo and GPT-4o-mini (openai2023gpt4). (ii) We deploy Vanilla RAG methodologies across multiple retrieval configurations (retrieving 1, 3, or 5 top passages), combining semantic-based document retrieval with chain-of-thought reasoning prompts to guide the LLM’s generation process. (iii) State-of-the-art GraphRAG Systems: We compare against leading GraphRAG implementations including KGP  (wang2024knowledge), G-retriever (he2024g), RAPTOR  (sarthi2024raptor), E^2GraphRAG (zhao20252GraphRAG), LightRAG (guo2024lightrag), HippoRAG (hipporag), GFM-RAG (luo2025gfm), and HippoRAG2 (gutiérrez2025hipporag2). Among these, RAPTOR organizes the corpus into a hierarchical tree graph; G-Retriever, LightRAG, HippoRAG, GFM-RAG, and HippoRAG2 extract triples from passages to build structured graphs; while E^2GraphRAG integrates both strategies.

Evaluation Metrics. We evaluate our method using four metrics across two categories. For end-to-end QA performance, following existing work (Wang et al., 2025), we use: 1) Contain-Match Accuracy (Contain-Acc.), which checks if the correct answer appears in the generated response, and 2) GPT-Evaluation Accuracy (GPT-ACC.), an LLM-based metric that assesses whether the predicted answer matches the ground truth. For the Medical dataset, since golden answers consist of lengthy descriptive statements, we only evaluate using GPT-ACC. For retrieval quality assessment, we adopt metrics from GraphRAG-Bench (xiang2025use): 1) Context Relevance, which measuring semantic alignment between questions and retrieved passages, and 2) Evidence Recall, which evaluating whether the retrieved contents contain all necessary information for the correct answer.

Implementations. For consistency in implementation, all algorithms use the same embedding model, i.e., all-mpnet-base-v2 (bge_embedding)). We set $k$ = 5 for top $k$ retrieval in all methods. All RAG approaches employ the same LLM (GPT-4o-mini) for both generation and evaluation tasks. All experiments are conducted on the hardware configuration detailed in Appendix [C](https://arxiv.org/html/2510.10114v4#A3).

### 4.2 Generation Accuracy (Q1)

To address Q1, we conduct a comprehensive evaluation of generation performance by comparing various baseline methods with LinearRAG across four benchmark datasets. The detailed experimental results are presented in Table [1](https://arxiv.org/html/2510.10114v4#S4.T1). Based on our analysis, we derive the following key observations.

Obs. 1. RAG significantly enhances zero-shot LLM performance. Direct prompting of LLMs without external knowledge retrieval yields the poorest performance across all datasets. For instance, advanced models like GPT-4o-mini achieve only 15.80% GPT-based accuracy on the MuSiQue dataset when operating without retrieval augmentation. However, integrating relevant corpus content into prompts substantially improves performance, as Vanilla RAG with top-5 retrieved contexts increases accuracy to 29.60% on the same dataset. Such significant performance enhancement demonstrates the essential nature of RAG mechanisms for information-intensive applications.

Obs. 2. GraphRAG methods provide crucial context missed by RAG methods for complex reasoning. While larger k values improve accuracy, the gains diminish at higher values, revealing vanilla RAG’s core limitation in multi-hop reasoning: it tends to overly focus on searching for mentioned entities or keywords within documents, thereby missing logic-related documents essential for the complete reasoning chain. By contrast, methods that model structural dependency in the retrieval consistently perform better. Among them, HippoRAG 2 achieves the best results across most datasets, attaining 62.90% Contain-based accuracy on HotpotQA and 31.00% on MuSiQue datasets.

Obs. 3. LinearRAG demonstrates superior performance compared to GraphRAG methods, which suffer from sensitivity to constructed graph quality. Typical GraphRAG methods address semantic misalignment by explicitly structuring knowledge into graphs, but their effectiveness relies heavily on relation extraction. Instead, LinearRAG gets rid of ineffective graph construction and LinearRAG outperforms all baselines by a significant margin across all datasets, empirically. Notably, LinearRAG achieves 63.70% GPT-based accuracy on 2Wiki, around 3.80% absolute improvement over the second best baseline, and boosts Contain-based accuracy to 70.20%.

**Table 2: Efficiency and performance comparison of different GraphRAG methods. Notably, Accuracy represents the average of Contain-Acc. and GPT-Acc. metrics. Prompt tokens represent input to LLM, and completion tokens represent LLM output. Best results are highlighted in bold, and second-best results are underlined.**
| Method | Time (s) | Token Consumption ($\times 10^{6}$) | Accuracy |  |  |
| --- | --- | --- | --- | --- | --- |
| Indexing | Retrieval (Avg.) | Prompt | Completion |  |  |
| G-retriever | 2745.94 | 11.487 | 6.05 | 2.26 | 36.85 |
| RAPTOR | 1323.57 | 0.062 | 0.81 | 0.03 | 46.10 |
| E^2GraphRAG | 534.60 | 0.053 | 0.78 | 0.08 | 46.20 |
| LightRAG | 4933.22 | 10.963 | 35.52 | 51.16 | 47.10 |
| HippoRAG | 936.00 | 1.461 | 3.05 | 0.98 | 63.00 |
| GFM-RAG | 1202.77 | 1.211 | 3.05 | 0.98 | 63.20 |
| HippoRAG2 | 1147.01 | 1.694 | 4.98 | 1.22 | 58.85 |
| LinearRAG (Ours) | 249.78 | 0.093 | 0 | 0 | 66.95 |

### 4.3 Efficiency Analysis (Q2)

To better understand the associated efficiency and cost implications, we conduct a dedicated analysis on prompt statistics across different GraphRAG models during the indexing and retrieval stages by comparing their token usage and running time on 2WikiMultiHopQA dataset. The results are presented in Table [2](https://arxiv.org/html/2510.10114v4#S4.T2), and we summarize our key observations as follows:

Obs. 4. Complicated graph construction inevitably brings significant time costs during both the indexing and retrieval stages. Models such as G-Retriever and LightRAG employ intricate schema definitions, resulting in notably poor efficiency. For instance, LightRAG requires 4,933.22 seconds for indexing and 10.963 seconds for retrieval. These models define entities and keywords within the graph and perform both high-level and low-level retrieval. Consequently, LLMs are overburdened with processing the large volume of content retrieved from these two information sources, which results in higher fees and latency.

Obs. 5. Reducing LLM token costs does not necessarily have a negative impact on performance.
Complicated prompt construction and completion in G-Retriever and LightRAG fail to deliver consistent performance improvements. For instance, HippoRAG2 uses only 3.05M tokens during prompt construction and 0.98M tokens in the completion stage, while HippoRAG2 consumes 4.98M tokens for prompt construction and 1.22M tokens in completion. Despite these lower token costs, both models outperform G-Retriever and LightRAG.

Obs. 6. LinearRAG delivers the strongest overall efficiency. Considering the whole pipeline, LinearRAG is the fastest and introduces zero token usage. While E^2GraphRAG and RAPTOR are more time-efficient than LinearRAG at the retrieval stage, it comes at the cost of significantly reduced model performance, as it retrieves only directly related documents with the query without considering the structural dependencies in the reasoning chain. In comparison, the lightweight pipeline of LinearRAG avoids LLM calls for both indexing and retrieval, which minimizes latency and eliminates token costs. For deployments that demand strong performance along with speed, scalability, and cost control, LinearRAG is the most practical choice.

### 4.4 Ablation Study (Q3)

Figure: Figure 4: Ablation study on key modules of LinearRAG under four different datasets. The y-axis represents the average of GPT-Acc. and Contain-Acc.
Refer to caption: x5.png

To address Q3, we conduct systematic ablation studies on the core components of LinearRAG across four datasets. We examine two key modules: ❶ Relevant Entity Activation via Semantic Bridging, i.e., w/o Entity Activation, which directly uses the initial entities extracted from the query as activated entities, bypassing the semantic bridging process that propagates activation scores from query entities to related entities in the knowledge graph. ❷ Passage Retrieval via Global Importance Aggregation, i.e., w/o Global Importance Aggregation, which skips the personalized PageRank algorithm and directly uses the initial activation scores computed by stage ❶ to retrieve documents from the corpus, without considering global importance relationships. Each variant is evaluated with the average of GPT-Acc. & Contain-Acc. as our primary evaluation metric. Experimental results are shown in Figure [4](https://arxiv.org/html/2510.10114v4#S4.F4), and we have the following findings.

Obs. 7. Each module of LinearRAG is critical for optimal performance. The performance gains are primarily attributed to two complementary stages. In the first Stage, LinearRAG identifies contextually relevant entities through semantic similarity propagation, uncovering the hidden logical relationships in multi-hop questions. In the second Stage, the model uses personalized PageRank algorithms on the activated subgraph to evaluate document importance from a global perspective. These two modules serve different but complementary purposes, allowing LinearRAG to achieve both effective and efficient performance.

## 5 Conclusion

In this work, we introduce LinearRAG, a novel GraphRAG framework that simplifies graph construction by replacing costly and error-prone relation extraction with lightweight entity extraction. It creates a hierarchical graph encompassing entities, sentences, and passages. Upon this, LinearRAG features a two-stage retrieval mechanism that advances the precision-recall Pareto frontier by jointly leveraging both local and global structural information. Extensive experiments demonstrate that LinearRAG consistently surpasses state-of-the-art baselines in retrieval precision, generation accuracy, and scalability, offering a robust and efficient solution for handling complex queries.

## Ethics statement

The first three datasets used in the experiments including HotpotQA, 2WikiMultiHopQA and MuSiQue are widely used datasets. The medical benchmark dataset is built from public resources.
Our research strictly adheres to the ICLR Code of Ethics, particularly regarding data privacy, transparency,
and responsible computing practices. And there is no participant involved.

## Reproducibility statement

We provide detailed information required to reproduce the main experimental results of the paper, including data splits and hyperparameter configurations. Additionally, for each experiment, we outline the required computational resources, such as memory usage and execution time. All baseline models are sourced from public repositories. Our code and dataset are made available.

## Appendix A Datasets

Our experimental evaluation is conducted on four datasets: three established multi-hop benchmark datasets for multi-hop question answering—HotpotQA (yang2018hotpotqa), MuSiQue (trivedi2022MuSiQue), and 2WikiMultiHopQA (2Wiki) (2wikimqa)—and one domain-specific dataset. Below, we provide a concise overview of each dataset’s key characteristics.

(i) HotpotQA (yang2018hotpotqa): A comprehensive benchmark comprising 97k question-answer instances designed to evaluate multi-hop reasoning capabilities. Each question requires models to synthesize information from multiple documents, with up to 2 gold-standard supporting passages provided alongside numerous irrelevant documents. This structure challenges systems to perform effective cross-document inference and evidence selection.

(ii) 2WikiMultiHopQA (2Wiki) (2wikimqa): A multi-hop reasoning benchmark containing 192k questions that necessitate information integration across multiple Wikipedia articles. Each instance requires evidence synthesis from either 2 or 4 specific articles, testing models’ ability to perform structured cross-document reasoning and maintain coherent information flow.

(iii) MuSiQue (trivedi2022MuSiQue): A sophisticated multi-hop QA benchmark featuring 25k question-answer pairs that demand 2-4 sequential reasoning steps. Each question requires coherent multi-step logical inference across multiple documents, challenging systems to execute structured reasoning chains while preserving contextual consistency throughout the inference process.

(iv) Medical: A specialized subset derived from GraphRAG-Bench (xiang2025use), constructed from structured clinical data sourced from the National Comprehensive Cancer Network (NCCN) guidelines. These guidelines provide standardized treatment protocols, drug interaction hierarchies, and diagnostic criteria. The dataset encompasses four tasks of increasing complexity: fact retrieval, complex reasoning, contextual summarization, and creative generation, totaling 4,076 questions across all difficulty levels.

## Appendix B Baseline Details

In our experiments, we compare our method against several widely used GraphRAG approaches.

(i) KGP (wang2024knowledge) builds a knowledge graph over multiple passages with LLMs; at retrieval stage, it introduces an LLM-driven graph traversal agent to navigate the graph and progressively collect supporting passage.

(ii) G-Retriever (he2024g) combines graph neural networks with LLMs by formulating subgraph retrieval as a Prize-Collecting Steiner Tree optimization problem, enabling effective conversational question answering on textual graphs while mitigating hallucination and enhancing scalability.

(iii) RAPTOR (sarthi2024raptor) develops a hierarchical tree by applying clustering algorithms and abstractive summarization techniques, facilitating representation at multiple semantic granularities.

(iv) E^2GraphRAG (zhao20252GraphRAG) uses spaCy to extract entities and LLMs to summarize passage groups into a hierarchical tree with encoded nodes at indexing stage; at retrieval stage, it hits relevant entities in $k$-hop neighborhood and collects associated passages for ranking, otherwise dense retrieval over the whole tree.

(v) LightRAG (guo2024lightrag) employs a two-tier framework that incorporates graph-based representations within textual indexing, merging fine-grained entity-relation mappings with coarse-grained thematic structures.

(vi) HippoRAG (hipporag) is a training-free graph-enhanced retriever that uses the Personalized PageRank algorithm with query concepts as seeds for single-step or multi-hop retrieval across disparate documents.

(vii) GFM-RAG (luo2025gfm) implements a GraphRAG paradigm by constructing graphs from documents and using a graph-enhanced retriever to retrieve relevant documents.

(viii) HippoRAG2 (gutiérrez2025hipporag2) extends HippoRAG with enhanced paragraph integration and contextualization. Optimizes seed node selection and PageRank reset probabilities while maintaining factual memory capabilities and improving associative memory performance. improving associative memory performance.

## Appendix C Machine Configuration

All experiments in this study were conducted on the hardware configuration detailed in Table [3](https://arxiv.org/html/2510.10114v4#A3.T3).

**Table 3: Detailed machine configuration used in our experiments.**
| Component | Specification |
| --- | --- |
| GPU | NVIDIA GeForce RTX 4090 D (24GB VRAM) |
| CPU | Intel(R) Xeon(R) Gold 6426Y |

## Appendix D Efficiency Analysis of Graph Construction: All-Stage Linear Scalability

We present the efficiency analysis of LinearRAG and demonstrate that it achieves linear scalability in both runtime and memory consumption during graph construction and retrieval, thereby ensuring all-stage linear scalability. Detailed analysis is provided below.

Graph construction stage involves lightweight operations such as sentence segmentation and named entity recognition over the corpus. The resulting computational complexity is $O(|{\mathcal{P}}|\cdot T)$, where $T$ denotes the average length of each passage. Notably, this stage incurs no LLM token consumption. Regarding memory usage, the first data structures to be stored are the embeddings of passages, nodes, and sentences, all of which scale linearly with the corpus size, i.e., $O(|{\mathcal{P}}|\cdot T)$. The second set of data structures includes two adjacency matrices, $M$ and $C$, stored in sparse format by leveraging the inherent sparsity (each sentence contains at most $\sim 4$ entities, and each passage at most $\sim 10$ entities). Thus, memory consumption is $O(|{\mathcal{P}}|+|{\mathcal{S}}|)$, which simplifies to $O(|{\mathcal{P}}|)$ since the number of sentences is proportional to the number of passages. Therefore, the overall memory complexity is $O(|{\mathcal{P}}|\cdot T+|{\mathcal{P}}|)=O(|{\mathcal{P}}|\cdot T)$, i.e., linear with respect to corpus size.

Retrieval stage involves similarity computations, semantic propagation using SpMM (sparse matrix multiplication), and Personalized PageRank (PPR) iterations. Each propagation step requires $O(\text{nnz})$ time, where nnz is the number of non-zero entries in the sparse matrices ($O(|{\mathcal{S}}|)$), and PPR on the bipartite graph is computable in linear time with respect to the number of edges ($O(|{\mathcal{P}}|)$). Overall, the computational complexity is $O(|{\mathcal{P}}|)$. Memory consumption primarily arises from loading sparse graph structures, activation vectors (of size $O(|{\mathcal{E}}|+|{\mathcal{S}}|+|{\mathcal{P}}|)$), and temporary query-specific computations.

Acceleration with parallel computation. The above analysis confirms the linear scalability of LinearRAG in both graph construction and retrieval. Additionally, due to the vectorized formulation of the graph structures, all data manipulations can be efficiently accelerated through parallel computation, further boosting performance in both stages. This is empirically verified in our efficiency experiments in section [4.3](https://arxiv.org/html/2510.10114v4#S4.SS3) and appendix [E.4](https://arxiv.org/html/2510.10114v4#A5.SS4).

## Appendix E Additional Experiments

### E.1 Retrieval Quality Evaluation (Q4)

To provide a more comprehensive assessment beyond generation performance, we adopt the settings from GraphRAG-Bench and utilize four tasks of increasing difficulty: Fact Retrieval, Complex Reasoning, Contextual Summarization, and Creative Generation. The comparison is conducted on the Medical dataset, same as GraphRAG-Bench. The results comparing LinearRAG with representative GraphRAG methods are presented in Table [4](https://arxiv.org/html/2510.10114v4#A5.T4) and we have the following observations.

Obs. 8. GraphRAG models demonstrate significant improvements in recall metrics compared to RAG baselines, particularly in creative generation tasks, but fall behind in relevance metrics. We infer that the reasons are twofold. On the one hand, for simpler tasks such as fact retrieval, models are not required to analyze reasoning chains to recall all the necessary supporting facts. Direct semantic retrieval is enough, reducing the risk of retrieving irrelevant or redundant information during graph traversal. On the other hand, for more complex tasks such as creative generation, the model needs continuous documents with strong logical dependencies to produce satisfactory outputs. RAG struggles to capture such complex relationships due to underlying graph structure of gold answers. Specifically, GFM-RAG improves recall from 44.88% to 83.51% in creative generation, but relevance drops from 58.73% to 22.87%.

Obs. 9. LinearRAG demonstrates tremendous performance improvements over GraphRAG models in relevance metrics, owning the advantages of both high recall and strong relevance. It is challenging to improve recall and relevance simultaneously because increasing recall often introduces more irrelevant documents, lowering relevance, while increasing relevance usually misses relevant results and lowering recall. LinearRAG achieves the best performance across four tasks in recall while achieves better than RAG in relevance metrics in most cases. We infer that the reason lies in our construction of a high-quality graph with minimal redundant connections, ensuring that irrelevant documents are not retrieved. Specifically, in complex reasoning tasks, LinearRAG achieves 87.03% recall and 81.58% relevance, significantly outperforming GFM-RAG’s 85.03% recall but only 33.06% relevance, demonstrating LinearRAG’s ability to maintain high precision while preserving comprehensive information coverage.

**Table 4: Retrieval quality evaluation results (%) of different baselines across four different question categories. The table compares recall and relevance metrics for fact retrieval, complex reasoning, contextual understanding, and creative generation tasks. The best results are highlighted in bold, and second-best results are underlined.**
| Method | Fact Retrieval | Complex Reasoning | Contextual | Creative Generation |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Recall | Relevance | Recall | Relevance | Recall | Relevance | Recall | Relevance |  |
| Vanilla RAG (Top-5) | 86.24 | 63.71 | 84.97 | 84.11 | 84.14 | 89.94 | 44.88 | 58.73 |
| RAPTOR | 85.40 | 69.38 | 89.70 | 53.20 | 88.86 | 58.73 | 72.70 | 52.71 |
| E^2GraphRAG | 87.84 | 69.74 | 87.08 | 62.67 | 89.17 | 71.63 | 60.26 | 35.84 |
| LightRAG | 80.32 | 41.27 | 82.91 | 42.79 | 85.71 | 43.11 | 81.34 | 45.17 |
| HippoRAG | 87.25 | 52.44 | 83.80 | 42.19 | 83.46 | 49.13 | 81.66 | 45.03 |
| GFM-RAG | 90.08 | 57.90 | 85.03 | 33.06 | 78.62 | 40.14 | 83.51 | 22.87 |
| LinearRAG (Ours) | 88.86 | 86.09 | 87.03 | 81.58 | 89.13 | 87.89 | 89.08 | 72.74 |

### E.2 Hyper-parameter Sensitivity (Q5)

Figure: (a) The impact of threshold $\delta$.
Refer to caption: x6.png

We conduct ablation studies to investigate the impact of key hyperparameters in LinearRAG. All experiments are evaluated using the average scores of of GPT-Acc. and Contain-Acc. on 2WikiMultiHopQA.

Obs. 10. Impact of threshold $\delta$. The threshold $\delta$ determines whether an entity’s score is retained during dynamic pruning and whether to continue expansion. As shown in Figure [5(a)](https://arxiv.org/html/2510.10114v4#A5.F5.sf1), when $\delta$ is too small, it introduces excessive noise and reduces efficiency in the retrieval stage. However, when $\delta$ is too large, it prevents the incorporation of more relevant entities, limiting the model’s ability to capture comprehensive contextual information. Therefore, selecting an appropriate value for $\delta$ is crucial for balancing retrieval quality and computational efficiency. And, we set $\delta=4$ based on our experimental setting.

Obs. 11. Impact of trade-off coefficient $\lambda$. The parameter $\lambda$ controls the balance between DPR-based passage similarity and entity-level information during passage initial scoring. As observed in Figure [5(b)](https://arxiv.org/html/2510.10114v4#A5.F5.sf2), optimal performance is achieved when $\lambda$ takes a relatively small value (e.g., 0.05), ndicating that entity information serves as the primary component while DPR similarity score acts as an auxiliary enhancement.

### E.3 Effectiveness of Different Sentence Embeddings (Q6)

**Table 5: Comparison of different sentence embedding models used in LinearRAG. The best results are highlighted in bold.**
| Model | HotpotQA | 2Wiki | MuSiQue | Medical |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Contain-Acc. | GPT-Acc. | Contain-Acc. | GPT-Acc. | Contain-Acc. | GPT-Acc. | GPT-Acc. |  |
| all-mpnet-base-v2 | 64.30 | 66.50 | 70.20 | 63.70 | 33.90 | 37.00 | 63.72 |
| all-MiniLM-L6-v2 | 64.20 | 64.90 | 69.50 | 62.60 | 32.80 | 36.90 | 62.32 |
| bge-large-en-v1.5 | 66.20 | 67.60 | 69.80 | 63.90 | 31.80 | 35.20 | 64.45 |
| e5-large-v2 | 66.80 | 68.30 | 69.90 | 63.10 | 31.70 | 36.50 | 65.42 |

In this section, we study the effectiveness of different sentence embeddings in the LinearRAG. We compare the all-mpnet-base-v2 (song2020mpnet), bge-large-en (bge_embedding), all-MiniLM-L6-v2 (wang2020minilm) and e5-large-v2 (wang2022text). We download the official pre-trained model from the Huggingface2.

Obs. 12. Based on the findings presented in Table [5](https://arxiv.org/html/2510.10114v4#A5.T5), we observe that performance variations across different sentence embedding models remain relatively modest, with all-mpnet-base-v2 demonstrating superior results on the majority of datasets. This suggests that LinearRAG exhibits robustness to the selection of sentence embedding models. Consequently, we adopt all-mpnet-v2 as our default embedding models in all experiments due to its computational efficiency.

**Table 6: Indexing efficiency comparison of GraphRAG methods on large-scale ATLAS-Wiki corpus. Results are evaluated on ATLAS-Wiki subsets of 5M and 10M tokens. Notaly, prompt tokens represent input to LLM, and completion tokens represent LLM output.**
| Dataset | Method | Indexing Time (s) | Token Consumption ($\times 10^{6}$) |  |
| --- | --- | --- | --- | --- |
| Prompt | Completion |  |  |  |
| 5M | RAPTOR | 18033.75 | 7.43 | 0.96 |
| HippoRAG | 6032.46 | 13.94 | 3.68 |  |
| LinearRAG (Ours) | 1409.95 | 0 | 0 |  |
| 10M | RAPTOR | 46430.96 | 16.62 | 2.82 |
| HippoRAG | 13815 | 28.04 | 7.53 |  |
| LinearRAG (Ours) | 3084.38 | 0 | 0 |  |

### E.4 Large-Scale Efficiency Analysis (Q7)

To evaluate the scalability and effectiveness of LinearRAG on large corpora, we conduct comprehensive efficiency analysis using the ATLAS-Wiki dataset (bai2025autoschemakg). We create two subsets containing 5M and 10M tokens respectively for indexing phase evaluation, as shown in Table [6](https://arxiv.org/html/2510.10114v4#A5.T6).

Obs. 13. The results demonstrate that LinearRAG achieves significant efficiency advantages over typical GraphRAG methods. Specifically, LinearRAG eliminates token consumption entirely (0 prompt and completion tokens) while achieving 12.8× and 15.1× speedup compared to RAPTOR on 5M and 10M datasets respectively. This zero-cost indexing approach makes LinearRAG particularly suitable for large-scale enterprise deployments without API dependencies.

### E.5 Case Study (Q8)

**Table 7: Case study of LinearRAG. LinearRAG successfully captures implicit relationships without requiring explicit relation extraction, enabling correct multi-hop reasoning.**
| Question | ”What nationality is Beatrice I, Countess Of Burgundy’s husband?” |
| --- | --- |
| Ground Truth | Germany |
| Support Context | [”Beatrice I, Countess of Burgundy” $\to$ ”spouse” $\to$ ”Frederick Barbarossa”] |
|  | [”Frederick Barbarossa” $\to$ ”country of citizenship” $\to$ ”Germany”] |
| Hippo2RAG | Retrieved context: |
|  | 1) ✓ “William Duncan (actor)”: …frederick barbarossa was elected king of germany at frankfurt on 4 march 1152… |
|  | 2) ✕ “Dulce of Aragon”: ”Dulce of Aragon (or of Barcelona; ; 1160 2̆013 1 September… |
|  | 3) ✕ “Gordon Flemyng”: Gordon William Flemyng( 7 March 1934 2̆013 12 July 1995) was a… |
|  | 4) ✕ “Marian Hillar”: Marian Hillar is an American philosopher, theologian, linguis… |
|  | 5) ✕ “Semi-Tough”: Semi-Tough is a 1977 American comedy film directed by Michael… |
|  | Prediction: |
|  | ✕ French. |
| LinearRAG | Activated Entities: |
|  | Tter 0-Entity: Beatrice I |
|  | Tter 0-Sentence: Beatrice I (1143 2̆013 15 November 1184) was Countess of Burgundy from 1148 until her death, and was also Holy Roman Empress by marriage to Frederick Barbarossa. |
|  | Tter 1-Entity: Frederick Barbarossa |
|  | Tter 1-Sentence: Frederick Barbarossa was elected King of Germany at Frankfurt on 4 March 1152 and crowned in Aachen on 9 March 1152. |
|  | Tter 2-Entity: Germany |
|  | Retrieved context: |
|  | 1) ✓ “William Duncan (actor)”: …he was elected king of germany at frankfurt on 4 march 1152… |
|  | 2) ✓ “Beatrice I, Countess of Burgundy”: …holy roman empress by marriage to frederick barbarossa… |
|  | 3) ✕ “Richilde, Countess of Hainaut”: Richilde, Countess of Mons and Hainaut( 2̆013 15 March 1086)… |
|  | 4) ✕ “Sophie of Pomerania, Duchess of Pomerania”: Sophia of Pomerania- Stolp( 1435 2̆013 24… |
|  | 5) ✕ “”D0̆0e1ire Drechlethan”: ”D0̆0e1ire DrechlethanD̈0̆0e1ire of the Broad Faceïs a… |
|  | Prediction: |
|  | ✓ Germany. |

To clearly contrast typical GraphRAG baselines with our LinearRAG framework, we include a detailed case analysis in Table [7](https://arxiv.org/html/2510.10114v4#A5.T7), comparing results from the strong baseline HippoRAG2 and our model on a multi-hop question from the 2WikiMultihopQA dataset.

Obs. 14. The case demonstrates that HippoRAG2 fails to retrieve relevant evidence due to its dependence on explicitly pre-extracted relations (such as husband) that are missing in this context. In comparison, our LinearRAG method effectively captures implicit relationships through entity activation and contextual chaining, without dependence on pre-extracted relational tuples.

## Appendix F Related Work

Large language models are prone to hallucination (fang2024alphaedit; jiang2025anyedit; fang2025safemlrm; zheng2025usb; hong2024next; yuan2025knapsack; zhong2024iterative), while RAG is a promising solution by grounding the reasoning process on contextual evidence from knowledge bases (zhang2025erarag; zhou2025depth; xiao2025graphragbenchchallengingdomainspecificreasoning; zhang2025survey; xiang2025use).
However, real-world knowledge is often distributed across documents, organizing them effectively for answering complex questions has always been a challenging yet promising research topic in RAG. In the following, we discuss two major lines (❶, ❷) of graphRAG research that closely relate to our work, which construct explicit graphs for organizing external knowledge sources. Then discuss reasoning-enhanced RAG (❸), which leverages LLM’s inherent reasoning ability for answering complex questions without explicitly structuring corpora.

❶Clustering-based hierarchy construction. One line of research employs clustering-based community detection, a bottom-up method that applies algorithms like Louvain or Leiden to identify densely connected clusters of entities within the initial graph (edge2024local; sarthi2024raptor; hipporag). By grouping related entities, it creates a hierarchical structure that abstracts passages into topic-based communities, reducing redundancy and offering a broader, macro-level view of the data. However, as an unsupervised technique, it is vulnerable to error propagation, where inaccuracies in entity relationships are amplified at higher levels of abstraction. Moreover, applying these clustering algorithms to large-scale graphs presents significant scalability issues, making real-time applications infeasible in practice.

❷Relation-extraction-based knowledge graph construction. This line of research (hipporag; guo2024lightrag; xiao2025reliablereasoningpathdistilling) adopts the idea of knowledge graphs to organize knowledge across different passages. The basic idea is to extract triples from each text chunk (passage) as an atomic summarization of the knowledge within the passage. The triples are connected via entity alignment (neusymea; LLM4EA), ultimately forming a unified knowledge graph, which directly carries structured knowledge and serves as the index of passages, where off-the-shelf graph reasoning algorithms (difflogic; pLogicNet; liu2023rsc) can be applied to perform reasoning (sun2024thinkongraph; luo2024reasoning). However, due to context window limits, OpenIE on each passage is processed independently, so the generated triples may be inconsistent. Recent work (liang2024kag; sharma2024og) mitigates this via top-down graph construction guided by a globally defined schema, but it relies on manual expert annotation to create and maintain the domain-specific schema, which is not only expensive, time-consuming, and does not generalize well across domains.

❸Reasoning-enhanced RAG. The key to answering complex questions in RAG is to effectively identify multiple distributed documents that support multihop logical dependencies. While GraphRAG methods explicitly construct graphs with human priors to organize corpora for efficient structured retrieval, reasoning-enhanced RAG directly leverages the inherent reasoning ability of LLMs to decompose complex queries into simpler subquestions that can be addressed by dense retrieval. LogicRAG (chen2025logicrag) and LAG (xiao2025lag) formalize this idea by first decomposing a query into a set of subqueries, then constructing a directed acyclic graph based on the logical dependencies among them, and solving subproblems one by one by following the topological order. Similarly, Chain-of-Note (CoN) (chainofNote) enhances RAG by generating sequential notes that break down complex queries into intermediate reasoning steps, retrieving relevant documents for each step to build a coherent answer. Another approach, SelfRAG (asai2024selfRAG), integrates self-reflection into the RAG process, where the LLM iteratively evaluates and refines subqueries to ensure retrieved documents align with the logical flow of the reasoning process. These methods collectively highlight the potential of LLM-driven reasoning to improve retrieval efficiency and answer quality for complex, multihop queries.

## Appendix G The Use of Large Language Models

We employ LLMs primarily for writing polish, including correcting spelling errors, fixing grammatical issues, and rewriting non-native expressions to improve clarity and fluency. And LLMs are used only for writing polishing of our manuscript and appendix. It does not generate research ideas, results, or claims. We ensure that all scientific contributions and implementations are original.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: Q1: What exact linear retrieval procedure is used (single-pass BFS-like scan, bounded-degree expansion, heuristic queue ordering)? How are thresholds chosen and adapted?

Q2: How are node and edge attributes computed (embedding similarity, co-occurrence, LLM scoring)? Are edge weights normalized and thresholded consistently?

Q3: What fallback exists for multi-hop or compositional queries requiring evidence aggregation? Can limited expansions be temporarily enabled without breaking linearity guarantees?

Q4: Are there systematic trade-off curves (recall vs. latency/memory) across different graph sizes and domains? How robust are results to parameter changes?

Q5: Do comparisons include equal-resource settings against beam search or greedy path selection to isolate algorithmic gains from compute differences?
soundness: 3
strengths: S1: The approach fits production constraints and integrates with standard embedding + reranking pipelines.

S2: The linear retrieval design emphasizes bounded expansions and pruning, offering predictable runtime and memory behavior on large graphs.

S3: The method encourages simple deployment: light graph construction, single-pass adjacency, and top-k selection, reducing system complexity compared to full GraphRAG stacks.
summary: The paper proposes LinearRAG, an efficient GraphRAG framework that constructs a relation-free hierarchical graph (Tri-Graph) using lightweight entity extraction and semantic linking over entities, sentences, and passages. For retrieval, LinearRAG adopts a two-stage strategy: (1) local semantic bridging to activate contextually relevant entities beyond literal matches, and (2) global importance aggregation via personalized PageRank to retrieve salient passages. This construction scales linearly with corpus size and incurs no extra token consumption, providing economical and reliable indexing for large corpora. Experiments on four benchmarks show consistent improvements over strong baselines in retrieval quality, generation accuracy, and scalability.
weaknesses: W1: Linear constraints risk under-retrieving long-range dependencies; multi-hop reasoning and compositional queries may suffer without fallback mechanisms.

W2: Limited theoretical analysis (e.g., recall/latency trade-offs, worst-case behaviors) could make the contribution primarily engineering rather than principled.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: Could the framework benefit from more informative weights for sentence-entity edges?
soundness: 3
strengths: 1. The paper presents a strong, well-argued case that relation extraction errors are a primary bottleneck for GraphRAG performance. The decision to "de-relationalize" the graph and defer relation understanding to the LLM during generation is a conceptually clear and impactful design choice. 

2. The proposed Tri-Graph structure is a novel and potentially groundbreaking simplification of the GraphRAG paradigm. The retrieval mechanism, leveraging sparse matrix operations for semantic propagation and PPR, is computationally elegant. 

3. The framework's linear scalability, facilitated by update-friendly appends and the complete absence of LLM calls in indexing/retrieval, is a major strength. The demonstrated linear growth trend on a million-scale corpus underscores its high practical value for real-world deployment.

4. The paper provides an exceptionally thorough evaluation, going beyond standard QA accuracy to include critical efficiency metrics like token cost and latency. This holistic comparison makes the results highly persuasive and relevant for computation-budget-sensitive scenarios.
summary: This paper proposes LinearRAG, a novel GraphRAG framework designed to address key challenges in existing methods: the difficulty and noise associated with knowledge graph construction, and low retrieval efficiency. The core innovation is constructing a three-layer hierarchical graph (Tri-Graph) comprising entities, sentences, and paragraphs. During retrieval, the model first activates query-relevant entities via local semantic propagation and then uses these as seeds in a Personalized PageRank algorithm on a paragraph-entity bipartite graph to aggregate global importance for retrieval in a single pass. Both the time and space complexity scale linearly with the corpus size, and the entire indexing/retrieval process requires zero LLM API calls. Experimental results on four public datasets demonstrate that LinearRAG significantly outperforms existing GraphRAG methods.
weaknesses: 1. The Tri-Graph merges entity mentions based on string matching, which ignores polysemy (different entities with the same name). This is a significant limitation, as it can introduce erroneous co-occurrence edges, potentially leading to the retrieval of irrelevant paragraphs. While high NER accuracy is claimed, the paper does not quantify the impact of this inherent ambiguity on retrieval performance, leaving a major potential source of error unanalyzed.

2. Using binary weights (0/1) for sentence-entity edges fails to capture the varying semantic importance of different entities within a sentence. This uniform weighting strategy is a simplification that may amplify the influence of "noisy" or peripheral entities during the propagation step, potentially harming result relevance and interpretability. 

3. The parameters, particularly the activation threshold and the trade-off coefficient, are noted to be highly sensitive. The paper lacks an analysis establishing a functional relationship between these parameters and query characteristics or graph properties.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: - The token-free graph construction process appears similar to the context-graph construction in the paper *"Synthesize-on-graph: ..."*, as both utilize the position relationships between entities and texts as graph relationships. Could you please explain the key distinctions of your method?
- Other questions refer to Weaknesses.
soundness: 3
strengths: - This paper proposes a efficient and lightweight graph construction method, Tri-Graph, which avoids error-prone relation extraction in GraphRAG, maintains linear scalability, and achieves 0 token consumption in retrieval.
- This paper proposes a novel GraphRAG framework that combine local semantic bridging and global importance aggregation, whose effectiveness is valided through extensive experiments.
- This paper conducted extensive experiments to validate the effectiveness of LinearRAG, including sufficient main experiments against GraphRAG and vanilla RAG.
summary: This paper proposes a new framework for RAG, LinearRAG, =which overcomes the limitations of existing GraphRAG systems. The proposed LinearRAG replaces complex relation modeling with a relation-free hierarchical Tri-Graph, built using lightweight entity extraction and semantic linking. This design scales linearly with corpus size and avoids extra token consumption. The retrieval process follows a two-stage mechanism: First, local semantic bridging activates relevant entities beyond literal matches through semantic propagation. Second, global importance aggregation applies personalized PageRank to rank passages holistically.

Experiments on HotpotQA, 2WikiMultiHopQA, MuSiQue, and a Medical benchmark show that LinearRAG consistently outperforms both vanilla RAG and advanced GraphRAG methods in retrieval quality, generation accuracy, and efficiency. It achieves strong multi-hop reasoning performance with minimal computational overhead.

LinearRAG offers a practical and scalable solution for integrating structured retrieval with large-scale text corpora, avoiding the instability of relation extraction and achieving linear scalability in both construction and retrieval.
weaknesses: - The ablation study seems coarse-grained. For example, when constructing Tri-Graph, the current method simultaneously incorporates co-occurrence relationships between entities and both passages and sentences. How would the final performance be affected if only passages, only sentences, or paragraphs instead?
- The main experiment only compared with vanilla RAG. What about comparisons with some advanced RAG methods, such as LightRAG, Lexical Diversity-aware RAG, and others?

---

confidence: 5
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Entity activation is a crucial initial step in LinearRAG. However, the authors do not clarify how the framework handles queries from which no entities can be extracted. Does the retrieval process halt in the absence of seed entities? Additionally, if extracted entities are ambiguous and cannot be disambiguated without the query’s full context, could this lead to activation of incorrect entities and degraded retrieval performance? An explanation addressing these scenarios would strengthen the paper.

2. In Equation 5, the matrix M is not defined. Moreover, since σ_q is a ∣S∣×1 vector (per Equation 4), its transpose σ_q^T is 1×∣S∣, which mismatches the dimension ∣V_e∣ of α_q^(t-1) (from Equation 3). A more detailed explanation of this equation and its dimensions is necessary.

3. LinearRAG’s dynamic pruning currently applies a fixed threshold across all expansions. Given that dynamic pruning aims to produce high-quality semantic paths, empirical evaluation of this fixed-threshold approach is warranted but absent from the manuscript. Furthermore, since distant entities are generally less important than closer ones, justification for using a uniform threshold would be valuable.

4. For evaluation using LLMs as judges, it is recommended to include multiple state-of-the-art LLMs from different providers to reduce bias stemming from reliance on a single model.
soundness: 3
strengths: S1: Addresses a timely and significant challenge relevant to both industry and academia.
S2: The proposed method is straightforward, achieving the fastest indexing speed alongside very low retrieval latency.
S3: Demonstrates competitive performance in token efficiency, content accuracy, and evaluation accuracy using large language models (LLMs) as judges.
summary: This paper introduces LinearRAG, a GraphRAG framework that streamlines graph construction by employing lightweight entity extraction instead of complex relation extraction. It constructs a hierarchical graph comprising entities, sentences, and passages and utilizes a two-stage retrieval strategy that integrates both local and global structural information to enhance precision and recall.
weaknesses: W1: Some equations lack clarity and contain unexpected errors.
W2: The effectiveness of the dynamic pruning mechanism is not empirically evaluated.
W3: Since LLMs serve as the evaluators, it would be beneficial to incorporate multiple state-of-the-art LLMs from diverse vendors to mitigate potential evaluation bias.


Decision: Accept (Poster)