← Back to Index

RAG Quick Reference Cheatsheet

RAG Types at a Glance

# Type Key Mechanism Best For Avoid When
1 Naive RAG Chunk → Embed → Top-k retrieval Prototypes, small corpora High precision needed
2 Advanced RAG HyDE + Hybrid search + Reranking Production Q&A Latency is critical
3 Modular RAG Swappable pipeline components Custom enterprise pipelines Simple single-source systems
4 Agentic RAG LLM-controlled multi-step retrieval Complex reasoning, tool use Strict latency budgets
5 Graph RAG Knowledge graph traversal Relational data, multi-hop Simple FAQ systems
6 Corrective RAG Retrieval quality evaluation + fallback Out-of-KB or stale corpora All queries are well-covered
7 Self-RAG LLM trained with reflection tokens High-accuracy specialized domains General chatbots, no fine-tuning
8 Speculative RAG Drafter → Verifier pattern Cost/quality optimization Multi-hop queries
9 Multi-modal RAG Cross-modal embeddings (CLIP) Docs with images/tables Text-only corpora
10 Long-context RAG Full documents in context Complex documents, small corpus Large corpora, cost-sensitive
11 Adaptive RAG Query classifier routes to no-retrieval / single-hop / multi-hop Mixed-complexity query traffic, latency-sensitive Homogeneous query distribution
12 Structured RAG Text-to-SQL generation with schema linking Relational databases, tabular data Schema-free, unstructured data
13 RAPTOR UMAP + GMM clustering → per-cluster LLM summaries → multi-level tree Multi-hop questions, hierarchical docs Frequently updated corpora (tree rebuild is expensive)
14 Contextual RAG LLM prepends 1–2 sentence context prefix to each chunk before embedding Dense corpora with ambiguous or short chunks Token-budget-constrained indexing pipelines
15 LightRAG Entity-relationship graph + dual local (entity) / global (community) retrieval Queries mixing relational and semantic needs Simple single-topic factoid Q&A
16 RAFT Fine-tunes LLM generator on oracle docs + K distractor docs + CoT answers Closed-domain high-stakes (medical, legal, internal KB) Frequently changing corpus or when fine-tuning is off the table
17 Cache-Augmented Generation (CAG) Precomputes KV cache for entire corpus; zero retrieval step at inference Stable, bounded corpus that fits in context window Large, dynamic, or multi-tenant corpora
18 RAG-Fusion N query reformulations → N parallel retrievals → RRF merge → generation Ambiguous queries, broad topic coverage Hard latency budget (N× retrieval cost)
19 Iterative / Multi-hop RAG Retrieve → reason → retrieve loops (IRCoT, Self-Ask, ITER-RETGEN) until a stopping criterion Compositional multi-hop questions needing fact chaining Simple single-fact queries; tight latency (sequential hops)
20 HippoRAG Personalized PageRank over an LLM-built KG + synonym edges for single-step multi-hop Entity-rich multi-hop on a stable, high-volume corpus Entity-poor/abstract queries; fast-changing corpora
21 Memory / Conversational RAG Tiered memory (working/summary/long-term) + history-aware query rewriting Multi-turn assistants needing reference resolution and recall Single-turn lookups; stateless-by-requirement domains
22 HyDE Embed an LLM-generated hypothetical answer instead of the query Zero-shot/unsupervised encoders, vocabulary-mismatched or cross-lingual queries Fine-tuned in-domain retrievers; entity/factoid lookups
23 FLARE Retrieve mid-generation when next-sentence token confidence < θ (forward-looking) Long-form generation where information needs evolve Short factoid answers; APIs without token logprobs
24 KAG Logical-form-guided reasoning + KG↔text mutual indexing Professional domains needing rule-following deduction + provenance (medical, legal, e-gov) Open-domain/similarity-answerable Qs; fast-changing corpora
25 GraphReader / GNN-RAG Agentic graph-of-notes traversal (GraphReader) / GNN-retrieved reasoning subgraphs (GNN-RAG) Long-context multi-hop (GraphReader); KGQA over dense KGs (GNN-RAG) Single-hop or similarity-answerable; no KG (GNN-RAG)
26 REALM (training-time) Retriever learned end-to-end via masked-LM pre-training (latent-variable marginalization) Research/learned-retrieval; updatable-corpus QA When a frozen off-the-shelf retriever suffices
27 RETRO (training-time) Chunked cross-attention over a trillion-token frozen datastore Parameter-efficient LMs; large-scale knowledge LM Most apps without trillion-scale datastore infra
28 Atlas (training-time) Jointly-trained Contriever + FiD, attention-distillation Few-shot knowledge tasks with scarce labels When strong LLM + inference-time RAG already suffices
29 Fusion-in-Decoder (FiD) (training-time) Encode each passage separately, fuse in the decoder Generative reading/fusing of many retrieved passages Single-passage reads; very tight decoder-latency budgets
30 ColRAG / ColBERT Multi-vector late interaction — one embedding per token, MaxSim scoring Hard retrieval, domain-specific vocabulary, sub-100ms precision Storage-constrained (index is 10–30× larger than single-vector); already using a reranker
31 Agentic Web RAG Live web search as retrieval backend — fetch, extract, cite pages in real time Queries about recent events; no pre-built corpus; general-purpose assistants Latency < 500ms; sensitive/regulated data; deterministic answers required
32 Few-Shot Example RAG Retrieve (query, answer) demonstration pairs instead of documents Code generation with project style, structured output, text-to-SQL Factual Q&A where document content (not format) is what's needed
33 Verifiable / Citation RAG Every claim linked to a specific passage + NLI-based attribution verification Legal, medical, compliance contexts requiring auditable answers Casual Q&A where citation overhead is unnecessary
34 Privacy-Preserving RAG On-device embedding, DP noise on query vectors, federated retrieval across data silos Regulated industries (HIPAA, GDPR); zero-trust retrieval; cross-org federated search Low-sensitivity public corpora where data minimization is not required
35 Streaming / Real-Time RAG Continuous Kafka/CDC event stream → micro-batch embed → upsert; freshness window in seconds News, financial data, live support docs; any corpus where staleness > 30s is unacceptable Stable, infrequently-updated corpora where batch reindex works fine
36 Table-Aware RAG Table extraction → row-level chunking with column headers → numerical-query boosted retrieval Financial reports, scientific data, HTML tables, multi-column PDFs with structured data Pure prose documents; relational databases (use Structured RAG instead)
37 Tree of Thought RAG Generate N thought branches → retrieve targeted evidence per branch → score and prune → synthesize best path Queries with competing hypotheses (diagnostics, root cause analysis, multi-interpretation) Simple factual queries; latency-sensitive applications (15–60s per query)
38 DPR (Dense Passage Retrieval) Bi-encoder trained with contrastive loss on (question, passage) pairs; offline passage indexing in FAISS Foundational architecture; learning fine-grained semantic retrieval; custom bi-encoder training When off-the-shelf embedding models (BGE, E5) already meet recall requirements
39 WebGPT / Tool-Augmented LM LLM trained via RLHF to issue browser actions (search/click/quote) as first-class learned operations When prompting-based tool use is unreliable; narrow/stable tool space; verification signal available Rapidly evolving tool space; prompting already reliable; training cost is prohibitive
40 SURGE (Schema-Grounded RAG) Schema-constrained generation via tool_use + per-field NLI grounding verification before delivery ETL from documents, compliance reports, database population — any structured output needing per-field auditability Conversational/advisory output where field-level traceability is unnecessary
41 Recursive Document Summarization RAG Multi-level summary tree (chunk → section → document → corpus) built offline; query routing selects the right abstraction level at inference Large documents navigated at multiple granularities (annual reports, contracts); "what does section 3 say?" Cross-document thematic queries (use RAPTOR instead); small corpora
42 Search-R1 / Reasoning RAG RL-trained LLM interleaves <think>/<search> tokens, learning a retrieval policy from answer-correctness reward Domains with verifiable answers and RL training budget (QA, math, coding search) No RL training infra/budget; prompted agentic RAG already sufficient
43 Deep Research / Agentic Research RAG Parallel plan → search → read → synthesize sub-agents produce a long-form cited report Open-ended research questions needing dozens of sources and a full report Simple single-answer lookups; hard latency/cost budgets (minutes, dollars per query)
44 MemoRAG Lightweight memory model compresses the corpus, generates query-time draft "clues" to guide precise retrieval Implicit or aggregate queries where no single passage has the answer Simple factoid lookups where standard dense retrieval already works
45 LongRAG + Self-Route Retrieves large (~4K-token) grouped units instead of small chunks; Self-Route picks RAG vs. full long-context per query Long documents where small-chunk fragmentation loses context Very large corpora (long units cost more per retrieval); tight latency budgets
46 VisRAG VLM embeds and reads document pages as images end-to-end — no OCR/layout parsing Visually rich documents (scanned PDFs, forms, slides) where parsing loses structure Plain-text corpora; VLM inference cost/latency is prohibitive
47 LazyGraphRAG Cheap NLP noun-phrase graph at index time; all LLM summarization deferred to a query-time relevance-test loop Graph-style queries where GraphRAG's indexing cost is prohibitive Extremely low query-time latency requirements (relevance-test loop adds cost per query)
48 Astute RAG Elicits the LLM's own parametric knowledge as an explicit source, then reconciles it with retrieved passages Domains with frequent retrieval-vs-parametric-knowledge conflicts Retrieval is already highly reliable and conflicts are rare
49 Auto-RAG / DeepRAG Decides retrieve-vs-reason at every step (autonomous dialogue or explicit MDP), not once up-front Multi-step reasoning tasks where retrieval need varies per step Simple single-hop queries; no fine-tuning budget
50 CoRAG (Chain-of-Retrieval) Trained on rejection-sampled retrieval chains; chain length is a tunable test-time compute knob Multi-hop QA where you can trade inference cost for accuracy Fixed low-latency budget; no fine-tuning pipeline
51 RQ-RAG Fine-tuned to explicitly rewrite / decompose / disambiguate queries via special tokens before retrieval Ambiguous or compound queries where prompted rewriting underperforms No fine-tuning budget; prompted HyDE/Multi-Query already sufficient
52 REFRAG Compresses chunks into dense embeddings; RL policy selectively expands important ones back to full tokens Latency-critical RAG with many retrieved chunks (long effective context) Small k (few chunks); training/serving the compression+policy stack is not worth it

