Don't Do RAG: When Cache-Augmented Generation is All You Need for Knowledge Tasks

Brian J Chan; Chao-Ting Chen; Hen-Hsen Huang; Jui-Hung Cheng

REVIEW 3 major objections 7 minor 5 cited by

Don't Do RAG: When Cache-Augmented Generation is All You Need for Knowledge Tasks

T0 review · 3 major / 7 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Cache-augmented generation—preloading all documents once into a long-context LLM's key-value cache—matches or beats retrieval-augmented generation on small knowledge bases while removing retrieval latency and errors.

desk verdict CAG's speed-up idea is real, but the accuracy comparison hands it the answer passages on a plate, so the main claim doesn't survive. read the letter →

arxiv 2412.15605 v2 pith:SDQOVIB3 submitted 2024-12-20 cs.CL

Brian J Chan , Chao-Ting Chen , Jui-Hung Cheng , Hen-Hsen Huang This is my paper · ORCID

classification cs.CL

keywords cache-augmentedgenerationretrieval-augmentedlong-contextLLMsKVcacheretrieval-freequestionansweringBERTScoreHotPotQASQuAD

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 when all relevant documents fit inside a large language model's context window, the standard retrieval-augmented generation pipeline is an unnecessary source of latency, errors, and complexity. Instead of retrieving documents at query time, the authors propose cache-augmented generation (CAG): encode the full document set once, store the resulting key-value cache, and at inference time feed only the query to the model with that cache attached. On SQuAD and HotPotQA subsets of 3–64 documents, they report that CAG achieves the highest BERTScore in most configurations while reducing response time by eliminating retrieval and avoiding recomputation of the document context. The practical stake is that systems with a small, stable knowledge base—company FAQs, internal documentation, customer-support logs—could replace a RAG stack with a single preloaded model. The paper frames the result as a challenge to the default use of RAG, with the explicit caveat that the advantage depends on the document collection being manageable in size.

What carries the argument

The load-bearing mechanism is the precomputed key-value (KV) cache of the transformer: the stored attention state produced by encoding the document set. The pipeline writes $C_{KV} = \mathrm{KV\text{-}Encode}(D)$ once offline, then at inference appends only the query tokens to this cache, so generation is conditioned on the full document set without recomputing it or retrieving from it. The cache-reset step truncates appended tokens, allowing rapid reuse across sessions. This mechanism is what converts 'put everything in context' from a latency-heavy per-query operation into a one-time cost.

What would settle it

Run the HotPotQA comparison with the information asymmetry removed: build a corpus of, say, 256 documents, draw questions from hidden target documents, preload CAG with a fixed random 64-document slice that may or may not contain the targets, and let both sparse and dense RAG retrieve over the full corpus. Record BERTScore per system. If either RAG variant matches CAG's score under equal uncertainty, the claim that preloading full context prevents retrieval errors and yields comparable or better accuracy is not supported; if CAG still wins, the claim is supported.

Watch

Extended reading notes

Core claim

The paper's central claim is that, for knowledge tasks whose reference material fits in a long-context model, real-time retrieval is an avoidable source of latency, error, and complexity. To show this, the authors introduce cache-augmented generation (CAG), where a document set $D$ is encoded once into a KV cache $C_{KV} = \mathrm{KV\text{-}Encode}(D)$, and every query is answered by generating from $M(q \mid C_{KV})$ with no retrieval step. On SQuAD and HotPotQA subsets sized so that CAG's context contains the full reference text, they report that CAG attains the highest BERTScore in most configurations (for example, 0.7951 versus 0.7676 for the best sparse-RAG result on HotPotQA-small, and 0.7734 versus 0.7658 on SQuAD-large), while sparse retrieval still costs retrieval time and dense retrieval costs substantial latency. The authors also report that the accuracy gap narrows as the document count grows, which they attribute to known long-context degradation, and they position CAG as most suitable for constrained, manageable knowledge bases such as internal documentation and FAQs.

Load-bearing premise

