SlimRAG: Retrieval without Graphs via Entity-Aware Context Selection

Jiale Zhang; Jiaxiang Chen; Jie Ding; Kui Zhao; Xin Pang; Yinghui Xu; Zenglin Xu; Zhucong Li

REVIEW 4 major objections 5 minor 1 cited by

SlimRAG: Retrieval without Graphs via Entity-Aware Context Selection

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read SlimRAG claims that graph-free, entity-aware retrieval outperforms graph-based RAG on HotpotQA accuracy and F1 while using a far more compact index.

desk verdict A simple graph-free retrieval design worth discussing, but the efficiency metric (RITU) is internally inconsistent and the single-dataset evaluation doesn't support the abstract's claims. read the letter →

arxiv 2506.17288 v1 pith:U4K5EQZP submitted 2025-06-15 cs.IR cs.AIcs.CL

Jiale Zhang , Jiaxiang Chen , Zhucong Li , Jie Ding , Kui Zhao , Zenglin Xu , Xin Pang , Yinghui Xu This is my paper

classification cs.IRcs.AIcs.CL

keywords retrieval-augmentedgenerationentity-awareretrievalinvertedindexsemanticrelevancecompactnessmulti-hopquestionansweringRITUgraph-freeRAG

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that structure-heavy RAG is over-engineered: entity linking, relation extraction, and subgraph traversal add cost and noise without ensuring query-relevant context, because embedding similarity is not the same as task relevance. To test this, SlimRAG builds only an entity-to-chunk inverted table at index time and, at query time, extracts salient entities, matches them to indexed entities by cosine similarity, and scores candidate chunks by combining embedding similarity with matched-entity count. On the multi-hop HotpotQA benchmark, SlimRAG reports the highest retrieval accuracy (57.41%) and F1 (58.36%) among the flat, tree, and graph baselines compared, with a Relative Index Token Utilization (RITU) of 16.31 versus 56.51 to 67.36 for graph-based methods. The paper also introduces RITU as a general metric for token-level index compactness. The core claim is that structure-free, entity-centric context selection can beat explicit graph structure on both retrieval quality and efficiency.

What carries the argument

The central object is the entity-to-chunk inverted map, a table that stores for every canonicalized entity the IDs of the chunks in which it appears. At query time, SlimRAG decomposes the question into sub-queries, extracts entities from them, retrieves the top $K$ index entities per query entity by cosine similarity, collects all chunks attached to the resulting hit-entity set, and scores each chunk $C_k$ as $\phi_q \cdot \mathrm{count}_k$, where $\phi_q$ is the query-chunk embedding similarity and $\mathrm{count}_k$ is the number of hit entities the chunk contains. The selected chunks are reordered by document position and merged under a token limit. The paper's efficiency metric RITU is the ratio of tokens used in index construction to total corpus tokens, and the reported 16.31 versus 56+ values are what carry the compactness argument.

What would settle it

On the same HotpotQA subset, replace the LLM-based entity extractor with an off-the-shelf NER tagger that does no coreference resolution. If retrieval accuracy stays near 57%, the paper's attribution of the gain to entity canonicalization is wrong; if it collapses toward the reported 38% no-module baseline, the entity-canonicalization machinery is confirmed as load-bearing. A second check: recompute RITU for all systems with a single tokenizer and index-construction definition; if SlimRAG's compactness advantage disappears, the efficiency claim is an artifact of metric normalization.

Watch

Extended reading notes

Core claim

The central discovery claim is that discarding graph edges entirely does not hurt multi-hop retrieval; it helps. SlimRAG decouples the role of embeddings into two stages: similarity organizes the index (canonicalized entities mapped to chunks), and relevance drives retrieval (query entities are matched to index entities, and each candidate chunk is scored by its embedding similarity to the query times the number of matched entities it contains). On HotpotQA this reaches 57.41% retrieval accuracy and 58.36% F1, above the best compared baseline RAPTOR (55.32% accuracy, 58.66% F1) and far above GraphRAG and LightRAG variants, while the index uses only 16.31 RITU against 56.51 to 67.36 for those graph systems. The authors interpret this as evidence that clean entity-level signals matter more than relational edges for query-focused retrieval.