Cost / Latency / Complexity by Architecture

Relative ratings for a typical mid-size deployment (●○○ low → ●●● high). Per-query cost assumes comparable answer quality targets.

Type Per-query cost Latency Build complexity Ops complexity Main cost driver
Naive RAG ●○○ ●○○ ●○○ ●○○ LLM generation tokens
Advanced RAG ●●○ ●●○ ●●○ ●●○ HyDE generation + reranker inference
Modular RAG ●●○ ●●○ ●●● ●●○ Router + active modules
Agentic RAG ●●● ●●● ●●● ●●● Multiple LLM calls per loop
Graph RAG ●●○ ●●○ ●●● ●●● KG construction (index-time, LLM-heavy)
Corrective RAG ●●○ ●●○ ●●○ ●●○ Retrieval evaluator LLM per query
Self-RAG ●○○* ●●○ ●●● ●●○ *Up-front fine-tuning; cheap at inference
Speculative RAG ●●○ ●○○ ●●● ●●● Parallel drafter GPUs + verifier scoring
Multi-modal RAG ●●○ ●●○ ●●● ●●○ Image embedding at index time, vision LLM
Long-context RAG ●●● ●●● ●○○ ●○○ Context tokens (linear in stuffed docs)
Adaptive RAG ●○○ ●○○ ●●○ ●●○ Classifier (tiny); saves cost on easy queries
Structured RAG ●●○ ●●○ ●●○ ●●○ Schema-in-prompt tokens + retry loops
RAPTOR ●○○* ●○○ ●●● ●●○ *Up-front LLM summarization per cluster; cheap at query time
Contextual RAG ●●○* ●○○ ●●○ ●●○ *One LLM call per chunk at index time (prompt caching cuts ~94%)
LightRAG ●●○ ●●○ ●●● ●●● Entity/relationship extraction at build time; graph ops at query time
RAFT ●○○* ●○○ ●●● ●●○ *Up-front fine-tuning cost; inference same as base model
CAG ●●●* ●○○ ●○○ ●●○ *High cold-start KV cache load; zero retrieval latency per query
RAG-Fusion ●●○ ●●○ ●●○ ●●○ N × (reformulation + retrieval); parallelizable
Iterative / Multi-hop RAG ●●● ●●● ●●○ ●●○ One LLM reasoning call per hop (sequential, not parallelizable)
HippoRAG ●○○* ●○○ ●●● ●●● *Up-front OpenIE over whole corpus; query-time retrieval is LLM-free PageRank
Memory / Conversational RAG ●●○ ●●○ ●●○ ●●● Query-rewriting LLM call + memory store reads/writes per turn
HyDE ●●○ ●●○ ●○○ ●○○ Extra LLM generation (the hypothetical) before retrieval
FLARE ●●○ ●●● ●●○ ●●○ Re-generation of low-confidence sentences + interleaved retrievals
KAG ●●○* ●●○ ●●● ●●● *Heavy KG build + extraction; multi-step parse/execute/compose per query
GraphReader ●●● ●●● ●●○ ●●○ LLM call per exploration step (sequential agentic traversal)
GNN-RAG ●○○* ●○○ ●●● ●●● *Up-front GNN training + KG upkeep; cheap GNN pass + one LLM call at query
REALM ●○○ ●○○ ●●● ●●● *Heavy training (async index refresh); inference is RAG-like
RETRO ●●○ ●●○ ●●● ●●● Per-chunk retrieval + huge frozen datastore storage/serving
Atlas ●●○ ●●○ ●●● ●●● Joint training + index refresh; FiD encoder cost linear in passages
Fusion-in-Decoder ●●○ ●●○ ●●○ ●●○ Decoder cross-attention over all passage tokens (grows with k)
ColRAG / ColBERT ●●○ ●○○ ●●○ ●●○ Large token-level index storage; fast MaxSim at query time
Agentic Web RAG ●●● ●●● ●●○ ●●○ Search API + page fetch latency; multiple LLM calls for multi-step
Few-Shot Example RAG ●○○ ●○○ ●●○ ●○○ Example embedding at index time; retrieval same cost as dense RAG
Verifiable / Citation RAG ●●○ ●●○ ●●○ ●●○ NLI verification pass per claim adds latency and compute
Privacy-Preserving RAG ●●○ ●●○ ●●● ●●● DP noise embedding + federated retrieval coordination overhead
Streaming / Real-Time RAG ●●○ ●○○ ●●● ●●● Kafka/CDC infra + always-on consumer; embedding is micro-batched
Table-Aware RAG ●●○ ●●○ ●●○ ●●○ Table parsing + row-level embedding at index time; reranker boost at query time
Tree of Thought RAG ●●● ●●● ●●● ●●● 15–50 LLM calls per query (thought gen + eval + retrieval per branch)
DPR ●○○* ●○○ ●●● ●●○ *Up-front contrastive training; inference is standard bi-encoder retrieval
WebGPT / Tool-Augmented LM ●●●* ●●● ●●● ●●● *RLHF pipeline is expensive; inference is multi-step browsing with LLM calls
SURGE ●●○ ●●○ ●●○ ●●○ Tool-use generation + NLI verification pass per field; LLM call per extracted object
Recursive Summary RAG ●●○* ●○○ ●●○ ●●○ *Up-front Haiku summarization per section/document; query-time routing is a single cheap Haiku call
Search-R1 / Reasoning RAG ●●○* ●●○ ●●● ●●○ *Heavy RL training cost; inference is a bounded number of self-issued search calls
Deep Research RAG ●●●● ●●●● ●●○ ●●○ Dozens of parallel sub-agent LLM calls + page fetches per report
MemoRAG ●●○ ●●○ ●●● ●●○ Memory-model training/compression up front; extra clue-generation call per query
LongRAG + Self-Route ●●○ ●●○ ●●○ ●○○ Larger retrieval units → more tokens fed to the reader per call
VisRAG ●●○ ●●○ ●●○ ●●○ VLM inference on page images at both index and query time
LazyGraphRAG ●○○* ●○○ ●●○ ●●○ *Cheap NLP-only indexing; query-time iterative relevance testing instead
Astute RAG ●●○ ●●○ ●○○ ●○○ Extra internal-knowledge elicitation + multi-round consolidation calls
Auto-RAG / DeepRAG ●●○* ●●○ ●●● ●●○ *Fine-tuning on decision traces; variable per-step retrieve/reason calls at inference
CoRAG ●●●* ●●○ ●●● ●●○ *Fine-tuning on rejection-sampled chains; chain length is a tunable test-time cost knob
RQ-RAG ●●○* ●●○ ●●● ●●○ *Fine-tuning cost; tree-decoding across refinement branches at inference
REFRAG ●○○* ●○○ ●●● ●●○ *RL + encoder training up front; ~30x lower TTFT than raw-token baseline at inference