The load-bearing premise is that the evaluation preloads CAG with the exact small set of answer-bearing passages the test questions were drawn from, while the RAG baselines must search the whole collection; if the two systems faced the same unknown corpus, or if the retriever were given the answer-bearing passages, the reported accuracy advantage would most likely shrink or disappear.

Editorial extensions

If this is right

For a stable knowledge base that fits in the model's context window, CAG removes the retriever component entirely, which eliminates retrieval latency and the maintenance burden of an index while keeping all documents in view.
Because the document context is encoded once and reused, per-query cost is just the query tokens plus generation, so CAG becomes increasingly faster than re-encoding the full context at inference time.
The performance gap over RAG narrows as the document set grows, so the benefit is largest for small-to-medium corpora; the same trend predicts a crossover point beyond which retrieval becomes necessary.
Preloading and selective retrieval are not mutually exclusive: a hybrid system could cache a foundation corpus and retrieve only for rare or highly specific queries, as the paper's conclusion suggests.

Reading between the lines

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

The reported comparison is asymmetric: CAG is preloaded with the exact document subset whose questions are asked, while RAG must retrieve from the full set. A more even test—preloading CAG from a larger or random pool, or handing RAG the answer-bearing passages—would likely shrink the accuracy margin, so the paper's strongest defensible claim is about the efficiency and simplicity of preloading, n
The real-world niche suggested by the paper is closed-domain question answering over stable corpora small enough to cache; the same logic would extend to per-topic caches with a lightweight router, which would recover some of RAG's flexibility while keeping per-query retrieval-free.
A natural stress test is corpus size: since the paper observes the gap narrowing as documents grow, there should be a crossover point where retrieval wins, and identifying that point empirically would turn 'CAG is all you need' into a scoped engineering rule rather than a general slogan.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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

Chan et al. propose CAG: preload a small knowledge base into a long-context LLM's context, cache the KV states, and answer queries with no retrieval at inference. The speed-up concept is sensible, the paper explains it clearly, and the code is public. The comparison against standard in-context learning (re-encoding the same text per query) does show the expected benefit of a precomputed cache.

The problem is the accuracy evaluation. In Section 3.1, for each test set they sample a small document subset D_s, take QA pairs tied to those documents, preload D_s into CAG, and then let the RAG baselines retrieve from the larger dataset. That hands CAG the exact passages containing every answer, while RAG has to find them among thousands of documents. This is not an oracle-retrieval control; it is a rigged comparison. The correct baseline is RAG with an index over the same constrained D_s, or CAG with an uncurated larger context. Without that, Table 2 mainly measures known retrieval failure, not a cache advantage.

There are additional issues. All accuracy numbers are BERTScore on SQuAD and HotPotQA, which are span-answer benchmarks; BERTScore rewards plausible paraphrase, so the 'accurate responses' claim is not verified with exact-match or token-level F1. No error bars are reported. On efficiency, the paper's own Table 3 shows sparse RAG top-3 total time (0.7414s) beating CAG's generation time alone (0.8512s) on HotPotQA-small, and cache loading is excluded from CAG's time. That is a smaller caveat, but it undercuts the blanket 'eliminates latency' slogan.

On novelty: the ingredients are prior art. TurboRAG [8] already uses precomputed KV caches, and refs [4,7] already show long-context LLMs can replace RAG. The contribution here is the packaging plus a cache-reset mechanism, not a new method. The paper's own Limitations section honestly admits the approach becomes impractical for larger datasets, but it never acknowledges the evaluation's structural inequity.

Who is this paper for? Practitioners with a genuinely small, closed knowledge base who want a quick retrieval-free recipe. The recipe itself is plausible and worth trying. But the paper as written overclaims on accuracy. If I were the editor, I would send it to a serious referee because the question is useful and the code is available, but the referee's first request would be a fair comparison with an oracle-retrieval control. As it stands, the central claim fails.

Referee Report

3 major / 7 minor

