RAG types explained: naive, hybrid, reranked, HyDE, corrective, agentic and GraphRAG
Retrieval-augmented generation is not one technique but a family. Each variant fixes a specific failure of the simple version. This guide walks through the main types in the order you would adopt them, and lets you run each one on the same small corpus to see what it retrieves.
- Reading time
- 10 min
- Sections
- 14
- Code examples
- 1
- Simulations
- 1
- Tables
- 1
- Sources
- 6
- Published
- 17 Nov 2026
A language model knows what was in its training data and nothing about your documents. Retrieval-augmented generation (RAG) fixes that by searching your documents first and putting the best passages into the prompt, so the model answers from evidence instead of memory.
The simple version works surprisingly well and fails in predictable ways. It misses exact terms, ranks the right passage too low, searches with the wrong words, or needs two pieces of evidence that sit in different documents. Each RAG variant below exists because of one of those failures. Adopt them in roughly this order, and only when a measurement shows you need the next one.
A useful picture is a library. Naive RAG asks the catalogue one question and takes the first three books. The better variants add a second catalogue that matches exact words, a librarian who reads the shortlist, a habit of rephrasing the question in the library's own vocabulary, a check that the books actually answer it, and finally a researcher who keeps searching until the case is complete.
The simulation: seven strategies, one corpus
Choose a question, then switch between strategies. The corpus has eight short policy passages; the relevant ones are marked. The scores are computed in your browser with simple word vectors and BM25, so the differences you see are real for this corpus, even though the corpus is tiny.
Interactive RAG comparison. It needs JavaScript; every strategy is also described in the text below.
Try "Can I get my money back if the item arrived broken?". The question shares almost no words with the policy, which says "damaged" and "refund". Naive search struggles; rewriting, HyDE and the agentic strategy recover. That is the vocabulary mismatch problem, and it is the most common reason simple RAG fails on real users' questions.
The common pipeline
Every variant shares the same skeleton:
- Ingest. Split documents into passages (chunks), usually a few hundred words with a small overlap, and keep metadata such as source, section and date.
- Index. Turn each chunk into a vector with an embedding model and store it in a vector index; many systems also build a keyword index.
- Retrieve. Turn the question into a query, search, and take the top k chunks.
- Generate. Put the chunks into the prompt with instructions to answer only from them and cite sources.
- Evaluate. Score retrieval (context precision and recall) and the answer (faithfulness and relevancy).
The variants change step 3 most, sometimes steps 1 and 4.
1. Naive RAG
Embed the question, take the nearest chunks by cosine similarity, answer. It is fast, cheap and a good baseline.
Fails when: the question uses different words from the documents, the answer depends on an exact identifier (a product code, an error number), or the best chunk sits at rank six.
Use it: as the first version, with an evaluation set, so every later change has a number to beat.
2. Hybrid search
Run a keyword search (usually BM25) next to the vector search and blend the two, either with weighted scores or with reciprocal rank fusion. Vectors capture meaning; keywords capture exact strings that embeddings blur, such as names, codes and rare terms.
Fixes: misses on exact terms. Costs: a second index and one tuning weight. Use it: almost always in production; it is the cheapest large gain after the baseline.
3. Retrieve, then rerank
Retrieve a wider set, for example 20 to 50 chunks, then let a reranker reorder them and keep the best few. A reranker is usually a cross-encoder: it reads the question and the chunk together, which judges relevance far better than comparing two separately computed vectors, but is too slow to run on the whole corpus.
Fixes: the right chunk retrieved but ranked too low. Costs: tens to hundreds of milliseconds per query. Use it: when context recall at 20 is good but precision at 3 is poor.
4. Query rewriting and multi-query
Ask a model to rewrite the user's question into the language of the documents, or to produce several phrasings and merge the results. "Money back for a broken item" becomes "refund for damaged or defective item".
Fixes: vocabulary mismatch and vague questions. Costs: one small model call. Use it: for user-facing search where people do not know the documents' terms.
5. HyDE: hypothetical document embeddings
Instead of embedding the question, ask the model to write a short hypothetical answer and embed that. Answers look like the passages that contain them, so the hypothetical answer often lands nearer the right chunk than the question does, even if its facts are wrong.
Fixes: questions that are short or phrased very differently from the documents. Costs: one generation before search; it can drift if the model invents a confident but misleading draft. Use it: for sparse, domain-specific corpora; combine with hybrid search.
6. Contextual chunks and better ingestion
Many retrieval failures start at ingestion: a chunk that says "it is covered for 12 months" without saying what "it" is. Contextual retrieval adds a short description of the surrounding document to each chunk before indexing; parent-child chunking retrieves small precise chunks but passes their larger parent section to the model.
Fixes: chunks that lose meaning when cut out of their document. Costs: a one-time pass over the corpus. Use it: when traces show the right passage exists but is never retrieved.
7. Corrective RAG (CRAG) and self-checking
Add a grader after retrieval. If the retrieved chunks do not answer the question, rewrite the query and search again, or fall back to another source, before generating. Self-RAG goes further and trains the model to decide when to retrieve and to critique its own output. In practice most teams implement the corrective loop with a small grading prompt.
Fixes: confident answers built on irrelevant context. Costs: one grading call per query, sometimes a second search. Use it: when wrong answers are expensive; it is the pattern in the agent guide.
8. Agentic RAG
Give retrieval to an agent as a tool. The agent plans sub-questions, searches several times, possibly across several sources (documents, SQL, web), and stops when it has enough evidence. It handles multi-hop questions such as "which of our suppliers in Germany had late deliveries last quarter and what does the contract say about penalties".
Fixes: questions whose evidence is spread across documents or systems. Costs: several model calls, higher latency and harder evaluation. Use it: for research-style questions; keep simple questions on a simple path.
9. GraphRAG
Extract entities and relations from the corpus into a knowledge graph, group related entities into communities and summarise them. Questions about the corpus as a whole ("what are the main themes in these reports?") can then be answered from the community summaries, and multi-hop questions can follow graph edges.
Fixes: global questions that no single chunk can answer, and relationship questions. Costs: an expensive indexing pass with many model calls, and a graph to maintain. Use it: for analytical questions over a stable corpus, not for frequently changing documents.
Choosing: a short decision guide
| Symptom in your evaluation | First thing to try |
|---|---|
| Misses exact names, codes, numbers | Hybrid search |
| Right chunk in top 20, wrong in top 3 | Reranker |
| Users' words differ from the documents' words | Query rewriting or HyDE |
| Right passage exists but never retrieved, chunks lack context | Contextual chunks, parent-child chunking |
| Answers built on irrelevant passages | Corrective grading step |
| Evidence spread across documents or systems | Agentic RAG |
| Questions about themes across the whole corpus | GraphRAG |
How to measure the difference
Pick 50 to 200 real questions with reference answers. For each change, compare:
- Context recall: did retrieval bring everything the reference answer needs?
- Context precision: are the relevant chunks at the top?
- Faithfulness: is every claim in the answer supported by the retrieved chunks?
- Latency and cost per query.
RAGAS computes the first three with an LLM judge; DeepEval offers similar metrics as tests for CI. Change one thing at a time and keep the numbers in a table. A variant that adds 400 ms and one point of recall is rarely worth it; one that turns 60% recall into 85% almost always is.
Common mistakes
Tuning the prompt when retrieval is the problem. If the right passage never reaches the model, no instruction will produce the right answer.
Chunks that are too large. Big chunks dilute the embedding and fill the context window with noise. Start around 200 to 500 words and measure.
No metadata filters. Dates, product lines and access rights belong in filters, not in the hope that similarity will find the newest or permitted document.
Stacking every technique at once. Each step adds latency and failure modes. Add the one your evaluation points to, then measure again.
Frequently asked questions
What is the difference between RAG and fine-tuning?
RAG gives the model facts at question time from documents you can update any day. Fine-tuning changes the model's weights to teach it a style, format or skill. Facts that change belong in RAG; behaviour belongs in fine-tuning.
Does a long context window replace RAG?
Not fully. Long contexts help, but putting everything into every prompt is slow and expensive, and models still miss details in very long inputs. Retrieval keeps prompts short and focused, and gives citations.
Which RAG type should I start with?
Naive RAG with a measurement set, then hybrid search. Most production systems end up with hybrid search plus a reranker, with a corrective or agentic path for hard questions.
What is the difference between agentic RAG and corrective RAG?
Corrective RAG adds one check and at most one retry to a fixed pipeline. Agentic RAG lets a model plan and run as many searches as it needs, across sources, which is more flexible and more expensive.
When is GraphRAG worth the cost?
When users ask about themes, trends and relationships across a large, fairly stable corpus, such as research archives or investigation files. For "what does policy X say" questions, hybrid search with a reranker is cheaper and as good.
Summary
RAG is a family of fixes on one pipeline. Start with naive retrieval and a measurement set, add hybrid search, then a reranker, then query rewriting or HyDE for vocabulary gaps, a corrective step where wrong answers are costly, and agentic or graph methods only for questions that truly need several hops or a view of the whole corpus.
Sources
- Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, Lewis et al., arXiv:2005.11401
- Precise Zero-Shot Dense Retrieval without Relevance Labels (HyDE), Gao et al., arXiv:2212.10496
- Corrective Retrieval Augmented Generation, Yan et al., arXiv:2401.15884
- Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection, Asai et al., arXiv:2310.11511
- From Local to Global: A Graph RAG Approach to Query-Focused Summarization, Edge et al., arXiv:2404.16130
- RAGAS documentation
Continue learning
Cite this article
Kelahmet, Ö. C. (2026, November 17). RAG types explained: naive, hybrid, reranked, HyDE, corrective, agentic and GraphRAG. Özer Cem KELAHMET. https://www.ozercemkelahmet.com/articles/rag-types-explained-naive-hybrid-rerank-hyde-corrective-agentic-graphrag
BibTeX
@online{kelahmet2026types,
author = {Kelahmet, {\"O}zer Cem},
title = {{RAG types explained: naive, hybrid, reranked, HyDE, corrective, agentic and GraphRAG}},
year = {2026},
month = {nov},
url = {https://www.ozercemkelahmet.com/articles/rag-types-explained-naive-hybrid-rerank-hyde-corrective-agentic-graphrag}
}How this article connects
2 pages link to or from it. Drag to turn, click a dot to open it.
Version historyfirst version
- Published
Factual corrections are listed here with what changed. Wording and formatting edits are not listed.