Failure Modes: Symptom → Likely Cause → First Fix

Symptom Likely cause First fix Deep dive
Answer contradicts the retrieved docs LLM ignores context (parametric memory wins) Harden prompt ("answer ONLY from context"), measure faithfulness Hallucination
Relevant doc exists but never retrieved Semantic gap between query and chunk wording Hybrid search (BM25 + dense), query rewriting Retrieval Failure
Recall collapsed after a model/pipeline change Query and docs embedded with different models/versions Re-embed entire corpus with one model; version-stamp vectors Embedding Mismatch
Confidently wrong answers about recent facts Index lags source-of-truth updates Incremental indexing + TTL/versioning; freshness alerts Stale Index
Answers degrade as k or doc size grows Context overflow → truncation or lost-in-the-middle Rerank then cut to top 3–5; compress context Context Overflow
Good docs retrieved but ranked below junk Reranker domain mismatch or score miscalibration Evaluate reranker on domain pairs; swap or fine-tune Reranker Failure
Multi-turn answers degrade; wrong context retrieved after topic change or pronoun use Conversation history poisons the retrieval query (coreference, implicit carry-over) Query condensation: rewrite history + new turn into a standalone query before retrieval Conversational Context Drift
Multi-hop chain produces confident but completely wrong answer; error invisible to the LLM HyDE/expansion generated a wrong hypothesis; wrong first hop propagated through all subsequent hops Re-anchor each hop against the original query; add semantic-drift circuit breaker Cascading Retrieval Failure
Tenant B receives Tenant A's financial or confidential data via RAG response Semantic cache keyed only on query meaning — no tenant namespace; semantically similar queries across tenants collide Namespace all semantic cache keys by tenant_id (or permission-hash) Semantic Cache Leakage