Load-bearing premise

The whole accuracy result rests on the assumption that the language model correctly extracts and canonically names the same entities in both the question and the stored chunks, even when the same thing is mentioned in different surface forms; the paper's own ablation shows that removing coreference resolution drops retrieval accuracy by about 16 points.

Editorial extensions

If this is right

If the central claim is right, a graph-free entity-to-chunk table can replace graph construction in multi-hop QA retrieval while improving accuracy and cutting index tokens by roughly a factor of four.
RITU gives systems a single index-compactness number to report, making retrieval efficiency comparable across flat, tree, and graph-based RAG pipelines.
Coreference resolution is not a minor cleanup: the paper's own ablation shows removing it drops accuracy from 57.41% to 40.98%, so entity canonicalization is a primary determinant of this method's success.
Query decomposition contributes about five accuracy points, meaning multi-hop questions lose targeted evidence when the query is matched as one undivided string.
Because the index is an append-only entity-to-chunk table, corpus updates require adding entries rather than updating graph edges, which is the incremental-update advantage the paper claims.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A natural extension the authors do not test is whether the same entity-overlap scoring transfers to retrieval domains where the salient units are numbers, dates, or claims rather than named entities; those settings are where an entity-centric inverted index could fail.
The reported RITU values depend on what counts as index-construction tokens and on the tokenizer, so cross-system comparisons should be read as order-of-magnitude rather than exact arithmetic.
The similarity-versus-relevance split is operationalized here as multiplying an embedding score by an entity-count term; the same correction could be applied to any dense retriever without building a graph.
The method's cost is concentrated in LLM-based entity extraction, so the efficiency story would be stronger if a cheaper extractor could be distilled to match the coreference-resolved entity sets.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Here's the quick read. SlimRAG is a clean, graph-free retrieval pipeline for RAG: index entities per chunk, match query entities by embedding, score chunks by similarity times entity count, and assemble context. The system is simple and the ablation is honestly done — removing coreference resolution drops accuracy by 16 points, which tells you where the real work is. That part is worth a look.

The new claim, RITU as an index-compactness metric, does not survive contact with its own definition. In §Experiments, RITU = TUIC/TCTC with TUIC defined as 'total number of tokens processed during indexing.' For SlimRAG, entity extraction reads every chunk, so the input tokens alone are at least TCTC; with prompt and output tokens the ratio should be >1. Table 1 reports 16.31. The only way to get that number is to count something much smaller — presumably the unique entity-name tokens in the inverted index. That's a legitimate measure, but it's not what is written. The same ambiguity applies to the baseline numbers, so the '4x more compact' conclusion is unsupported. This is not a nitpick; the efficiency claim is half the paper's value proposition.

Other soft spots: the abstract says 'multiple QA benchmarks' but the experiments are only HotpotQA. There are no error bars or significance tests. The baselines appear to be lifted from Zhou et al. 2025 with some 'estimates' — not clearly re-run in-house. Code is not released, and the metric definitions are loose enough that reproducibility would be hard. Also, the evaluation is retrieval-only; there's no end-to-end generation accuracy, so calling it RAG is a bit of a stretch.

What's genuinely good: the system is simple, the ablation is telling, and the idea of decoupling similarity (for indexing) from relevance (for retrieval) is sensible even if the philosophical framing is not novel. The paper reads like an honest engineering report, not a hype job.

Bottom line: this deserves a serious referee, but the RITU metric needs to be redefined and recomputed, the benchmark claim needs to match the actual eval, and the code should be out before acceptance. If those are fixed, the accuracy comparison on HotpotQA could be a useful data point for the field.

Referee Report

4 major / 5 minor

