RAG Architectures Elucidated
RAG gives a model access to your organization's own knowledge instead of asking it to answer from whatever it happened to memorize during training. The idea is simple; making it hold up in production is not. Here's the architecture underneath RAG, the pipeline a query actually travels through, and the five places production systems quietly break.
Retrieval-Augmented Generation is, at its core, three components working together: a knowledge repository holding an organization's documents, databases, APIs and internal knowledge; a retrieval engine that searches that repository for what's relevant to a given query; and the LLM itself, which generates a response grounded in whatever the retriever hands it. None of the three does the whole job alone — a strong LLM fed weak context still produces a weak answer, and a great retriever wired to a weak generation step still under-delivers.
01The Three Pillars, and the Pipeline Between Them
A RAG system is the three pillars wired into a specific sequence — each stage narrowing a huge repository down to the handful of passages actually worth sending to the model.
Knowledge Repository
Documents, databases, APIs and internal knowledge bases — the raw material retrieval searches over. Its quality sets a hard ceiling on everything downstream.
Retrieval Engine
Searches the repository for what's relevant to the prompt, ranks candidates, and hands the LLM only the passages worth reading.
The LLM
Generates the final response grounded in the retrieved context — reasoning over what it was given rather than recalling from training alone.
Done well, that pipeline gives an organization a few concrete advantages over relying on a model's frozen training data alone: no retraining required just to reflect this week's internal documents, source attribution the model's raw memory can never provide, measurably lower hallucination rates because the model is reasoning over supplied evidence rather than guessing, and — because retrieval narrows what actually reaches the model — often lower generation cost than stuffing everything into context and hoping.
02The RAG Evolution Ladder
Ten stages, each one answering a question the previous stage couldn't.
Retrieve & Generate
The classic approach: embed the query, search a vector database, retrieve the top-K chunks, and send them to the LLM. Best when the knowledge base and the questions are relatively straightforward.
Best for: simple document Q&A and internal chatbots.
Retrieve Better
Adds smarter chunking, query rewriting, metadata filtering, reranking, and context compression. The goal isn't more context — it's better context.
Best for: improving relevance and answer quality in production.
Combine Search Strategies
Combines semantic/vector search with keyword search such as BM25. Sometimes meaning matters; sometimes the exact word matters — hybrid RAG covers both.
Best for: users who search for exact terms, product names and IDs as well as concepts.
Swap Components, Keep the Pipeline
Breaks the pipeline into replaceable components such as a retriever, router, reranker and generator, so each part can be changed, tested or scaled on its own. The Modular RAG paper describes this as turning RAG systems into reconfigurable, LEGO-like frameworks.
Best for: scalable enterprise systems that need flexibility.
Retrieve Relationships
Instead of treating knowledge as isolated chunks, GraphRAG represents entities and their relationships — especially powerful when a question requires connecting information across multiple sources.
Best for: multi-hop questions, compliance, research and enterprise knowledge networks.
Retrieve, Evaluate, Correct
Introduces a validation step: is the retrieved information actually relevant? If not, the system refines the query, retrieves again, or falls back to another source.
Best for: high-stakes uses where poor retrieval cannot be tolerated.
Retrieve, Generate, Critique
The model doesn't blindly accept everything it retrieves — it evaluates whether retrieval is even needed, assesses the evidence, and critiques whether its own answer is adequately supported.
Best for: improving reliability and avoiding unnecessary retrieval.
Retrieve When Needed
Not every question deserves the same pipeline. A simple question gets answered directly, a knowledge-dependent question triggers retrieval, and a complex question invokes a more sophisticated retrieval-and-reasoning strategy.
Text, Images, Tables, Audio, Video
Retrieval is no longer limited to paragraphs. Multimodal RAG pulls from text, images, tables, charts, audio, and video — essential for complex enterprise documents.
Let the System Decide
An agent decides whether retrieval is needed, which source to search — vector database, SQL, API, web, or knowledge graph — and whether the evidence gathered is sufficient before answering. RAG stops being a fixed pipeline and becomes a dynamic reasoning workflow.
Best for: complex research, multi-step workflows and autonomous AI systems.
03Seven Transitions Reshaping RAG in 2026
The ladder above describes the architecture. These are the industry-wide shifts happening around it right now.
"RAG is dead" — except it isn't
Million-token context windows reopened the debate on whether retrieval is even necessary. The 2026 consensus: long context killed lazy retrieval, not retrieval itself. Naive, chunk-and-pray pipelines are fading; disciplined retrieval is thriving.
Retrieval + long context, not retrieval vs. long context
The winning pattern is hybrid: use retrieval to narrow down the right material, then hand a long context window to the model to reason across it — cheaper and more accurate than either approach alone.
Retrieval remains dramatically cheaper per query at scaleFrom fixed pipeline to agentic reasoning
Agentic RAG is graduating from research demo to production baseline for complex knowledge work, with agents planning retrieval strategy, choosing sources, and retrying on weak evidence.
Standard pattern for multi-hop enterprise Q&A in 2026GraphRAG goes mainstream — carefully
Knowledge graphs bring relationship-aware retrieval and stronger multi-hop reasoning, but extraction and maintenance cost several times more than a baseline vector pipeline, so teams are adopting it selectively rather than by default.
Best fit: regulated, relationship-heavy domainsFreshness becomes a design requirement
Nightly re-indexing is increasingly treated as a design failure. Streaming databases with native embedding functions, live API feeds, and event-driven updates are pushing RAG toward near-real-time freshness.
Streaming + native embeddings now production-readyMultimodal becomes the default, not the exception
Cross-referencing text, tables, images, audio, and video in a single retrieval pass is moving from a specialized capability to an expected one, driven by enterprise documents that were never pure text to begin with.
Five converging trends: agentic orchestration, streaming, cross-modal reasoning, on-device privacy, standardized evaluationEvaluation and governance mature
Frameworks such as RAGAS, ARES, and cloud-native evaluators now measure faithfulness, context precision/recall, and citation accuracy as a matter of course — and access controls are becoming as important as retrieval quality for safe enterprise-wide rollout.
RAG is now treated as enterprise AI infrastructure, not a feature04Five Ways RAG Breaks in Production
RAG demos are easy to get right. Production RAG tends to fail in the same five places, in roughly this order of how quietly they do damage.
1. Dirty Knowledge Base
Category: input qualityA RAG system can only retrieve what actually exists in its knowledge base — and duplicated documents, stale content, incomplete PDFs and inconsistent formatting all show up downstream as noise that lowers answer quality and raises hallucination rates. There's no retrieval technique clever enough to fully compensate for a dirty source corpus. Deduplication, staleness checks and formatting normalization aren't preprocessing chores to skip past — they're the ceiling on everything the rest of the pipeline can achieve.
2. Structure-Blind Chunking
Category: retrieval designSplitting documents into chunks without regard for their structure routinely separates related information across chunk boundaries — so the answer can exist in the knowledge base and still get missed, because no single chunk contained the whole picture. Structure-aware strategies (semantic or recursive chunking, with deliberate overlap) preserve context far better than a fixed character count, and different document types genuinely need different treatment: a legal contract, a technical manual, an FAQ and a code file don't chunk the same way. This is deep enough a topic to warrant its own treatment — see the chunking strategies guide linked below. See the ten chunking strategies below.
3. Assuming Vector Search Is Enough
Category: retrieval designProduction retrieval shouldn't lean on a single technique. Vector search finds semantic similarity but can miss exact terms, IDs, or rare vocabulary that keyword search catches instantly; metadata filtering narrows candidates by attributes embeddings don't encode at all; and a reranking model reorders whatever the first pass returns by actual relevance to the query. Combining these — hybrid retrieval plus reranking — meaningfully improves the odds the LLM receives the context it actually needs before generation even starts. See reranking below.
4. Skipping Retrieval Evaluation
Category: operational disciplineRetrieval quality doesn't stay fixed — it degrades as enterprise data grows, document formats shift, and the index ages, and none of that shows up until someone measures it. That means someone on the team needs to own a standing set of retrieval metrics — context recall, retrieval precision, faithfulness, groundedness and citation accuracy chief among them — tracked continuously rather than checked once at launch. Catching retrieval failures in a dashboard is a much better place to catch them than in a user-facing answer.
5. Treating RAG as a Finished Product
Category: operational disciplineDocument formats change, user expectations shift, and business goals evolve — which means retrieval quality drifts by default unless something actively fights that drift. Organizations that keep enterprise RAG reliable treat it the way they'd treat any other production system: continuous performance monitoring, regular failure review, real user feedback loops, periodic reranker retraining, and an evolving retrieval pipeline rather than a pipeline shipped once and left alone.
05Chunking: Ten Strategies, Three Families
Chunking is usually treated as a default setting — pick a chunk size, add a bit of overlap, move on to the embedding model. That's a mistake. The chunk boundary decides what your retriever can actually find, what context reaches the LLM, and ultimately how grounded the final answer can be. Two systems using the identical embedding model and the identical LLM can produce very different answer quality purely because one of them chunked its source documents better.
Structural strategies split on visible or countable boundaries. Meaning-aware strategies split — or repair — based on what the text actually means. Retrieval-architecture strategies change what gets indexed versus what gets returned.
Structural & Rule-Based Chunking
1. Fixed-Size Chunking
Use for: simple, uniform textSplits text into chunks of a fixed number of characters or tokens, usually with a fixed overlap. Simple, fast and fully deterministic, with no dependency on document structure — but naive fixed-size splitting with large chunks and heavy overlap is exactly what underperformed in controlled testing (see the research below). Tuned carefully — smaller chunks, little or no overlap — it stays a reasonable baseline; used as a lazy default, it usually isn't.
2. Recursive Chunking
Use for: general-purpose documentsRecursively splits on a prioritized list of separators — paragraph breaks first, then sentences, then words — until each chunk fits a target size, preserving more natural boundaries than raw character counting. This is what LangChain's RecursiveCharacterTextSplitter implements, and it's the de facto default for mixed or unknown document types because it degrades gracefully without needing document-specific logic.
3. Sentence-Based Chunking
Use for: FAQs and support contentSplits at sentence boundaries using NLP sentence segmentation, so each chunk is a self-contained thought. Well matched to FAQ pages and support articles, where each retrieval unit should map cleanly onto one question's answer. The trade-off is that very short chunks can lack surrounding context — a problem sliding-window or contextual chunking (below) exist to fix.
4. Paragraph-Based Chunking
Use for: reports and manualsSplits at paragraph boundaries, preserving the natural unit of argument or explanation a human author already delineated. A good fit for reports, manuals and long-form prose where paragraphs are internally coherent — though resulting chunk sizes are less uniform and less predictable than fixed-size or recursive splitting, which complicates capacity planning for the vector index.
5. Sliding Window Chunking
Use for: content whose context crosses boundariesChunks with deliberate overlap — a window that advances a fixed number of tokens at a time — so content near a boundary still appears in full within an adjacent chunk. Useful whenever meaning-carrying context crosses a natural split point, such as a clause continuing an argument from the previous paragraph, at the cost of a larger index and some retrieved redundancy.
6. Document-Structure-Aware Chunking
Use for: PDFs, policies, and technical docsUses the document's own markup — headings, sections, list items, table boundaries — as chunk boundaries instead of raw character counts. Close to essential for PDFs, policies and technical documentation, where a chunk that silently crosses a section heading mixes two unrelated topics into one embedding. Document-parsing pipelines such as Unstructured's partitioning tools exist specifically to recover this structure from PDFs and HTML before chunking begins.
Meaning-Aware Chunking
7. Semantic Chunking
Use for: topic-heavy contentInstead of splitting on visible structure, semantic chunking embeds consecutive sentences and inserts a boundary wherever the similarity between neighboring sentence embeddings drops — wherever the topic actually shifts, regardless of paragraph or heading markers. The approach traces back to Greg Kamradt's widely cited "five levels of text splitting" work; a cluster-based variant that maximizes embedding similarity within each chunk globally, rather than only comparing adjacent sentences, achieved the highest precision in Chroma's controlled chunking evaluation (see the research below). Best for long-form articles, transcripts and meeting notes that don't map cleanly onto headings.
8. Contextual Chunking
Use for: chunks whose meaning depends on surrounding textPrepends a short, LLM-generated explanation of what a chunk is about and where it sits in the source document, before that chunk is embedded or indexed — so a fragment reading "revenue grew 3% over the previous quarter" gets rewritten with the company name and fiscal period attached. This is Anthropic's Contextual Retrieval technique: contextual embeddings alone cut retrieval failures by 35%, adding contextual BM25 lexical search on top cut failures by 49%, and layering in reranking pushed the improvement to 67% (see the research below). Reach for it when chunks are frequently ambiguous out of context — financial filings, legal contracts, dense technical specifications.
Retrieval-Architecture Chunking
9. Parent-Child Chunking
Use for: precise retrieval with broader contextIndexes small, precise chunks for matching, but returns the larger "parent" chunk or section they belong to as the context actually sent to the LLM. LangChain's ParentDocumentRetriever and LlamaIndex's small-to-big retrieval pattern implement this directly: small chunks give the retriever precision — a query matches one specific sentence — while the larger parent gives the generation step the surrounding context it needs to actually answer well. It decouples what gets matched from what gets read.
10. Hierarchical Chunking
Use for: large repositoriesExtends parent-child chunking into several nested levels — document, section, paragraph, sentence — letting retrieval operate at whichever level best matches a given query and letting the system walk up or down the hierarchy as needed. Suited to large repositories — documentation sites, knowledge bases spanning thousands of documents — where one flat chunk size can't serve both broad "which document covers this" queries and narrow "what exactly does this clause say" queries equally well.
A decision framework
Matching content type to a starting strategy — treat this as a starting point for evaluation, not a final answer.
| Content Type | Start With | Why |
|---|---|---|
| Logs, transcripts, uniform text | Fixed-size or recursive | No exploitable structure; predictable chunk size matters more than boundary precision |
| FAQs, support articles, Q&A pairs | Sentence-based | Each retrieval unit should map to one self-contained answer |
| Reports, manuals, long-form prose | Paragraph-based or recursive | Paragraphs are already coherent argument units |
| PDFs, policies, technical specifications | Document-structure-aware | Section and heading boundaries carry meaning fixed-size splitting would destroy |
| Long-form articles, meeting notes without headings | Semantic chunking | Topic shifts don't align with any visible structural marker |
| Financial filings, legal contracts, dense specs | Contextual chunking | Individual chunks are frequently ambiguous without surrounding context |
| Precision-sensitive QA over long documents | Parent-child chunking | Retrieval precision and generation context are different requirements |
| Large multi-document knowledge bases | Hierarchical chunking | Query granularity varies too widely for one flat chunk size |
| Content where key context sits past a boundary | Sliding window | Deliberate overlap prevents boundary-adjacent meaning from being cut |
| General-purpose default / mixed document types | Recursive | Degrades gracefully without needing document-specific logic |
What the research actually shows
Two controlled studies are worth knowing well, because their numbers are specific enough to act on rather than just directionally suggestive.
Chroma's Chunking Evaluation
Chroma's technical report on chunking built a token-level evaluation framework — precision, recall and intersection-over-union against known-relevant spans — across 472 queries over five different corpora (state documents, Wikipedia, finance, biomedical literature and chat logs). The headline finding: chunking strategy choice changed recall by as much as 9 percentage points between methods. A cluster-based semantic chunker capped at 200 tokens produced the highest precision of everything tested; an LLM-driven chunker that used a language model to choose split points directly produced the highest recall. Recursive character splitting at a modest 200-token size with no overlap held up well against far more sophisticated methods. The most notable result may be the negative one: OpenAI's own commonly used default settings — 800-token chunks with 400-token overlap — scored the lowest across nearly every metric in the study, a reminder that a popular default is not the same thing as an evaluated one.
Anthropic's Contextual Retrieval
Anthropic's Contextual Retrieval work targeted a specific failure mode directly: a chunk that is perfectly well-formed but meaningless once separated from its source, because the company name, date, or subject it refers to lived in a different chunk. The fix — an LLM-generated explanatory prefix added to each chunk before embedding and indexing — produced large, layered improvements.
Both studies point the same direction: the marginal chunking decision —200 tokens versus 800, semantic versus fixed, contextualized versus raw — is not a minor tuning knob. It is frequently a bigger lever on end-to-end RAG quality than swapping the embedding model or the LLM itself.
Test it, don't assume it
The practical takeaway from both studies isn't "always use strategy X" — it's that chunking strategy needs the same evaluation discipline as any other model choice. A minimal version of that discipline: build a small labeled set of queries with known-relevant source spans, measure precision and recall (or IoU) for each candidate chunking strategy against that set, and only then pick a default for production. That evaluation loop is cheap relative to the cost of silently shipping a chunking strategy that caps retrieval quality no downstream reranking or prompt engineering can fully undo.
If you are building a RAG system, chunking is one layer worth testing deliberately — document structure, query patterns, context requirements, latency, cost and retrieval method all pull in different directions, and the strategy that wins for one corpus is rarely the one that wins for the next.
06Reranking: Precision Before the Prompt
Embedding search is fast but coarse. A reranker re-scores the top candidates against the actual query, so the few passages that reach the model are the ones that answer it. Here is where reranking fits, the concepts behind it, and five leading models.
A related pattern places a decision model after retrieval to score each passage and to judge whether the evidence is enough to answer. See RAG vs. Jev + RAG.
Key reranking concepts
Fast embedding-based retrieval — query and doc encoded separately for scalable similarity search.
Query and document processed jointly — slower but highly accurate relevance scoring.
Token-level matching (e.g. ColBERT) — balances bi-encoder speed with cross-encoder precision.
A logit or probability that quantifies how well a document answers a specific query.
Rerankers trained on 100+ languages to support global retrieval pipelines without translation.
5 leading reranking models
Qwen3 Embedding (Reranking)
The Qwen3 Embedding series is specifically designed for text embedding, retrieval, and reranking tasks — delivering state-of-the-art multilingual performance with a unified model family that covers both bi-encoder retrieval and cross-encoder reranking.
View Qwen3 Embedding (Reranking) →NVIDIA NV-RerankQA Mistral 4B v3
Optimized for providing a logit score that represents how relevant a document is to a given query — NVIDIA's Retrieval QA Mistral 4B Reranking Model brings enterprise-grade accuracy to RAG pipelines via the NIM inference platform.
View NVIDIA NV-RerankQA Mistral 4B v3 →Cohere Rerank
From improving response quality to feeding AI agents higher-signal inputs, Cohere Rerank delivers accurate retrieval ranking at enterprise scale — with a simple API, multilingual support, and seamless integration into any existing search or RAG stack.
View Cohere Rerank →Jina Reranker v3
A 0.6B parameter multilingual document reranker introducing a novel "last but not late" interaction architecture — combining the efficiency of bi-encoders with the accuracy of cross-encoders for fast, high-quality reranking across 100+ languages.
View Jina Reranker v3 →BGE — One-Stop Retrieval Toolkit
BGE (BAAI General Embedding) is a comprehensive one-stop retrieval toolkit for search and RAG — offering embedding models, rerankers, and utilities in a unified ecosystem, with top BEIR benchmark results and strong out-of-the-box performance.
View BGE — One-Stop Retrieval Toolkit →07The Metrics That Catch Drift Before Users Do
A useful minimum: track these five continuously rather than spot-checking them once.
| Metric | What It Answers |
|---|---|
| Context Recall | Did retrieval surface all the information actually needed to answer the query? |
| Retrieval Precision | Of what was retrieved, how much was actually relevant — versus noise the LLM has to filter itself? |
| Faithfulness | Does the generated answer stay consistent with the retrieved context, or does it drift into unsupported claims? |
| Groundedness | Can every factual claim in the answer be traced back to specific retrieved evidence? |
| Citation Accuracy | Do the sources cited in the answer actually support what's attributed to them? |
Open-source evaluation frameworks such as RAGAS formalize several of these into automatable, LLM-assisted metrics — worth adopting rather than reinventing, since retrieval evaluation is exactly the kind of discipline that gets skipped when it isn't made easy.
08A Production-Readiness Checklist
Retrieval quality before model selection — a production-ready RAG implementation earns each of these, not just the ones that were easy.
Add to that embedding refreshes as the corpus and embedding models evolve, human review loops on flagged or low-confidence answers, and ongoing performance monitoring in production — not as one-time launch tasks, but as standing operational practice. Optimizing every stage of the pipeline, rather than expecting the LLM to compensate for weak retrieval, is what actually moves the needle on response consistency, hallucination rate and latency together.
A Five-Stage Production Walkthrough
A LinkedIn post by Palanisamy Ramasamy (1 November 2026) makes a point many teams meet in production: a RAG system can retrieve the right document and still give the wrong answer, because the right information never reaches the model in usable form. He observes that teams often spend too much time experimenting with models and too little improving retrieval, and that a bigger model will not fix a broken retrieval pipeline. His five stages, summarized here in our own words, line up with the sections above.
- Ingestion: fix the data before embedding. Remove duplicates with checksums, extract content by page and section, preserve metadata and use token-aware chunking, since poorly structured documents create retrieval problems that no prompt can reliably solve. See the chunking section above.
- Query understanding: search for intent, not just keywords. Normalize domain terminology, expand acronyms, rewrite ambiguous questions and generate multiple queries when needed, because enterprise users rarely phrase questions the way source documents do.
- Context optimization: quality over volume. Use high-recall vector search, stitch neighboring chunks when context is fragmented, filter by metadata and permissions, and rerank with a cross-encoder; retrieving twenty chunks does not mean twenty useful ones. See the reranking section above and the Reranker Models page.
- Generation: make answers verifiable. Ground responses in retrieved evidence, include source references and citations, and detect insufficient context instead of guessing.
- Vector store: design for production. PostgreSQL with pgvector can offer HNSW indexing for approximate similarity search, metadata filtering, persistent storage and transactional consistency, but indexing alone does not guarantee retrieval quality. See the Vector Databases and Open-Source RAG Stack pages.
The post's takeaway matches this guide's checklist: RAG performance is not only about embeddings, chunk size or model choice, but about how well ingestion, query understanding, retrieval, reranking and generation work together, and you should measure whether the system retrieved the right evidence, not only whether it produced an answer. Related pages: Embedding Models, Hallucination Mitigation and LLM Evaluation Methods. Read the original post.
09Where RAG Is Headed
The throughline across every one of these transitions is the same: RAG is maturing from a retrieval trick into an architecture discipline. Good RAG is ultimately about getting the right context, at the right time, from the right source, before asking the model to reason — whether that source is a vector index, a knowledge graph, a live API, or another modality entirely. Teams building on generative AI platforms in 2026 are increasingly judged less on whether they "have RAG" and more on which of these nine architectures they chose, and why.
Expect the next phase to bring tighter integration between retrieval and the agent harnesses, execution loops, and multi-agent graphs coordinating around it — retrieval is no longer a standalone step bolted onto a chatbot; it is one control point in a larger agentic system.
10Retrieval Quality Is the Product
RAG has become a foundational piece of enterprise AI, but production reliability depends on far more than picking a strong LLM. Clean data, structure-aware chunking, hybrid retrieval, continuous evaluation and active monitoring all determine whether a system stays trustworthy once it's handling real traffic rather than a demo dataset. Teams that treat retrieval quality as the actual product — not a preprocessing step on the way to the "real" model — are the ones whose RAG systems hold up as usage, document volume and business requirements keep growing.
11Frequently Asked Questions
Is RAG dead now that LLMs have million-token context windows?
No. Long context killed lazy retrieval, not retrieval itself. Naive, chunk-and-pray RAG pipelines are fading, but retrieval remains far cheaper per query than stuffing everything into a huge context window, and accuracy degrades when relevant content is buried in the middle of a long window. The dominant 2026 pattern is hybrid: use retrieval to narrow down the right context, then use a long window to reason across it.
What is agentic RAG?
Agentic RAG replaces a fixed retrieve-then-generate pipeline with a dynamic reasoning workflow. An agent decides whether retrieval is even needed, which source to query (vector database, SQL, API, web, or knowledge graph), whether the evidence gathered is sufficient, and whether to retrieve again before answering.
What is the difference between GraphRAG and standard vector-based RAG?
Standard RAG treats knowledge as isolated chunks retrieved by semantic similarity. GraphRAG instead represents entities and their relationships explicitly, which makes it much stronger at multi-hop questions that require connecting several pieces of information, at the cost of higher setup and maintenance effort.
What are the most common reasons RAG fails in production?
Five recur: a dirty knowledge base, structure-blind chunking, assuming vector search alone is enough, skipping retrieval evaluation, and treating RAG as a finished product. Each is covered in the production section above.
Which metrics should I track for a RAG system?
At minimum context recall, retrieval precision, faithfulness, groundedness and citation accuracy, tracked continuously rather than spot-checked. Open-source frameworks such as RAGAS help automate them.
Which chunking strategy should I start with?
Start with recursive chunking for mixed or unknown document types, and move to document-structure-aware chunking for PDFs and policies, or contextual chunking for ambiguous fragments. There is no universal best chunk size, so test candidates on your own questions.
What does a reranker do in a RAG pipeline?
A reranker is a second-stage model that re-scores the top candidates from vector search against the actual query, often with a cross-encoder, and keeps only the best few for the model's context window. It improves precision at the cost of some latency.
About this page
This page synthesizes a working taxonomy of ten RAG architectures with current 2026 industry reporting on retrieval-augmented generation adoption, the long-context debate, GraphRAG economics, streaming retrieval, multimodal RAG, and evaluation frameworks such as RAGAS. It is intended as a living reference and will be revisited as the space keeps moving. The "Best for" notes on the evolution ladder follow a LinkedIn post by Ritesh Rai on eight important RAG types (LinkedIn may ask you to sign in), written here in my own words. The post and its readers also note that these types are not exclusive: one system can combine hybrid search, reranking and corrective retrieval.
12Further Reading
Deeper coverage of the pieces this page only sketches.