Chunking Quick-Pick

Content type Strategy Typical size Notes
Uniform prose (articles, wikis) Recursive splitting 256–512 tokens, 10–20% overlap Sensible default; respect paragraph boundaries
Long structured docs (manuals, contracts) Parent-child Child 200–300, parent 1,000+ Retrieve on child precision, generate with parent context
Q&A / FAQ content One Q&A pair per chunk Natural unit Never split an answer from its question
Code Function/class boundary Natural unit Syntax-aware splitters; keep signatures with bodies
Tables Whole table + caption per chunk Natural unit Serialize to markdown; never split rows from headers
Mixed/unknown Semantic chunking Variable Embedding-similarity breakpoints; costs an embedding pass
Cross-chunk context critical (references span chunks) Late Chunking Variable Embed full doc first → pool token embeddings into windows; requires token-level model (JinaAI v3, nomic-embed-text)

Calibrate on your own data: build a small labeled probe set, sweep chunk size/overlap, measure Recall@5 — see chunking_strategies.md.

Evaluation Metrics

Metric What it measures Tool
Context Precision Fraction of retrieved chunks that are relevant RAGAS
Context Recall Fraction of relevant info that was retrieved RAGAS
Faithfulness Does the answer only use the retrieved context? RAGAS, TruLens
Answer Relevance Does the answer actually address the question? RAGAS
MRR Rank of first relevant result Custom
NDCG Quality of ranked retrieval results Custom
Latency P95 95th percentile end-to-end response time Infrastructure