Summary. The paper proposes cache-augmented generation (CAG), a retrieval-free alternative to RAG that preloads a knowledge source into a long-context LLM, precomputes the KV cache offline, and answers queries without performing retrieval at inference time. The authors compare CAG against sparse (BM25) and dense (OpenAI-index) RAG baselines on SQuAD and HotPotQA subsets of varying size, reporting BERTScore for accuracy and wall-clock times for efficiency. The central claim is that CAG eliminates retrieval latency and retrieval errors while achieving comparable or superior answer quality, making it a streamlined alternative for constrained knowledge bases. The paper includes a public code release, which is commendable.

Significance. If the claims were conclusively supported, the paper would be a useful practical contribution to the ongoing discussion of when long-context models can replace retrieval pipelines. The idea of amortizing the cost of reading a fixed knowledge base through a precomputed KV cache is sensible and aligns with several recent systems. However, the experimental comparison as designed does not isolate the claimed advantages: the preloading protocol guarantees CAG access to the answer-bearing documents while the RAG baselines appear to retrieve from the full corpus, and no oracle-retrieval control is reported. The efficiency results also do not uniformly support the latency narrative. Because these issues bear directly on the central 'comparable or superior results' claim, the current evidence is insufficient to validate the paper's main conclusion, despite the soundness of the underlying concept.

major comments (3)

[Section 3.1, Table 2] The test-set construction biases the central comparison. For each configuration, a document subset D_s is sampled and QA pairs associated with D_s are selected as test instances; CAG then preloads the entire D_s into its context, guaranteeing that the answer-bearing passages are present. The RAG baselines, by contrast, are described as fetching passages from the 'respective dataset', which appears to be the full SQuAD or HotPotQA corpus. In that setting, RAG must retrieve the relevant passages from a much larger index, so the accuracy gap in Table 2 may reflect retrieval failure rather than any property of precomputed caching. The authors must clarify which index the RAG systems use and must add an oracle-retrieval control in which the RAG generator is given the gold supporting passages (or all of D_s) as context. Without such a control, the claim that CAG achieves 'comparable or superior results' is not established.
[Table 3] The efficiency claim is not uniformly supported by the reported numbers. For HotPotQA-small, the sparse RAG top-3 configuration has a total response time of 0.0008 + 0.7406 = 0.7414 seconds, which is lower than CAG's generation time alone (0.8512 seconds). Sparse retrieval latency is negligible (0.0008 seconds), so the statement that CAG 'eliminates retrieval latency' is only meaningful relative to dense RAG. Moreover, CAG's cache loading time is not included in the comparison, and CAG's generation time grows with context length (0.8512 to 2.2631 seconds across the three HotPotQA sizes). The authors should report end-to-end times including cache construction/loading and should qualify the latency claim in light of the sparse-RAG results.
[Section 3.3, Table 2] Accuracy is evaluated only with BERTScore, with no variance, confidence intervals, or significance tests. On SQuAD and HotPotQA, whose answers are short spans, BERTScore can reward semantically plausible but incorrect answers, and the reported differences are often small (e.g., 0.7695 vs. 0.7616 for SQuAD-small CAG vs. sparse RAG top-1). To support the phrase 'superior results', the authors should report exact-match/F1 or another span-level metric and provide statistical reliability measures. This is particularly important because the BERTScore gaps shrink as the knowledge size grows, and the conclusion that CAG is consistently superior rests on differences that may be within noise.

minor comments (7)

[Abstract] The phrase 'CAG provide a streamlined and efficient alternative' is a grammatical error; it should be 'CAG provides'.
[Section 2, Eq. (1)] The notation 'KV-Encode(D)' is introduced informally; specifying that this is a forward pass over the document set with the KV cache retained would improve precision.
[Section 3.1, Table 1] The SQuAD configurations use only 3, 4, and 7 documents, which are extremely small knowledge bases; the authors should justify these sizes or discuss why they are representative of constrained knowledge scenarios.
[Section 3.2] The dense retrieval baseline, 'OpenAI Indexes', is not an open and reproducible system; using a public dense retriever (e.g., DPR or Contriever) would strengthen reproducibility.
[Table 3] The 'In-Context Learning' baseline is mentioned in the table but never described in the methodology; the authors should define this baseline and its relationship to CAG.
[Figure 2] The caption states that the x-axis represents response time, but the figure shows categorical bar groups; the caption should be reworded to describe the bar structure accurately.
[Limitations] The limitation that CAG becomes impractical for large datasets is acknowledged, but it should also appear in the abstract or conclusion because it substantially qualifies the 'streamlined alternative' framing.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: CAG's superiority claim is an empirical full-context-versus-top-k comparison, not a derivation that reduces to its inputs.