Summary. The paper proposes SlimRAG, a retrieval-augmented generation framework that replaces graph-based indexing with a lightweight entity-to-chunk inverted index. At indexing time, entities are extracted from chunks (with coreference resolution) and linked to their chunks; at query time, the query is decomposed, entities are extracted, matched to corpus entities by embedding similarity, and chunks are scored by a product of query-chunk similarity and hit-entity count. The paper claims that this structure-free design achieves higher retrieval accuracy and F1 than flat, tree, and graph baselines on HotpotQA while using a much more compact index, as measured by the proposed Relative Index Token Utilization (RITU). An ablation shows that coreference resolution and query decomposition both contribute substantially. The claimed results are: 57.41% accuracy, 59.33% recall, 58.36% F1, RITU 16.31, and index time 2,164 seconds, compared with graph-based baselines with RITU 56.51–67.36.

Significance. If the method and metrics are sound, the contribution is useful: it is a simple, modular, and inexpensive alternative to graph-based RAG that decouples entity extraction from relation modeling, and the RITU metric, once properly defined, could become a standard measure of index compactness. The paper is open about the role of coreference resolution and provides an ablation study and a case study. However, the claimed significance rests on two pillars that need strengthening: the efficiency claim is currently undermined by an inconsistent definition of RITU, and the accuracy claim is supported by only a single benchmark with no error bars. The central retrieval idea is straightforward and potentially reproducible, but the experimental evidence as presented is not yet sufficient for a strong claim of superiority.

major comments (4)

[Experiments (RITU definition, Table 1)]
[Abstract vs. Experiments]
[Experiments (Evaluation metrics and statistical reliability)]
[Method (Entity matching and coreference sensitivity)]

minor comments (5)

[Notation (Method, Algorithm 1, Appendix)]
[Table 1 caption]
[Table 1 and Figure 5]
[Case study (Figure 6)]
[Related Work]

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: SlimRAG's accuracy and efficiency claims are empirical comparisons against external baselines, with no fitted inputs renamed as predictions and no load-bearing self-citations.

full rationale

The central retrieval-accuracy claim (57.41% accuracy, 58.36% F1 on HotpotQA) is an experimental result measured against gold supporting facts with flat, tree, and graph baselines, not a quantity derived from SlimRAG's own definitions. The index/retrieval pipeline (entity extraction, inverted entity-to-chunk map, cosine entity matching, dual-factor scoring) is a proposed architecture rather than a derivation, and its ablation study is a controlled empirical test. No parameter is fit to the test set and then reported as a prediction; hyperparameters K=5 and H=10 are fixed and stated. The paper contains no self-citations that carry a load-bearing premise, and no uniqueness or ansatz is imported from the authors' prior work. The RITU metric is author-proposed, but its use is not circular: it does not enter the retrieval accuracy computation, and the efficiency comparison is an empirical measurement or estimate stated in the paper. A possible ambiguity between RITU's stated definition, 'total number of tokens processed during indexing,' and the reported value is a metric-consistency and validity concern, not a circularity, and therefore does not raise the circularity score.

Assumptions & free parameters 4 free parameters · 3 assumptions · 0 invented entities

No new physical or conceptual entities are introduced. The free parameters are standard hyperparameters and model choices, and the axioms are domain assumptions about LLM extraction quality and embedding matching reliability.

free parameters (4)

K = 5
Number of top similar corpus entities retrieved per query entity during semantic expansion. Chosen by hand, not tuned.
H = 10
Number of sentences in the final retrieved context. Chosen by hand, not tuned.
Entity extraction model = gpt-4o-mini
Proprietary LLM used for entity extraction and coreference resolution. The choice of model affects performance and is not independently justified.
Embedding model = text-embedding-3-small
OpenAI embedding model used for all similarities. Choice is a manual selection.

assumptions (3)

domain assumption Cosine similarity in the chosen embedding space reliably matches query entities to corpus entities.
The retrieval phase assumes that RetrieveTopK over entity embeddings correctly identifies the same entities even when surface forms differ. No analysis of matching failures is provided.
domain assumption The LLM-based entity extraction with coreference resolution produces accurate and complete entity sets.
The ablation shows a 16-point accuracy drop without coreference resolution, indicating the method's heavy reliance on this extraction quality.
domain assumption The HotpotQA evaluation protocol follows Zhou et al. 2025 and is fair across all baselines.
The paper states this but provides no details of baseline implementations, hyperparameters, or exact data splits.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SlimRAG: Retrieval without Graphs via Entity-Aware Context Selection." pith.science (2026). https://pith.science/paper/U4K5EQZP