Production-side evaluation (LLM-as-judge, online metrics, drift alerts): see observability_and_evaluation_ops.md.

Common Tools by Layer

Embedding Models

Vector Databases

RAG Frameworks

Evaluation Frameworks

Rerankers

Decision Tree: Which RAG to Use?

Start
  │
  ├─ Is the primary data source a relational database or tabular store?
  │     └─ YES → Structured RAG
  │
  ├─ Is your corpus stable, bounded, and fits in a context window?
  │     └─ YES → Cache-Augmented Generation (CAG)  ← no retrieval step needed
  │
  ├─ Is your corpus relational / entity-heavy (graph-structured)?
  │     ├─ Large corpus, mandatory global summaries needed → Graph RAG (Microsoft)
  │     └─ Lower build cost, dual local+global retrieval → LightRAG
  │
  ├─ Does query complexity vary widely (trivial to multi-hop)?
  │     └─ YES → Adaptive RAG
  │
  ├─ Does your query require multiple retrieval steps or tool calls?
  │     └─ YES → Agentic RAG
  │
  ├─ Does your corpus include images/tables?
  │     └─ YES → Multi-modal RAG
  │
  ├─ Is your corpus small (<50 docs) and complex?
  │     └─ YES → Long-context RAG
  │
  ├─ Is your corpus hierarchical or multi-level (needs multi-hop summaries)?
  │     └─ YES → RAPTOR
  │
  ├─ Are chunks short / ambiguous and retrieval recall is low?
  │     └─ YES → Contextual RAG  ← LLM-generated context prefix per chunk
  │
  ├─ Are queries often ambiguous or benefit from multiple phrasings?
  │     └─ YES → RAG-Fusion  ← N reformulations + RRF merge
  │
  ├─ Is retrieval accuracy critical in a closed, specialized domain?
  │     ├─ Can fine-tune the LLM generator → RAFT
  │     └─ Cannot fine-tune → Self-RAG (if reflection tokens available)
  │
  ├─ Is your knowledge base potentially outdated/incomplete?
  │     └─ YES → Corrective RAG
  │
  ├─ Do you need cost/quality optimization at scale?
  │     └─ YES → Speculative RAG
  │
  ├─ Do you need a flexible, customizable pipeline?
  │     └─ YES → Modular RAG
  │
  ├─ Is this a production system needing good precision?
  │     └─ YES → Advanced RAG
  │
  └─ Prototyping or simple use case?
        └─ YES → Naive RAG

Common Pitfalls Checklist

Run through this before any RAG interview (or production launch):

Retrieval

Chunking & Context

Generation

Evaluation & Ops

Security & Access