full rationale

The paper's derivation chain is architectural and empirical, not self-referential. Equations (1) and (2) define CAG as preloading all documents D and using a precomputed KV cache C_KV, while Equation (3) defines RAG as retrieving top-k passages P_k before generation. The reported accuracy advantage of CAG is an experimental result obtained by comparing these two distinct input constructions, not an algebraic consequence of the definitions. The test-set construction (Section 3.1, 'QA pairs associated with D_s were selected as test instances') matches the paper's explicitly stated scope of a constrained, fully preloadable knowledge base, and Section 3.2 states that RAG baselines retrieve 'exclusively from the respective dataset,' so both methods operate over the same underlying corpus. No fitted parameter is renamed as a prediction, no load-bearing self-citation appears, no uniqueness theorem is imported from the authors' prior work, and no ansatz is smuggled in via citation; the closest prior work TurboRAG is cited as related work rather than as the source of the paper's own claims. The absence of an oracle-retrieval control and the reliance on BERTScore only are legitimate experimental-design and validity criticisms, but they do not make the central claim equivalent to its inputs by construction. The claim that CAG 'eliminates retrieval latency' is a definitional property of an architecture with no retrieval step, not a derived result; as such, it is not circular. Overall, the central comparison is self-contained and falsifiable, appealing to external benchmarks and measured timings rather than to its own assumptions.

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

The method has no fitted parameters and introduces no new physical or conceptual entities. The main assumptions are about the evaluation protocol (gold document subset given to CAG), the model's effective long-context capability, and the validity of KV cache precomputation for exact conditional matching.

assumptions (3)

domain assumption The preloaded document subset D_s contains all documents needed to answer the selected QA pairs.
Section 3.1 states 'QA pairs associated with D_s were selected as test instances.' This guarantees CAG has the answer-bearing passages in context, while RAG must retrieve from the full dataset.
domain assumption Llama 3.1 8B can effectively use all preloaded tokens in its context window during generation with a precomputed KV cache.
Section 3.1 uses Llama 3.1 8B with 128K context; the preloading assumes the model can reason over 21k-85k token contexts without degradation beyond what is observed.
domain assumption KV cache precomputation with the same model yields exactly the same conditional distribution as re-encoding the documents with the query at inference.
Equation 2 assumes M(D ⊕ q) = M(q | C_KV). This is standard for transformer decoding, but the paper does not discuss position ID handling, which TurboRAG [8] identified as a complication.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Don't Do RAG: When Cache-Augmented Generation is All You Need for Knowledge Tasks." pith.science (2026). https://pith.science/paper/SDQOVIB3