@misc{pith2026250617288,
  author       = {Pith},
  title        = {Pith review of: SlimRAG: Retrieval without Graphs via Entity-Aware Context Selection},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/U4K5EQZP}},
  note         = {Machine review of arXiv:2506.17288}
}

read the original abstract

Retrieval-Augmented Generation (RAG) enhances language models by incorporating external knowledge at inference time. However, graph-based RAG systems often suffer from structural overhead and imprecise retrieval: they require costly pipelines for entity linking and relation extraction, yet frequently return subgraphs filled with loosely related or tangential content. This stems from a fundamental flaw -- semantic similarity does not imply semantic relevance. We introduce SlimRAG, a lightweight framework for retrieval without graphs. SlimRAG replaces structure-heavy components with a simple yet effective entity-aware mechanism. At indexing time, it constructs a compact entity-to-chunk table based on semantic embeddings. At query time, it identifies salient entities, retrieves and scores associated chunks, and assembles a concise, contextually relevant input -- without graph traversal or edge construction. To quantify retrieval efficiency, we propose Relative Index Token Utilization (RITU), a metric measuring the compactness of retrieved content. Experiments across multiple QA benchmarks show that SlimRAG outperforms strong flat and graph-based baselines in accuracy while reducing index size and RITU (e.g., 16.31 vs. 56+), highlighting the value of structure-free, entity-centric context selection. The code will be released soon. https://github.com/continue-ai-company/SlimRAG

Figures

Figures reproduced from arXiv: 2506.17288 by the authors.

**Figure 2.** Semantic similarity may mislead relevancebased retrieval. Cosine similarity heatmap between the query “What is the gender of this waiter?” and various related entities. Although Waiter and Waitress show the highest similarity, they are not useful for answering the query. More relevant entities like Male are semantically farther, underscoring the need to distinguish similarity from relevance during retrieval. Thi… view at source ↗