@misc{pith2026241215605,
  author       = {Pith},
  title        = {Pith review of: Don't Do RAG: When Cache-Augmented Generation is All You Need for Knowledge Tasks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/SDQOVIB3}},
  note         = {Machine review of arXiv:2412.15605}
}

read the original abstract

Retrieval-augmented generation (RAG) has gained traction as a powerful approach for enhancing language models by integrating external knowledge sources. However, RAG introduces challenges such as retrieval latency, potential errors in document selection, and increased system complexity. With the advent of large language models (LLMs) featuring significantly extended context windows, this paper proposes an alternative paradigm, cache-augmented generation (CAG) that bypasses real-time retrieval. Our method involves preloading all relevant resources, especially when the documents or knowledge for retrieval are of a limited and manageable size, into the LLM's extended context and caching its runtime parameters. During inference, the model utilizes these preloaded parameters to answer queries without additional retrieval steps. Comparative analyses reveal that CAG eliminates retrieval latency and minimizes retrieval errors while maintaining context relevance. Performance evaluations across multiple benchmarks highlight scenarios where long-context LLMs either outperform or complement traditional RAG pipelines. These findings suggest that, for certain applications, particularly those with a constrained knowledge base, CAG provide a streamlined and efficient alternative to RAG, achieving comparable or superior results with reduced complexity.

Figures

Figures reproduced from arXiv: 2412.15605 by the authors.

**Figure 2.** Response Time Comparison on HotPotQA (Sec [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 5 Pith papers

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

Log-Augmented Generation: Scaling Test-Time Reasoning with Reusable Computation
cs.CL 2025-05 conditional novelty 6.0 of 10

By storing KV caches of prior reasoning traces and retrieving them during generation, LAG improves LLM agent accuracy and efficiency over standard agentic systems and reflection methods.
Memorization and Knowledge Injection in Gated LLMs
cs.CL 2025-04 conditional novelty 6.0 of 10

MEGa injects episodic memories into separate gated LoRA adapters selected by embedding similarity, mitigating catastrophic forgetting and enabling recall, QA, and compositional questions on two datasets.
The Few-shot Dilemma: Over-prompting Large Language Models
cs.CL 2025-09 conditional novelty 5.0 of 10

Across seven LLMs on two requirements datasets, F1 scores rise then fall as more few-shot examples are added, and TF-IDF-selected examples at small counts match or beat larger prompts, including a 1% gain over prior SOTA.
Semantic Caching of Contextual Summaries for Efficient Question-Answering with Language Models
cs.CL 2025-05 conditional novelty 4.0 of 10

Caching query-aware LLM document summaries and reusing them for similar questions cuts input token use by roughly half while keeping answer similarity close to full-document processing.
Parallel Key-Value Cache Fusion for Position Invariant RAG
cs.AI 2025-01 conditional novelty 4.0 of 10

KV-Fusion encodes each retrieved passage in parallel with identical local positions, fuses the key-value caches, and fine-tunes a decoder so answers do not depend on passage order.

Reference graph

Works this paper leans on

13 extracted references · 5 canonical work pages · cited by 5 Pith papers

[8]

Songshuo Lu, Hua Wang, Yutian Rong, Zhi Chen, and Yaohua T ang

work page
[1]

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhis hek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Y ang, Angela Fan, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783 (2024)

arXiv 2024
[2]

Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu P an, Yuxi Bi, Yi Dai, Jiawei Sun, and Haofen Wang. 2023. Retrieval-augmented gen eration for large language models: A survey. arXiv preprint arXiv:2312.10997 (2023)

arXiv 2023
[3]

Cheng-Ping Hsieh, Simeng Sun, Samuel Kriman, Shantanu A charya, Dima Rekesh, Fei Jia, and Boris Ginsburg. 2024. RULER: What’s the Real Context Size of Your Long-Context Language Models?. In First Conference on Language Modeling. https://openreview.net/forum?id=kIoBbc76Sy

work page 2024
[4]

Quinn Leng, Jacob Portes, Sam Havens, Matei Zaharia, and Michael Carbin. 2024. Long Context RAG Performance of Large Language Models. arXiv preprint arXiv:2411.03538 (2024)

arXiv 2024
[5]

Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Pe troni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rock- täschel, et al. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing Systems 33 (2020), 9459–9474

work page 2020
[6]

Tianle Li, Ge Zhang, Quy Duc Do, Xiang Yue, and Wenhu Chen. 2024. Long- context LLMs Struggle with Long In-context Learning. arXiv:2404.02060 [cs.CL] https://arxiv.org/abs/2404.02060

arXiv 2024
[7]

Zhuowan Li, Cheng Li, Mingyang Zhang, Qiaozhu Mei, and Mi chael Ben- dersky. 2024. Retrieval Augmented Generation or Long-Cont ext LLMs? A Comprehensive Study and Hybrid Approach. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Process ing: Industry Track. Association for Computational Linguistics, Miami, Flori da, US, 881–8...

doi:10.18653/v1/2024.emnlp-industry.66 2024

Show all 13 references

[9]

Reiner Pope, Sholto Douglas, Aakanksha Chowdhery, Jaco b Devlin, James Brad- bury, Jonathan Heek, Kefan Xiao, Shivani Agrawal, and Jeﬀ De an. 2023. Ef- ﬁciently scaling transformer inference. Proceedings of Machine Learning and Systems 5 (2023), 606–624

2023
[10]

Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQuAD: 100,000+ Questions for Machine Comprehension of Tex t. In Proceed- ings of the 2016 Conference on Empirical Methods in Natural L anguage Processing, Jian Su, Kevin Duh, and Xavier Carreras (Eds.). ...

2016 doi
[11]

Cohen, Rus- lan Salakhutdinov, and Christopher D

Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, Wi lliam W. Cohen, Rus- lan Salakhutdinov, and Christopher D. Manning. 2018. HotpotQA: A Dataset for Diverse, Explainable Multi-hop Question Answering. In Conference on Empirical Methods in Natural Language Processing (EMNLP)

2018
[12]

acm-jdslogo.png

Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q Weinbe rger, and Yoav Artzi. [n. d.]. BERTScore: Evaluating Text Generation with BERT. In International Con- ference on Learning Representations . 4https://www.youtube.com/watch?v=NaEf_uiFX6o This figure "acm-jdslogo.png" is ava...

arXiv
[2024]

arXiv:2410.07590 [cs

TurboRAG: Accelerating Retrieval-Augmented Genera tion with Pre- computed KV Caches for Chunked Text. arXiv:2410.07590 [cs. CV] https://arxiv.org/abs/2410.07590

arXiv

Pith tools

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

[1] [8]

Songshuo Lu, Hua Wang, Yutian Rong, Zhi Chen, and Yaohua T ang

work page

[2] [1]

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhis hek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Y ang, Angela Fan, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783 (2024)

arXiv 2024

[3] [2]

Yunfan Gao, Yun Xiong, Xinyu Gao, Kangxiang Jia, Jinliu P an, Yuxi Bi, Yi Dai, Jiawei Sun, and Haofen Wang. 2023. Retrieval-augmented gen eration for large language models: A survey. arXiv preprint arXiv:2312.10997 (2023)

arXiv 2023

[4] [3]

Cheng-Ping Hsieh, Simeng Sun, Samuel Kriman, Shantanu A charya, Dima Rekesh, Fei Jia, and Boris Ginsburg. 2024. RULER: What’s the Real Context Size of Your Long-Context Language Models?. In First Conference on Language Modeling. https://openreview.net/forum?id=kIoBbc76Sy

work page 2024

[5] [4]

Quinn Leng, Jacob Portes, Sam Havens, Matei Zaharia, and Michael Carbin. 2024. Long Context RAG Performance of Large Language Models. arXiv preprint arXiv:2411.03538 (2024)

arXiv 2024

[6] [5]

Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Pe troni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rock- täschel, et al. 2020. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing Systems 33 (2020), 9459–9474

work page 2020

[7] [6]

Tianle Li, Ge Zhang, Quy Duc Do, Xiang Yue, and Wenhu Chen. 2024. Long- context LLMs Struggle with Long In-context Learning. arXiv:2404.02060 [cs.CL] https://arxiv.org/abs/2404.02060

arXiv 2024

[8] [7]

Zhuowan Li, Cheng Li, Mingyang Zhang, Qiaozhu Mei, and Mi chael Ben- dersky. 2024. Retrieval Augmented Generation or Long-Cont ext LLMs? A Comprehensive Study and Hybrid Approach. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Process ing: Industry Track. Association for Computational Linguistics, Miami, Flori da, US, 881–8...

doi:10.18653/v1/2024.emnlp-industry.66 2024