**Figure 3.** Overview of the SlimRAG pipeline. The framework consists of two main stages: Indexing Phase and Retrieval Phase. In the indexing stage (left), raw documents from heterogeneous sources (e.g., CSV, PDF, web) are segmented into chunks, from which salient entities are extracted. These entities are then organized into a lightweight inverted index that maps each entity to the set of chunks in which it appears. During retr… view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: SlimRAG vs. Baselines on HotpotQA. Radar chart comparing SlimRAG and five baselines on accuracy, recall, F1, indexing time, and RITU (lower is better). Values are min-max normalized. SlimRAG shows strong overall performance with low indexing overhead. in (Zhou et al.…

**Figure 5.** Figure 5: Indexing Efficiency vs. Corpus Size. Index construction cost (solid lines, USD) and elapsed time (dashed lines, seconds) for SlimRAG, LightRAG, and GraphRAG on HotpotQA. SlimRAG consistently incurs lower cost and latency as corpus size increases, highlighting its scal…

**Figure 6.** Figure 6: Case study on a sample multi-hop HotpotQA question. We show the top-ranked context returned by LightRAG (34 137 [PITH_FULL_IMAGE:figures/full_fig_p008_6.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Collaborative Inference and Learning between Edge SLMs and Cloud LLMs: A Survey of Algorithms, Execution, and Open Challenges
cs.DC 2025-07 conditional novelty 4.0 of 10

A survey that builds a taxonomy of edge-cloud LLM-SLM collaboration for inference and training, claiming to be the first to unify both phases.

Reference graph

Works this paper leans on

37 extracted references · 10 canonical work pages · cited by 1 Pith paper

[1]

, " * write output.state after.block = add.period write newline

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...
[3]

Chen, H.; Shen, X.; Lv, Q.; Wang, J.; Ni, X.; and Ye, J. 2024 a . SAC-KG : Exploiting Large Language Models as Skilled Automatic Constructors for Domain Knowledge Graphs . arXiv:2410.02811

arXiv 2024
[4]

Chen, T.; Wang, H.; Chen, S.; Yu, W.; Ma, K.; Zhao, X.; Zhang, H.; and Yu, D. 2024 b . Dense X Retrieval : What Retrieval Granularity Should We Use ? arXiv:2312.06648

arXiv 2024
[5]

Dinan, E.; Roller, S.; Shuster, K.; Fan, A.; Auli, M.; and Weston, J. 2019. W izard of W ikipedia: Knowledge-Powered Conversational Agents. In International Conference on Learning Representations

work page 2019
[6]

Edge, D.; Trinh, H.; Cheng, N.; Bradley, J.; Chao, A.; Mody, A.; Truitt, S.; and Larson, J. 2024. From Local to Global: A Graph RAG Approach to Query-Focused Summarization. arXiv:2404.16130

arXiv 2024
[7]

Fan, W.; Ding, Y.; Ning, L.; Wang, S.; Li, H.; Yin, D.; Chua, T.-S.; and Li, Q. 2024. A survey on rag meeting llms: Towards retrieval-augmented large language models. In International Conference on Knowledge Discovery and Data Mining (KDD), 6491--6501

work page 2024
[8]

Gao, L.; Ma, X.; Lin, J.; and Callan, J. 2022. Precise zero-shot dense retrieval without relevance labels. arXiv preprint arXiv:2212.10496

arXiv 2022

Show all 37 references

[9]

Gao, Y.; Xiong, Y.; Gao, X.; Jia, K.; Pan, J.; Bi, Y.; Dai, Y.; Sun, J.; and Wang, H. 2023. Retrieval-augmented generation for large language models: A survey. arXiv preprint arXiv:2312.10997

2023 arXiv
[10]

Guo, Z.; Xia, L.; Yu, Y.; Ao, T.; and Huang, C. 2024. LightRAG : Simple and Fast Retrieval-Augmented Generation. arXiv:2410.05779

2024 arXiv
[11]

D.; Sugawara, S.; and Aizawa, A

Ho, X.; Nguyen, A.-K. D.; Sugawara, S.; and Aizawa, A. 2020. Constructing A Multi-hop QA Dataset for Comprehensive Evaluation of Reasoning Steps. In Proceedings of the 28th International Conference on Computational Linguistics, 6609--6625

2020
[12]

Huang, L.; Cao, S.; Parulian, N.; Ji, H.; and Wang, L. 2021. Efficient Attentions for Long Document Summarization. In 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2021, 1419--1436. Associ...

2021
[13]

Huang, Y.; and Huang, J. 2024. A Survey on Retrieval-Augmented Text Generation for Large Language Models . arXiv:2404.10981

2024 arXiv
[14]

J.; Madotto, A.; and Fung, P

Ji, Z.; Lee, N.; Frieske, R.; Yu, T.; Su, D.; Xu, Y.; Ishii, E.; Bang, Y. J.; Madotto, A.; and Fung, P. 2023. Survey of hallucination in natural language generation. ACM Computing Surveys, 55(12): 1--38

2023
[15]

u ttler, H.; Lewis, M.; Yih, W.-t.; Rockt \

Lewis, P.; Perez, E.; Piktus, A.; Petroni, F.; Karpukhin, V.; Goyal, N.; K \"u ttler, H.; Lewis, M.; Yih, W.-t.; Rockt \"a schel, T.; Riedel, S.; and Kiela, D. 2020. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. In Advances in Neural Information Processing ...

2020
[16]

Li, M.; Miao, S.; and Li, P. 2024. Simple is Effective: The Roles of Graphs and Large Language Models in Knowledge-Graph-Based Retrieval-Augmented Generation. arXiv:2410.20724

2024 arXiv
[17]

Li, W.; Liu, K.; Zhang, X.; Lei, X.; Ma, W.; and Liu, Y. 2025. Efficient Dynamic Clustering-Based Document Compression for Retrieval-Augmented-Generation . arXiv:2504.03165

2025 arXiv
[18]

Liang, L.; Sun, M.; Gui, Z.; Zhu, Z.; Jiang, Z.; Zhong, L.; Qu, Y.; Zhao, P.; Bo, Z.; Yang, J.; Xiong, H.; Yuan, L.; Xu, J.; Wang, Z.; Zhang, Z.; Zhang, W.; Chen, H.; Chen, W.; and Zhou, J. 2024. KAG : Boosting LLMs in Professional Domains via Knowledge Augmented Generation . ...

2024 arXiv
[19]

Liu, J.; Li, L.; Xiang, T.; Wang, B.; and Qian, Y. 2023. TCRA-LLM: Token Compression Retrieval Augmented Large Language Model for Inference Cost Reduction. arXiv:2310.15556

2023 arXiv
[20]

Luo, K.; Liu, Z.; Xiao, S.; and Liu, K. 2024. BGE Landmark Embedding: A Chunking-Free Embedding Method For Retrieval Augmented Long-Context Large Language Models. arXiv:2402.11573

2024 arXiv
[21]

Qian, H.; Liu, Z.; Mao, K.; Zhou, Y.; and Dou, Z. 2024. Grounding Language Model with Chunking-Free In-Context Retrieval. arXiv:2402.09760

2024 arXiv
[22]

R.; Fard, R

Rezaei, M. R.; Fard, R. S.; Parker, J.; Krishnan, R. G.; and Lankarany, M. 2025. Adaptive Knowledge Graphs Enhance Medical Question Answering : Bridging the Gap Between LLMs and Evolving Medical Knowledge . arXiv:2502.13010

2025 arXiv
[23]

Sanmartin, D. 2024. Kg-rag: Bridging the gap between knowledge and creativity. arXiv preprint arXiv:2405.12035

2024 arXiv
[24]

Sarmah, B.; Hall, B.; Rao, R.; Patel, S.; Pasquali, S.; and Mehta, D. 2024. HybridRAG : Integrating Knowledge Graphs and Vector Retrieval Augmented Generation for Efficient Information Extraction. arXiv:2408.04948

2024 arXiv
[25]

Shuster, K.; Poff, S.; Chen, M.; Kiela, D.; and Weston, J. 2021. Retrieval Augmentation Reduces Hallucination in Conversation. In Findings of the Association for Computational Linguistics: EMNLP 2021, 3784--3803. Punta Cana, Dominican Republic: Association for Computational Li...

2021
[26]

W.; Morris, J

Soman, K.; Rose, P. W.; Morris, J. H.; Akbas, R. E.; Smith, B.; Peetoom, B.; Villouta-Reyes , C.; Cerono, G.; Shi, Y.; Rizk-Jackson , A.; Israni, S.; Nelson, C. A.; Huang, S.; and Baranzini, S. E. 2023. Biomedical Knowledge Graph-Enhanced Prompt Generation for Large Language M...

2023 arXiv
[27]

Steck, H.; Ekanadham, C.; and Kallus, N. 2024. Is Cosine-Similarity of Embeddings Really About Similarity ? In Companion Proceedings of the ACM Web Conference 2024 , 887--890

2024
[28]

A.; Waltman, L.; and van Eck , N

Traag, V. A.; Waltman, L.; and van Eck , N. J. 2019. From Louvain to Leiden: Guaranteeing Well-Connected Communities. Scientific Reports, 9: 5233

2019
[29]

Trivedi, H.; Balasubramanian, N.; Khot, T.; and Sabharwal, A. 2022. MuSiQue: Multihop Questions via Single-hop Question Composition. Transactions of the Association for Computational Linguistics, 10: 539--554

2022
[30]

R.; and Neubig, G

Wang, Z.; Araki, J.; Jiang, Z.; Parvez, M. R.; and Neubig, G. 2023. Learning to Filter Context for Retrieval-Augmented Generation. arXiv:2311.08377

2023 arXiv
[31]

Wu, S.; Xie, J.; Chen, J.; Zhu, T.; Zhang, K.; and Xiao, Y. 2024. How Easily Do Irrelevant Inputs Skew the Responses of Large Language Models ? arXiv:2404.03302

2024 arXiv
[32]

Xu, F.; Shi, W.; and Choi, E. 2023. RECOMP: Improving Retrieval-Augmented LMs with Compression and Selective Augmentation. arXiv:2310.04408

2023 arXiv
[33]

Xu, Y.; He, S.; Chen, J.; Wang, Z.; Song, Y.; Tong, H.; Liu, G.; Liu, K.; and Zhao, J. 2024. Generate-on- Graph : Treat LLM as Both Agent and KG in Incomplete Knowledge Graph Question Answering . arXiv:2404.14741

2024 arXiv
[34]

H.; Li, W.; Cheng, L.; Chen, Q.; Caverlee, J.; Matsuo, Y.; and Li, I

Yang, R.; Liu, H.; Marrese-Taylor , E.; Zeng, Q.; Ke, Y. H.; Li, W.; Cheng, L.; Chen, Q.; Caverlee, J.; Matsuo, Y.; and Li, I. 2024. KG-Rank : Enhancing Large Language Models for Medical QA with Knowledge Graphs and Ranking Techniques . arXiv:2403.05881

2024 arXiv
[35]

W.; Salakhutdinov, R.; and Manning, C

Yang, Z.; Qi, P.; Zhang, S.; Bengio, Y.; Cohen, W. W.; Salakhutdinov, R.; and Manning, C. D. 2018. HotpotQA : A Dataset for Diverse, Explainable Multi-Hop Question Answering. arXiv:1809.09600

2018 arXiv
[36]

Zhong, M.; Yin, D.; Yu, T.; Zaidi, A.; Mutuma, M.; Jha, R.; Hassan, A.; Celikyilmaz, A.; Liu, Y.; Qiu, X.; et al. 2021. QMSum: A New Benchmark for Query-based Multi-domain Meeting Summarization. In Proceedings of the 2021 Conference of the North American Chapter of the Associa...

2021
[37]

Zhou, Y.; Su, Y.; Sun, Y.; Wang, S.; Wang, T.; He, R.; Zhang, Y.; Liang, S.; Liu, X.; Ma, Y.; and Fang, Y. 2025. In-Depth Analysis of Graph-Based RAG in a Unified Framework. arXiv:2503.04338

2025 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

, " * write output.state after.block = add.period write newline

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

[3] [3]

Chen, H.; Shen, X.; Lv, Q.; Wang, J.; Ni, X.; and Ye, J. 2024 a . SAC-KG : Exploiting Large Language Models as Skilled Automatic Constructors for Domain Knowledge Graphs . arXiv:2410.02811

arXiv 2024

[4] [4]

Chen, T.; Wang, H.; Chen, S.; Yu, W.; Ma, K.; Zhao, X.; Zhang, H.; and Yu, D. 2024 b . Dense X Retrieval : What Retrieval Granularity Should We Use ? arXiv:2312.06648

arXiv 2024

[5] [5]

Dinan, E.; Roller, S.; Shuster, K.; Fan, A.; Auli, M.; and Weston, J. 2019. W izard of W ikipedia: Knowledge-Powered Conversational Agents. In International Conference on Learning Representations

work page 2019

[6] [6]

Edge, D.; Trinh, H.; Cheng, N.; Bradley, J.; Chao, A.; Mody, A.; Truitt, S.; and Larson, J. 2024. From Local to Global: A Graph RAG Approach to Query-Focused Summarization. arXiv:2404.16130

arXiv 2024

[7] [7]

Fan, W.; Ding, Y.; Ning, L.; Wang, S.; Li, H.; Yin, D.; Chua, T.-S.; and Li, Q. 2024. A survey on rag meeting llms: Towards retrieval-augmented large language models. In International Conference on Knowledge Discovery and Data Mining (KDD), 6491--6501

work page 2024

[8] [8]

Gao, L.; Ma, X.; Lin, J.; and Callan, J. 2022. Precise zero-shot dense retrieval without relevance labels. arXiv preprint arXiv:2212.10496

arXiv 2022