Adaptive RAG explained: What to know in 2026

Speculative RAG: A faster retrieval-augmented generation

Corrective RAG, or CRAG, is about fixing what standard RAG systems often get wrong. 

Instead of allowing irrelevant or weak context to enter your large language model (LLM) pipeline, CRAG performs checks and corrections, resulting in sharper, faster, and more trustworthy answers.

This guide will show you how CRAG works, why it matters, and where it fits into modern AI workflows. By the end, you’ll know when to use CRAG, where its limits are, and how it compares to other methods like speculative RAG.

Here’s what we’ll cover:

* What CRAG is, how it is an upgrade to traditional RAG, and why it matters in real LLM applications.
* The key components, the workflow that ties them together, and how to implement CRAG in practice.
* When CRAG should be used, what limitations to expect, and how it differs from speculative RAG.

Now, let’s examine the basics more closely.

## What is corrective RAG (CRAG)?

Corrective retrieval-augmented generation, or CRAG, is a [type of RAG-based](https://www.meilisearch.com/blog/rag-types) approach used to improve the reliability of AI-generated answers. 

Instead of simply passing retrieved documents to a language model without any adjustments, CRAG introduces an additional step – it evaluates, filters, and refines the retrieved information before an answer is generated.

This dramatically reduces the risk of AI hallucinations and boosts confidence in the generated response.

Let’s see how CRAG improves the traditional RAG in workflows. 

## How does corrective RAG improve traditional RAG?

A [traditional RAG](https://www.meilisearch.com/blog/what-is-rag) performs document retrieval from a knowledge base and feeds the docs directly to the LLM. The LLM then uses this raw context to generate answers. 

In a traditional RAG pipeline, irrelevant, noisy, or incomplete retrieval results can sometimes slip through, leading to inaccurate outputs. 

CRAG, on the other hand, applies corrective steps before the context reaches the language model. Retrieved documents are filtered, ranked, verified, and even enriched if needed before being passed on to the LLM. 

That way, the LLM receives high-quality, relevant documents before it generates an answer.

![corrective rag-1.png](https://unable-actionable-car.media.strapiapp.com/corrective_rag_1_83b8b193db.png)


## Why is CRAG important in LLM applications?

CRAG makes LLMs more dependable for real-world use cases. 

Here’s why CRAG matters in LLM applications:

* Reduces hallucinations by eliminating weak or misleading inputs before they reach the LLM.
* Improves user trust by consistently providing relevant, accurate, and explainable answers.
* Supports high-stakes use cases such as customer support, healthcare, finance, or enterprise search.

In short, CRAG is vital in production-ready systems that organizations can truly rely on. It also naturally connects with knowledge refinement strategies, helping ensure that external data sources are clean before being used.

## What are the key components of corrective RAG?

Corrective RAG works by layering corrective mechanisms over traditional RAG's basic retriever–generator setup. 

CRAG includes the following key components:


### 1. Retriever

The retriever is responsible for gathering candidate documents from the knowledge base. 

In CRAG, retrieval isn’t limited to a single method – it often combines [vector store search](https://www.meilisearch.com/blog/what-is-vector-search), keyword filtering, and hybrid search to reduce the chances of irrelevant results. 

The retriever creates a pool of potential context, which can be evaluated and refined before the next step.

### 2. Evaluator

As the name suggests, the retrieval evaluator assesses the quality of the retrieved information. Based on relevance and confidence score metrics, it scores the content for relevance and filters out the low-confidence results. 

This is to ensure that the generator isn’t exposed to poor context. In some implementations, evaluators can even run a binary score check or a grade_documents style function to validate candidate results.


### 3. Generator

The generator is the LLM that produces answers. Unlike in a basic RAG pipeline, the generator in CRAG is never fed unchecked inputs. It receives only validated context. 


### 4. Feedback loop

The feedback loop is how the system is continually improved. It uses feedback from outputs to improve its confidence scores, logs user questions, and identifies user feedback to pinpoint errors or gaps that may be causing issues. 

Over time, this loop can expand the knowledge base, retrain retrieval models, and refine evaluator criteria, making CRAG more effective with each iteration. Techniques like self-reflection or even query re-writing can enhance this stage further.

Next, we will map out how these pieces fit into a corrective RAG workflow.

## What does a corrective RAG workflow look like?

A corrective RAG workflow adds evaluation and correction layers to the standard retrieval–generation cycle. The goal is to ensure the language model works only with the most reliable and relevant context.

![image7.png](https://unable-actionable-car.media.strapiapp.com/image7_0064aea584.png)

1. **Query input:** The process starts with a user query. The system interprets intent and sets up retrieval.
2. **Retrieval:** The retriever fetches candidate passages from the knowledge base, often using hybrid methods like keyword plus vector search, as detailed in our guide to[ RAG techniques](https://www.meilisearch.com/blog/rag-techniques). Tools like Meilisearch, LangChain, LlamaIndex, or even Tavily as a web search tool can be integrated here.
3. **Evaluation:** The evaluator reviews both the context and the draft response. It filters out weak or irrelevant passages and ensures only high-confidence context continues forward. Evaluators might rely on a grader system powered by OpenAI embeddings or transformers.
4. **Generation:** The retrieved context is passed to the language model. At this stage, the model drafts a response based on the available information.
5. **Correction:** Before finalizing the answer, the system reranks, replaces, or augments weak passages. In some cases, it may even expand retrieval to fill in gaps using a text_splitter or a transform_query step.
6. **Iteration:** User feedback, confidence scores, and query logs feed into the feedback loop, helping the system improve retrieval quality over time.

This workflow resembles a graphstate architecture, where different nodes—retriever, evaluator, generator, feedback—connect through a structured schema. Frameworks like langgraph or langchain_core allow developers to compile such pipelines and extend them with as_retriever utilities.

## How to implement corrective RAG

Corrective RAG adds a quality gate between document retrieval and generation. You start by setting up fast recall, then add steps to rerank, validate, and refine context before passing it to the language model.

The implementation can be done in Python, integrating libraries from GitHub. Advanced users sometimes explore self-rag systems, where the model runs an internal web search or external knowledge lookup before committing to a final response.

### 1. Index data with Meilisearch

The first step is to load documents into a search index and adjust retrieval controls so you can quickly recall candidates and apply filters or synonyms before performing any corrective checks.

```python
# pip install meilisearch
from meilisearch import Client
client = Client("http://127.0.0.1:7700", "MASTER_KEY")
idx = client.index("docs")
docs = [
  {"id": "1", "title": "FAQ: Billing", "body": "Upgrade rules and discounts."},
  {"id": "2", "title": "Guide: Exports", "body": "CSV, JSON, API sync details."},
  {"id": "3", "title": "Policy: Refunds", "body": "Refund window is 30 days."}
]
idx.add_documents(docs)
idx.update_settings({
  "searchableAttributes": ["title", "body"],
  "filterableAttributes": ["title"],
  "typoTolerance": {"enabled": True},
  "synonyms": {"refund": ["return", "money back"]}
})
```


### 2. Retrieve candidates and rerank with corrective signals

After recall, the next step is to rerank and validate results. This filters out noisy passages and guarantees that only high-confidence context is passed to generation.


```python
query = "What is the refund policy?"
# Fast recall from Meilisearch
hits = idx.search(query, {"limit": 10})["hits"]
# Example: simple heuristic reranker
def relevance_score(hit, q):
    text = (hit.get("title","") + " " + hit.get("body","")).lower()
    return sum(1 for term in q.lower().split() if term in text)
scored = sorted(hits, key=lambda h: relevance_score(h, query), reverse=True)
# Keep high-confidence candidates only
CUTOFF = 3
candidates = scored[:CUTOFF]
# Optional: LLM-as-judge to validate each candidate against the query
def llm_validate(q, passage) -> float:
    # Return a 0–1 score. Stub here for brevity.
    return 0.9 if "refund" in passage.lower() else 0.4
validated = []
for c in candidates:
    score = llm_validate(query, c["body"])
    if score >= 0.7:
        validated.append({**c, "crag_score": score})
```


With clean and reliable candidates, the next step is to check for contradictions or missing pieces, then correct or augment the context before generation.


### 3. Evaluate and correct the context

We will validate the shortlisted passages and correct them when needed. This step catches contradictions, fills gaps, and removes duplicates so only strong evidence reaches the model.


```python
from collections import defaultdict
def detect_duplicates(items):
    seen, out = set(), []
    for it in items:
        key = (it.get("title",""), it.get("body",""))
        if key not in seen:
            seen.add(key); out.append(it)
    return out
def needs_more_evidence(query, validated):
    has_refund = any("refund" in c["body"].lower() for c in validated)
    return not has_refund
def expand_query(query):
    return [query, "refund window", "return policy", "money back"]
validated = detect_duplicates(validated)
if needs_more_evidence(query, validated):
    aug_terms = expand_query(query)
    more = []
    for t in aug_terms:
        more.extend(idx.search(t, {"limit": 5})["hits"])
    # simple merge then rerun validator
    merged = detect_duplicates(validated + more)
    revalidated = []
    for c in merged:
        score = llm_validate(query, c["body"])
        if score >= 0.7:
            revalidated.append({**c, "crag_score": score})
    validated = revalidated
```


Next, only the corrected and validated context is passed on to the language model.


### 4. Assemble the prompt and generate the final answer

We need to combine the refined passages into a compact prompt with clear instructions. For this, you will need to ask for citations and require the model to ignore low-confidence content.


```python
def make_context(validated, max_chars=1800):
    out, used = "", []
    for c in validated:
        piece = f"[{c.get('id','')}] {c.get('title','')}: {c.get('body','')}\n"
        if len(out) + len(piece) <= max_chars:
            out += piece; used.append(c)
    return out, used
ctx_text, used_passages = make_context(validated)
prompt = f"""
You are a careful assistant.
Question: {query}
Evidence:
{ctx_text}
Instructions:
1) Answer strictly from Evidence.
2) Cite sources by their IDs like [1], [2].
3) If Evidence is insufficient, say "Not enough information" and list missing facts.
Return a concise, factual answer.
"""
from openai import OpenAI
import os
client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY","YOUR_API_KEY"))
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role":"user","content": prompt}]
)
answer = response.choices[0].message.content
print(answer)
```


Next, close the loop with feedback so the system learns and improves over time.


### 5. Log feedback and improve continuously

By closing the loop with feedback, you help the system record confidence, missing fields, and user signals so the pipeline can self-correct. This data allows us to tune retrieval settings in Meilisearch to expand coverage where gaps are common.


```python
feedback_log = []
CONFIDENCE_THRESHOLD = 0.7
def log_feedback(query, answer, confidence, missing=None):
    feedback_log.append({
        "query": query,
        "answer": answer,
        "confidence": confidence,
        "missing": missing or []
    })
def should_expand(entry):
    return entry["confidence"] < CONFIDENCE_THRESHOLD or len(entry["missing"]) > 0
def auto_expand(missing_terms):
    for term in missing_terms:
        hits = idx.search(term, {"limit": 10})["hits"]
        # here you would extract entities, relations, and upsert to your store
        # or keep the hits for future retrieval tuning
# example usage
log_feedback(query, answer, confidence=0.68, missing=["refund timeframe", "exceptions"])
for entry in feedback_log:
    if should_expand(entry):
        auto_expand(entry["missing"])
```


This completes the corrective flow. 

You now have fast recall with Meilisearch, corrective scoring and validation, targeted augmentation, safe generation, and a learning loop that keeps improving.

## When should you use CRAG?

Like traditional RAG, corrective RAG is most useful in industries or situations where precision is essential. As it improves upon traditional RAG with better context and retrieval, CRAG becomes a much more valuable tool. 

Let’s see where we can use it:

* **Customer support:** A chatbot fed the proper context performs far better than one with misleading context. 
* **Healthcare:** CRAG plays a significant role in healthcare by validating retrieved studies and records, so clinical support tools rely only on trustworthy medical evidence.
* **Legal research:** Corrective RAG grounds answers in the right case law, statutes, and precedents to avoid hallucinations or imprecise citations.
* **Financial services:** CRAG screens market data, reports, and filings before generation, reducing the risk of misleading compliance or poor investment insights.
* **Enterprise knowledge management:** In knowledge bases, CRAG improves internal search by resolving contradictions and filtering out duplicate or noisy content across teams.
* **Education and training:** In education and training, CRAG can support tutoring systems by delivering fact-checked explanations rather than shallow or misleading answers.

CRAG adoption in these high-stakes domains adds a layer of trust to AI systems.

## What are the limitations of corrective RAG?

CRAG offers developers a plethora of perks and benefits, but these come with certain tradeoffs. For instance, it dramatically improves factuality but can also limit scalability and performance. 

Here are some other CRAG limitations to keep in mind:

* **Computational cost:** More detailed steps mean more computational costs. If we want to run retrieval, evaluation, and correction, the latency infrastructure requirements go up. For applications needing real-time responses, this can be a challenge.
* **Dependency on feedback mechanisms:** CRAG relies heavily on evaluators or human-in-the-loop feedback to refine outputs. If feedback quality is poor or inconsistent, the corrections can be less effective.
* **Potential overcorrection:** With correction, there’s always potential for overcorrection, and you might lose useful but unconventional information.
* **Complexity of implementation:** Layers upon layers mean a higher chance of something going wrong.
* **Limited adaptability:** If the correction logic is too rigid, the system may struggle to adjust quickly to new datasets or changing data sources without retraining or fine-tuning.

Despite these challenges, CRAG is still a powerful approach for domains where accuracy outweighs latency or cost. 

Let’s see how corrective RAG differs from speculative RAG.

## How does corrective RAG differ from speculative RAG?

The main difference between corrective RAG and speculative RAG is *when and how* corrections or predictions occur during the retrieval–generation process. 

Corrective RAG evaluates the generated output and fixes errors after retrieval, while[ speculative RAG](https://www.meilisearch.com/blog/speculative-rag) speeds up response generation by predicting multiple candidate outputs early and pruning them later.

![corrective rag.png](https://unable-actionable-car.media.strapiapp.com/corrective_rag_7f8c530bc5.png)

In short, CRAG emphasizes trustworthiness, while speculative RAG prioritizes speed. Both can complement each other depending on system goals.

## Final thoughts on building with corrective RAG

Corrective RAG helps close the gap between speed and reliability in generative AI systems. Adding evaluation and correction loops reduces hallucinations and gives you more trustworthy outputs in real-world applications.

Corrective RAG (CRAG): Workflow, implementation, and more

RAG (retrieval-augmented generation) represents a way for AI systems to retrieve and use relevant information from external knowledge sources to generate more accurate responses. 

Instead of relying only on training data, RAG uses real-time data (from documents or databases) before generating responses.

Different types of RAG architecture handle various tasks, depending on the level of complexity. 

Some RAG types are simple; they retrieve once and generate an answer. 

Other types require multiple steps (such as retrieving, refining, and re-generating) to improve the quality of their response. 

Here is a table that briefly describes the various RAG types along with their use cases.

![RAG types.png](https://unable-actionable-car.media.strapiapp.com/RAG_types_0be7d3e99b.png)

## 1. Simple RAG (original)

Simple RAG (original) refers to the most basic form of [retrieval-augmented generation](https://www.meilisearch.com/blog/what-is-rag), where the AI system retrieves relevant documents from a knowledge base in a single step and uses that information to generate a response. 

It is the most straightforward implementation.

![Simple RAG (Original).png](https://unable-actionable-car.media.strapiapp.com/Simple_RAG_Original_b58e096a23.png)

Simple RAG works by converting a user query into embeddings, searching a vector database for semantically similar content, retrieving the top matching documents, and then feeding your original question and the retrieved information to a large language model (LLM) for answer generation. The retrieval process is predictable.

Simple RAG is used in basic question answering systems, chatbots, or FAQ automation, where questions have relatively straightforward answers.

**Pros:**

* Fast response times
* Easy to set up and implement
* Low computational cost

**Cons:**

* Struggles with questions requiring multiple sources
* No feedback after generating a response
* Does not improve if the data retrieval is poor

## 2. Simple RAG with memory

RAG with memory refers to an enhanced version of simple RAG that can remember previous conversations. 

In the context of RAG, memory refers to the AI system's ability to keep track of past interactions (such as past questions, answers, or retrieved documents). It does not just remember what was said, but understands how previous context can influence new searches. 

![Simple RAG but With Memory.png](https://unable-actionable-car.media.strapiapp.com/Simple_RAG_but_With_Memory_2d48540c41.png)

Simple RAG with memory works by storing key parts of previous conversations and using them with new queries to generate better answers. 

For instance, if a user asks about the capital of France and later refers to ‘its population,’ the system recalls the context to determine that the user's query is still referring to Paris. 

RAG with memory is used in personal AI agents, conversational chatbots, customer support systems, or educational tutoring platforms.

**Pros:**

* Reduces repetitive explanations
* Encourages more human-like interactions
* Personalizes responses based on user conversation history

**Cons:**

* Higher processing cost than the original simple RAG
* Higher risk of retrieving outdated or incorrect information
* Raises questions about data privacy

## 3. Agentic RAG

[Agentic RAG](https://www.meilisearch.com/blog/agentic-rag) is a more dynamic RAG that acts like an experienced researcher. Instead of just retrieving the first relevant documents, it plans its approach, decides what to investigate, and then takes action using associated tools. 

Agentic RAG works by breaking down a task into smaller steps. It figures out what your question needs and then searches various data sources for valuable information. 

It does not stop at the first result. It checks whether what it found answers the question, and if not, it continues searching. 

![Agentic RAG.png](https://unable-actionable-car.media.strapiapp.com/Agentic_RAG_bc913668a1.png)

Agentic RAG can be used in legal research where lawyers conduct comprehensive case analysis, and in financial analysis that combines market data with regulatory information. Agentic RAG is useful when you require methodical planning.

**Pros:**

* Good for multi-step reasoning
* Intelligent decision-making about information gathering
* Can improve performance on complex queries

**Cons:**

* Costs more to run due to multiple searches
* Difficult to build and manage
* Takes longer to respond since it is doing actual research work


## 4. Graph RAG

[Graph RAG](https://www.meilisearch.com/blog/graph-rag) uses a knowledge graph to understand how different pieces of information are connected. It finds relationships and patterns between pieces of data rather than just searching for matching words.

![Graph RAG.png](https://unable-actionable-car.media.strapiapp.com/Graph_RAG_b6ffce03d4.png)

Graph RAG works by mapping out how different entities in your knowledge base are interconnected. It then uses these relationships to find relevant data. Even if a document does not have your exact search terms, it might still be helpful if it is conceptually related.

Graph RAG is used in fields where the relationships between concepts are crucial, such as investigative journalism, which uncovers hidden connections, or business intelligence, which requires understanding market relationships.

**Pros:**

* Great for complex questions requiring connecting multiple concepts
* Helps prevent scattered answers
* Can provide unexpected but relevant responses

**Cons:**

* Requires significant work to build the knowledge graph
* Slower than basic RAG systems
* Only as good as the connections you have taught it to recognize

## 5. Self-RAG

Self-RAG is a type of RAG that improves its search by rewriting your question before looking for answers. It behaves like a researcher who constantly questions their work. 

Self-RAG works by first providing an answer based on the retrieved data, then using specialized evaluation modules to check whether the answer is accurate and supported by the source material. It uses a language model to rewrite the original query, adding missing context and inferred intent from previous conversations.

![Self-RAG.png](https://unable-actionable-car.media.strapiapp.com/Self_RAG_44c6d5034a.png)

Self-RAG is used when questions are incomplete or there is insufficient detail to retrieve the proper documents. 

**Pros:**

* Catches and corrects its own mistakes before you see them
* Helps get better results from vague questions
* More reliable in scenarios where accuracy matters

**Cons:**

* Higher costs to run all those extra checks
* Slower since it is doing the work twice
* Can be too cautious and refuse to answer when uncertain


## 6. Branched RAG

Branched RAG is a type of RAG that explores multiple lines of thought simultaneously before deciding on the best answer. 

![Branched RAG.png](https://unable-actionable-car.media.strapiapp.com/Branched_RAG_a2d1bf0ffd.png)

Branched RAG works by generating responses for different interpretations of your question, retrieving answers for each one, and then comparing the answers to pick the most relevant response.

Branched RAG is used in comprehensive market research, where structured data such as technical specifications, competitor insights, and customer feedback are needed simultaneously.

**Pros:**

* Handles open-ended questions well
* Less likely to miss important aspects of complex questions
* Can provide more thoughtful final response

**Cons:**

* Complex to coordinate findings from different sources
* Can overwhelm users with information if not properly filtered

## 7. Multimodal RAG

Multimodal RAG is a version of RAG that simultaneously uses text, images, videos, audio files, charts, and documents to answer your questions. 

![Multimodal RAG.png](https://unable-actionable-car.media.strapiapp.com/Multimodal_RAG_2c097525a4.png)

[Multimodal RAG](https://www.meilisearch.com/blog/multimodal-rag) converts different types of content (a graph, a photo, a video clip, or a document) into a format it can search through and understand. When you ask a question, it looks through all these different media types to find relevant information and combines everything to provide an accurate response.

Multimodal RAG is used to analyze files that combine text and other forms of media.

**Pros:**

* Works with any type of content
* Provides complete answers using different sources
* Great for visual topics that need multiple perspectives

**Cons:**

* More complex to build and train
* Requires more storage and processing power
* Quality depends on how well it interprets various data formats

## 8. Adaptive RAG

[Adaptive RAG](https://www.meilisearch.com/blog/adaptive-rag) is a RAG model that learns from experience. It pays attention to what works and what doesn’t, and gradually improves its ability to respond to different kinds of questions. 

![Adaptive RAG.png](https://unable-actionable-car.media.strapiapp.com/Adaptive_RAG_60242702c1.png)

Adaptive RAG works by first recognizing the type of question (simple, complex, broad, or narrow) it received, then adjusting its retrieval process and generation style based on the question to provide an accurate answer.

Adaptive RAG is used in systems that deal with all kinds of queries, such as customer support bots, research tools, and digital assistants.

**Pros:**

* Gets better at helping you over time by learning your preferences
* Improves relevance by adjusting to the query type
* Can balance speed and depth when required

**Cons:**

* It takes time to learn and improve, so early results might be inconsistent
* More complex to build and maintain than static RAG architectures
* Can get stuck in bad habits if it learns from poor examples


## 9. Speculative RAG

[Speculative RAG](https://www.meilisearch.com/blog/speculative-rag) does not wait for you to finish asking your question. Instead, it anticipates what you might want to know next and pre-fetches that information in the background.

![A graph showing how speculative RAG works. ](https://unable-actionable-car.media.strapiapp.com/Speculative_RAG_4c1f083ea9.png)

Speculative RAG works by analyzing your current question and conversation history to predict likely follow-up queries. It then retrieves relevant documents for those anticipated questions while still working on your actual question, so when you do ask that follow-up, it already has the relevant data available.

Speculative RAG is used when speed matters, such as real-time chatbots, autocomplete suggestions, or customer service systems.

**Pros:**

* Faster response time
* Creates a more natural conversation flow
* Reduces waiting time when exploring complex topics

**Cons:**

* Risk of retrieving the wrong information if the guess is inaccurate
* Wastes computational resources on predictions that turn out wrong

## 10. Corrective RAG

[Corrective RAG](https://www.meilisearch.com/blog/corrective-rag) is designed to double-check its answers and correct them if something is wrong. 

![Corrective RAG.png](https://unable-actionable-car.media.strapiapp.com/Corrective_RAG_fa0994f373.png)

Corrective RAG works by doing the usual search and generating an answer, but then it steps back and asks, ‘Does this fully answer the question?’ 

If the answer feels off, it drops the weaker sources and tries a new search to find more relevant information before updating the response.

Corrective RAG is used when accuracy is important, such as in legal research, academic writing, or policy analysis.

**Pros:**

* Catches and fixes poor search results before you see them
*  Improves the reliability and accuracy of generated responses
* Adds an extra layer of quality control

**Cons:**

* Takes longer since it might need multiple search attempts
* Can get stuck in loops if it is never satisfied with what it finds
* Uses more computational resources performing extra searches


## 11. Modular RAG

[Modular RAG](https://www.meilisearch.com/blog/modular-rag) is like a toolkit: different modules handle different parts of the process, and you can combine them however you want, depending on the use case. 

The system is flexible, so you can swap in a new retriever, a better reranker, or a different generator. 

![Modular RAG.png](https://unable-actionable-car.media.strapiapp.com/Modular_RAG_f45a20e140.png)

Modular RAG works by breaking the system into separate components, allowing you to customize each part without rebuilding the entire system. 

Modular RAG is used across multiple domain-specific research environments and production AI applications.

**Pros:**

* Can easily optimize each component
* Easy to upgrade or replace components without starting afresh
* Great for customizing workflows

**Cons:**

* More complex to coordinate all the different components
* Takes planning ahead to figure out how all the parts will fit together

## 12. Naive RAG

Naive RAG is the simplest form of RAG. It pulls documents based on your question and passes them straight to the model without making any adjustments.

![Naive RAG.png](https://unable-actionable-car.media.strapiapp.com/Naive_RAG_2535319547.png)

Naive RAG works by converting your question into basic search terms, pulling the top documents that match those terms, and then passing them straight to the language model to generate a response. There is no filtering or reranking; it is just a simple matching algorithm.

Naive RAG is used in simple chatbots with a limited scope and basic FAQ systems where questions are predictable.

**Pros:**

* Very simple to build and understand
* Fast, since there is no complex processing involved
* Low computational costs

**Cons:**

* Struggles with complex questions
* No verification of search results
* Often retrieves irrelevant documents that affect the final answer


## 13. Advanced RAG

[Advanced RAG](https://www.meilisearch.com/blog/rag-techniques) is a more refined version of RAG that combines multiple steps (such as reranking, memory, feedback loops, branching, improved data retrieval, etc.) to get more accurate results.

![Advanced RAG.png](https://unable-actionable-car.media.strapiapp.com/Advanced_RAG_9b806ab383.png)

Advanced RAG works by layering various RAG techniques: it can rewrite the query to make it more straightforward, rank the results, check if the answer makes sense, and even review it if required, all to ensure that the generated response is the most relevant and accurate.

Advanced RAG is used in systems when making mistakes is not an option, such as in research tools or enterprise applications.

**Pros:**

* Handles complex questions better
* Smart enough to know which approach works best for different situations
* Offers more control over how results are generated

**Cons:**

* Requires expertise to build and keep running properly
* Requires careful fine-tuning to ensure all parts work together effectively
* Expensive to run due to its background work

## 14. HyDE (hypothetical document embedding)

HyDE is a unique approach in RAG in which the AI model starts by generating a guess as to what a good answer might look like and then uses that guess to search for real documents that match it.

![HyDe.png](https://unable-actionable-car.media.strapiapp.com/Hy_De_c9bf688f29.png)

HyDE works by generating a hypothetical answer first, converting it into a search query, and then retrieving real documents similar to the imagined one. This is the opposite of how you expect searches to work.

HyDE is used when traditional keyword searches struggle. It is helpful in academic research systems, legal databases, or medical information systems.

**Pros:**

* Focuses on semantic meaning, not just matching terms
* Useful in technical domains that are hard to search
* Helpful when the original query is missing key details

**Cons:**

* Harder to explain how it got its result
* Slow because of the added steps
* The hypothetical answer might lead the searcher down completely wrong paths


## Why are there different types of RAG architecture?

Different types of RAG architecture exist because no single setup works well in every situation. You choose what works best for you based on your intended use case.

Some tasks require speed and simplicity, while others call for deeper analysis, multiple sources, or even different types of input, such as images or graphs. 

For example, simple RAG can handle quick and straightforward queries. But if you are working on complex research or handling messy data, you might consider something smarter, such as agentic or self-RAG.

Now, let’s see the importance of RAG.


## What is the importance of RAG?

[RAG is a technique](https://www.meilisearch.com/blog/rag-techniques) that combines information retrieval with generative AI. It retrieves documents from a knowledge base and uses them to generate a more relevant and accurate answer.

It is important because it helps language models stay grounded in true information rather than hallucinations. 

RAGs are widely used for various real-world use cases. 

Tech companies, for instance, use RAG to help support agents quickly find answers to technical issues without going through pages of documentation. 

Law firms use it to scan thousands of legal documents in seconds. 

Hospitals also use RAG to enable doctors to match patient symptoms with findings from medical literature, thereby improving their diagnosis and treatment decisions.


## What tools are used for RAG?

RAG tools are the building blocks that connect your data to powerful language models to deliver accurate results.

Here are some [retrieval-augmented generation tools](https://www.meilisearch.com/blog/rag-tools) that are used in different RAG applications:


* **Meilisearch:** A super-fast search engine that supports both keyword and vector search. It is excellent for balancing keyword and semantic search and works smoothly with embedding models through a simple API. 
* **LangChain:** An open-source orchestration framework that connects retrievers, embedding models, and generators. It helps manage your entire RAG pipeline and handles the process of integrating with APIs, databases, and file formats.
* **Weaviate:** A vector database built for production. It supports hybrid search, filtering, and fast, scalable queries. 
* **Faiss:** A vector search library developed by Meta. It allows you to index and search embeddings efficiently, ensuring that the AI system focuses on meaning instead of just keywords.
* **Haystack:** A complete RAG framework that combines retrieval, question answering, and generation. It is useful when you want all RAG components to work together seamlessly.

RAG tools are categorized based on the part of the pipeline they support (retrieval, generation process, orchestration, or storage). Choosing the right tool depends on what stage you are working on and what you are trying to build.


## Build efficient RAG systems with Meilisearch

Choosing the right RAG approach comes down to matching the architecture to the problem you’re solving. 

As the technology evolves, RAG will continue to play a central role in building AI systems that stay grounded in relevant data. 

Combining strong retrieval with effective generative models helps reduce errors, improve reliability, and make AI more useful in real-world scenarios – whether for quick lookups, complex research, or anything in between.

14 types of RAG (Retrieval-Augmented Generation)

RAG techniques help optimize the accuracy and flexibility of RAG pipelines. From smarter chunking to hybrid search and context distillation, these methods are key to delivering faster, more accurate responses in real-world AI applications.

Why do we need them?

Because basic RAG systems often struggle with noisy results, irrelevant context, or poor ranking. 

When the retrieval system cannot surface relevant information, users lose trust, and your LLM wastes time processing the wrong context.

This guide breaks down nine advanced RAG techniques worth knowing:

* Text chunking
* Reranking
* Leveraging metadata
* Hybrid search
* Query rewriting
* Autocut
* Context distillation
* Fine-tuning the large language model (LLM)
* Fine-tuning the embedding models

You’ll also learn how to implement these strategies using tools like Meilisearch, LangChain, and vector databases, plus how to evaluate which ones actually move the needle. 

Let’s get into it.

![A table listing the most important advanced RAG techniques.](https://unable-actionable-car.media.strapiapp.com/Advanced_RAG_techniques_9ce2dce000.png)

## 1. Text chunking

Text chunking breaks long documents into smaller pieces (‘chunks’) that are easier to index and retrieve. 

Instead of pulling in whole documents, RAG pipelines work with these chunks, and the quality of the chunks directly affects retrieval accuracy and answer clarity.

If your chunks are too long, the artificial intelligence model will get distracted. On the other hand, if they’re too short, context will be lost. The right balance helps deliver the best results.

Here are a few types of chunking:

* **Simple chunking:** Splits documents into fixed-size blocks with a bit of overlap (e.g., 35 characters with a five-character overlap). Easy to implement, ignores semantic structure, and may split key ideas across chunks.
* **Semantic chunking:** Groups sentences by similarity using embeddings and cosine thresholds. Keeps related ideas together and improves retrieval precision, but requires embedding models like BERT and higher-performance computing.
* **Language model–based chunking:** Uses an LLM to segment text into self-contained propositions. Produces highly coherent results but is computationally expensive and may require fine-tuning.

Not to anyone’s surprise, each method has its trade-offs. Semantic or LLM-based chunking will likely pay off if you work with product manuals or technical docs. For simpler content, fixed-size chunks will do the job just fine.

## 2. Reranking

In RAG systems, the initial retriever pulls in a wide net of retrieved information, some good and some not so good. Reranking is the process of reordering results so that the most relevant information rises to the top before being passed to the LLM.

Here are a few common approaches to reranking:

* **Cross-encoder reranking:** Feeds the user query and each candidate chunk into a transformer model (like BERT) that scores how well they match. Very accurate but slow and resource-intensive. Best when quality matters more than latency.
* **Score-based reranking:** Adjusts order using heuristics or relevance scores (e.g., BM25 boosts, keyword search matches). Fast and lightweight, but less nuanced.

Both techniques are valid, but your choice depends on how much latency you can afford. 

## 3. Leveraging metadata

Leveraging metadata means using structured tags, like date, author, domain, or document type, to filter and boost the right results. 

Metadata filtering is a low-lift, high-impact technique since it doesn’t require any heavy computing.

Here are its key sub-types:

* **Date filtering** removes outdated data and only focuses on recent documents. This is useful in fast-changing fields like finance. However, this focus on recency can sometimes exclude essential documents. 
* **Author/source filtering** boosts retrieved documents from trusted individuals or sources. There’s a very low chance of hallucinations, but you might also miss out on less well-known but highly relevant data.
* **Document type filtering** includes filters based on format (e.g., guide vs. blog vs. policy doc). While it can help match user intent, there’s an added risk of over-filtering if metadata is inconsistent.


## 4. Hybrid search

[Hybrid search](https://www.meilisearch.com/blog/hybrid-search) combines keyword-based (sparse) and vector-based (dense) retrieval methods to improve result quality. 

This dramatically increases relevance, especially in edge cases or ambiguous user queries.

Here are the two main approaches to hybrid search:

* **Score fusion:** Combines results from sparse and dense methods using weighted scores. Balanced accuracy. Needs careful tuning to avoid noisy results.
* **Result merging:** Retrieves top results from both methods, then merges and reranks them. Simple to implement. Risk of duplication or inconsistent ranking logic.


## 5. Query rewriting

Query rewriting refines user input before the retrieval process. It reformulates vague or underspecified queries so the retrieval system can better understand intent and return more relevant results. This is especially helpful when dealing with short or typo-heavy queries.

Most modern generative AI systems use various algorithms to upgrade queries behind the scenes. Here are a few types:

* **Synonym expansion:** This technique automatically adds equivalent terms to cover more variations. While this may improve recall, it can also introduce some irrelevant matches.
* **Spelling correction:** Any typos or misspellings are automatically fixed. It boosts success for casual users, but there’s a chance it might ‘correct’ niche or valid jargon.
* **Intent clarification:** This process transforms a broad query into a clearer one using rules or machine learning. It improves relevance but requires training data and adds complexity.


## 6. Autocut

Autocut trims text dynamically based on token limits or model constraints, without cutting into semantic meaning. There’s a method for removing the less relevant context without displacing the critical info. 

This matters because many LLMs have strict token limits. If you overload the context window, the AI model may hallucinate, skip over key info, or underperform. 

Here are two common strategies for autocutting:

* **Scored trimming** helps rank content by importance and cuts the lowest-scoring sections. While the prioritization is smart, it needs a scoring mechanism in place.
* **Rule-based trimming** applies fixed rules (e.g., drop intro paragraphs or footnotes). It’s easy to implement, but it lacks adaptability to nuanced content.

## 7. Context distillation

Parsing large documents at every instance isn’t optimal for high-level RAG systems. Context distillation helps condense large documents into high-value, meaningful summaries. 

As you know, LLMs only require the *right* information, not *all* the information. More context doesn’t necessarily mean better results; it might even dilute the final output. Context distillation helps the model stay focused and accurate when it comes to response generation.

Two ways to approach this:

* **Summarization-based distillation** uses extractive or abstractive summarization to retain key points. Produces concise context but may miss details.
* **Question-driven distillation** tailors context based on the specific question being asked. Highly relevant, but depends on accurate query understanding.

## 8. Fine-tuning the LLM

Fine-tuning the LLM involves retraining a pre-trained [language model](https://www.meilisearch.com/blog/mastering-rag) on your specific datasets to understand better the type of generated responses you want. 

It’s useful when prompt engineering alone can’t guide the model well enough, especially in regulated industries or domain-specific contexts.

* **Supervised fine-tuning:** Retrains with labeled Q&A, code, or instructions. Offers precision and control but requires curated data and resources.
* **Reinforcement learning from human feedback:** Humans rate outputs, and the model learns to favor preferred responses. Aligns with values or brand tone but is resource-intensive.

## 9. Fine-tuning the embedding models

Embedding models turn documents into vectors for document retrieval. Fine-tuning them means reshaping how the retrieval model ‘understands’ similarity, which is essential if off-the-shelf embeddings underperform in your field.

* **Contrastive learning:** Trains embeddings to pull semantically similar text closer and push dissimilar text apart. Improves retrieval accuracy but requires labeled positives and negatives.
* **Domain adaptation:** Continues training on your corpus to align embeddings with your field. Easier to set up, especially with unlabeled data, but risks overfitting.

Fine-tuning the LLM and embedding models gives you complete control over both retrieval and generating responses, setting the foundation for a high-performing, domain-aware RAG model.

## What are advanced RAG techniques?

Advanced RAG techniques go beyond the basics of retrieval-augmented generation. They are more detailed and nuanced when it comes to chunking, retrieval, and ranking content. The end goal, however, is the same: to generate better and more relevant search results. 

Whether you're optimizing hybrid search, rewriting queries, or tweaking metadata, these approaches build on the core principles of[ retrieval-augmented generation](https://www.meilisearch.com/blog/what-is-rag) to scale both accuracy and efficiency.

## Why are advanced RAG techniques needed?

The problem with basic RAG setups is that they often struggle with complex queries. Also, they aren’t enough when scaling across diverse datasets or maintaining relevance in high-stakes situations. 

As user expectations grow and LLMs become more central to production-grade workflows, brute-force retrieval is no longer enough. We need smart AI applications to understand nuance and prioritize recent data from trusted sources. 

Advanced techniques help you move from ‘retrieve and hope’ to ‘retrieve with intent.’ They address key pain points like hallucination, latency, and content mismatch, while unlocking improved precision and performance.


## How can you implement advanced techniques in RAG?

You can implement advanced retrieval techniques using different tools, libraries, and frameworks.

Some of the [RAG tools](https://www.meilisearch.com/blog/rag-tools) you can use to implement advanced retrieval-augmented generation techniques are the following:

* Meilisearch
* Weaviate
* LangChain
* Pinecone

Let’s learn a little more about them:


### 1. Meilisearch

Developed with user experience in mind, Meilisearch is an open-source tool that is perfect for implementing advanced RAG pipelines. It supports customizable ranking rules and handles large document collections easily. 

You can implement hybrid search (combining keyword-based and vector search relevance) using Meilisearch’s [hybrid search plugin](https://www.meilisearch.com/solutions/hybrid-search). This balances semantic search understanding with traditional precision.


```json
POST /indexes/products/search
{
  "q": "secure laptop",
  "vector": [0.128, 0.98, 0.45, …],
  "attributesToRetrieve": ["title", "description"],
  "limit": 10
}
```


When dealing with large documents, you can boost [search quality](https://www.meilisearch.com/docs/guides/improve_relevancy_large_documents) by indexing them as structured chunks:


```json
{
  "title": "AI Compliance Guide",
  "content_chunk": "RAG systems rely on fast indexing and retrieval...",
  "chunk_id": 12
}
```


Meilisearch’s performance and easy integration make it a go-to solution for building smart RAG pipelines without overcomplicating things.


### 2. Weaviate

Weaviate is a vector-native search engine built for high-performance semantic search. It integrates with transformers and embedding models directly, making it a good fit for RAG implementations.


### 3. LangChain

LangChain is a Python/JavaScript framework that chains together LLMs, retrieval components, and tools. It makes RAG workflows modular and configurable.

You can plug in reranking models, write your own query rewriters, and manage chunking pipelines all within one orchestrated flow.


### 4. Pinecone

Pinecone is a managed vector database built for high-scale similarity search. It’s useful for projects that need lightning-fast, scalable vector retrieval, reranking, and time-filtered queries.

Combined with Meilisearch or LangChain, Pinecone adds scalability and production-readiness to your RAG setup.


## How can you evaluate advanced techniques in RAG systems?

To evaluate advanced RAG techniques, you need to test how each one impacts retrieval quality. The aim is to achieve high precision, context, low latency, and solid real-world usability. 

To assess effectiveness, focus on metrics like:


* **Retrieval accuracy:** Are the most contextually relevant chunks returned? This affects everything downstream, including hallucination rate and answer quality.
* **Latency:** Do techniques like reranking or hybrid search slow down your system? Evaluate end-to-end response time.
* **Precision vs. recall:** Are you returning too few (or too many) relevant documents? You want the sweet spot that balances coverage with focus.
* **User satisfaction:** How often do end users get exactly what they need? Consider running A/B tests or manual evals.

When you’re optimizing for speed without sacrificing quality, Meilisearch’s fast and accurate hybrid engine stands out.


## Why smarter RAG matters in practice

Advanced RAG techniques are ultimately about making information retrieval smarter, not just faster. They help systems move beyond brute-force search toward context-aware retrieval that scales across domains. 

By layering strategies such as hybrid search, reranking, and context distillation, teams can design RAG pipelines that deliver more precise, reliable, and efficient results in production settings.


9 advanced RAG techniques to know & how to implement them

10 Best RAG Tools and Platforms: Full Comparison [2026]

What is RAG (Retrieval-Augmented Generation) & how it works?

We've all marveled at the capabilities of large language models (LLMs) like ChatGPT, Gemini, or DeepSeek, witnessing their ability to generate coherent and often insightful text. However, alongside this power, we've also encountered their limitations, particularly their tendency to "hallucinate" or generate incorrect information. This isn't because they're designed to store facts, but rather because they're trained to predict the next word based on patterns in vast amounts of text, relying on a kind of "muscle memory" rather than a factual knowledge base.

## The problem of hallucination and limited context

Many known cases show that this is a problem that needs to be addressed. One of them was the real-world example of [lawyers](https://gunnercooke.com/ai-fake-cases-and-the-courts-a-cautionary-tale-for-the-legal-profession/) who, relying solely on an LLM, presented fabricated case citations in court, only to find out that all the information given to them by the LLM was false. This highlights the critical need for LLMs to access and accurately cite external, reliable information.

The recurring question then becomes: **how do we leverage the power of LLMs with our own domain-specific or business-specific data?**

One approach to connect LLMs with specific data is to provide them with context directly within the prompt. This is a good approach, although it can only go so far. While models like Google's Gemini are increasingly capable of handling larger contexts, there's a limit to how much information an LLM can effectively process and utilize within a single prompt. 

Another method is [fine-tuning](https://www.meilisearch.com/blog/fine-tuning-vs-rag), where you further train an LLM on your specific dataset. This is quite useful too, but unfortunately, fine-tuning is resource-intensive, requiring significant time and data, making it impractical for frequently updated information.

## The solution: retrieval-augmented generation (RAG)

The most effective solution to these challenges is Retrieval Augmented Generation (RAG). In short, RAG tells the model “before you start talking, search for the answer among these documents, and then talk”. Think of RAG as equipping your LLM with the skills of a librarian and providing it access to a comprehensive library (your knowledge base or database). Instead of generating responses purely from its training data, the LLM first "looks up" relevant information from your provided sources and then uses that information to formulate an educated answer. This process not only improves the accuracy of responses but also allows the LLM to provide sources, directly combating the issue of hallucination.

![Explanation of how search works with and without RAG](https://unable-actionable-car.media.strapiapp.com/image4_0863a743e6.png)
*Figure 1: With RAG, the model will first search for an answer to the user’s query in a database, and then it formulates a response using the query and the retrieved documents.*

The RAG workflow typically involves three key steps:

1. **Query Transformation**: The user's query is optimized into an effective search query.  
2. **Information Retrieval**: The transformed query is used to search a database for relevant information.  
3. **Response Generation**: The retrieved results, along with the original prompt, are fed to the LLM to generate an informed response.

As an example, if the query from the user is “Hmm, I’m trying to find out the best places to eat in Paris, any ideas?”, a good query transformation model (step 1\) would turn it into “Restaurants in Paris, highest quality”. The information retrieval system (step 2) would return a list of documents or links containing names and ratings of several restaurants in Paris. The LLM would then formulate a verbal response (step 3\) using the modified query and the list of restaurants. Think of it this way, imagine your friend calls you on the phone and asks you for good restaurants in Paris. You first turn their question into a Google query, search for it in Google, look at the first 4 or 5 results, and then respond to them with a sentence or two, giving them recommendations based on what you found. That is exactly the RAG process.

While many associate RAG with vector databases and a separate re-ranking step after retrieval, solutions like Meilisearch simplify this process by integrating the entire workflow and stack. This blog post will focus on the crucial second step (**how to search properly**), while the next blog post will delve deeper into the entire RAG pipeline and explore how Meilisearch simplifies its deployment and maintenance.

## The tools: full-text and semantic search

Effective searching within a text database is paramount for successful RAG. Two prominent methods stand out:

* [**Full-text search**](https://www.meilisearch.com/blog/how-full-text-search-engines-work): This method focuses on matching keywords present in your query with those found in the search results.  
* [**Semantic search**](https://www.meilisearch.com/blog/semantic-search): This approach retrieves documents that are conceptually closest to your query, understanding the meaning behind the words, not just the words themselves.

The best of both worlds is

* [**Hybrid search**](https://www.meilisearch.com/blog/hybrid-search), which, as the name suggests, combines the strengths of both full-text and semantic search. Let's examine when each method excels before diving into how they can be combined.

### When is semantic search better?

Semantic search shines when the combined meaning of words is more important than individual keyword matches. Consider the query "Book a trip".

* An article titled "Books about trips" might be highly ranked by full-text search due to keyword overlap, but it's likely not what the user intends.  
* An article stating "Schedule your travels with us" is semantically more relevant, even if it shares fewer exact keywords. Semantic search would prioritize the latter, providing a much better result.

### When is full-text search better?

Full-text search is superior when you need precise keyword matches, especially for technical terms or specific identifiers. For instance, if your query is "ISO 9001 certification process":

* An article titled "ISO 9001:2025 Certification Checklist" is a perfect match due to the specific terminology.  
* An article like "How to achieve quality management compliance" might be semantically similar, but lacks the direct keyword specificity.

Full-text search is also valuable in cases where semantic similarity doesn't equate to the correct answer. For example, if the question is "What color is an apple?", semantic search might return "What color is an orange" as the most similar sentence. While similar, it doesn't provide the direct answer to the original question.

## How to combine the results: hybrid search scoring

Once we have results from both full-text and semantic searches, the challenge lies in effectively combining them into a unified, fair ranking. Meilisearch addresses this by assigning and combining scores based on their relevance.

For semantic search, the score is directly based on **similarity**. Similarity is a measure that's high for closely related pieces of text and low for disparate ones, directly reflecting how well the results conceptually match the query. For example, the similarity between the sentences “hello, how are you” and “hi, how’s it going” is high. The similarity between the sentences “Hello, how are you?” and “I like apples” is low.

For full-text search, RAG methods often employ traditional algorithms like BM25 or TF-IDF to calculate a relevance score for each document, reflecting how well its keywords match the query. Meilisearch, on the other hand, employs another method, an algorithm called [**bucket sorting**](https://www.meilisearch.com/blog/bucket-sort-guide). 

This process involves organizing documents into progressively smaller "buckets" based on a set of defined ranking rules (such as a relevance score, number of typos, or word proximity), with each subsequent rule acting as a tie-breaker until a precise order is achieved.

A key aspect of Meilisearch's approach is normalizing these scores. Initial scores from full-text and semantic search often have different ranges. For example, BM25 scores might range from 0 to 1, while semantic similarity scores could be concentrated within a narrower band like 0.5 to 0.8. To ensure comparability, semantic search scores are stretched and centered (a process called an **affine transformation**), bringing them into the same 0-1 range as full-text scores (Figure 2). This normalization ensures consistency across both types of search results, allowing for a unified relevance score. In other words, this allows the results from both search methods to compete fairly.

![Graphic demonstrating how results from full-text and semantic search get combined in hybrid search](https://unable-actionable-car.media.strapiapp.com/image3_074aa973e2.png)
*Figure 2: The results from Semantic search are stretched (zoomed and centered) in order to combine them with the results of FullText search.*

This consistent scoring across both search types is crucial. It enables you to decide, at query time, the "semantic ratio", meaning how much weight you want to give to semantic results versus full-text results when combining them.

## Benefits of hybrid search: precision and recall

To understand the power of hybrid search, let's briefly review the concepts of precision and recall, two fundamental metrics in information retrieval. The importance of each metric varies depending on the specific problem.

Imagine you have an email spam filter:

* **Recall** measures the percentage of all truly spam emails that your filter successfully identified as spam (meaning that the number of actual spam emails that still landed in your inbox was small).  
* **Precision** measures, among the emails your filter flagged as spam, what percentage were actually spam (meaning that the number of legitimate emails mistakenly sent to your spam folder was small).

In the context of searching for answers to a query in a database:

* **Recall** measures the percentage of all relevant articles (those containing the answer) that we successfully retrieved.  
* **Precision** measures the percentage of retrieved articles that actually contain the answer.

Let's illustrate with a numerical example: Suppose we have 1000 articles, and 100 of them answer the query "What documents do I need to open a company?". Our search model retrieves 90 articles. And out of those 90 articles, 60 contained the answer to the query.

* If, out of the 100 relevant articles, our model successfully retrieved 60, then the **recall** is 60/100=60%.  
* If, out of the 90 retrieved articles, 60 contained the answer and the other 30 did not, then the **precision** is 60/90≈66.67%.

![How Precision and Recall are calculated](https://unable-actionable-car.media.strapiapp.com/image1_9d405f3289.png)
*Figure 3: Example of precision and recall.*

### Hybrid search and precision-recall

**Recall**: Hybrid search significantly enhances recall. If your initial search is poor, a re-ranking step cannot magically fix it; it can only reorder the results it's given. I like to think of this as "rearranging deck chairs on the Titanic", since no matter how well you rearrange the results, the result won’t be good. Hybrid search, by combining the strengths of full-text and semantic approaches, effectively expands the initial pool of relevant documents, building a much stronger ship.

**Precision**: Hybrid search also bolsters precision. Full-text search naturally promotes high precision for queries requiring specific keyword matches, as it's difficult for a document with many exact word overlaps to be irrelevant. For those trickier edge cases where a document might share many words with the query but be on a different topic, semantic search steps in, ensuring that only truly related articles are prioritized.

By intelligently combining the strengths of both full-text and semantic search, hybrid search offers a powerful approach to information retrieval, ensuring that RAG systems have access to the most relevant and accurate information for generating insightful and reliable responses. In our next blog post, we'll delve deeper into the entire RAG pipeline and explore how Meilisearch simplifies its deployment and maintenance.

## Optimizing performance: binary quantization and arroy

Beyond the core logic of hybrid search, efficient vector management is crucial for large-scale RAG systems. This is where [**Binary Quantization**](https://www.meilisearch.com/blog/meilisearch-indexes-embeddings-7x-faster-with-binary-quantization) (BQ) comes in. BQ dramatically shrinks vector embeddings by converting 32-bit floats to compact 1-bit representations, significantly reducing disk space and memory usage. In short, binary quantization simplifies a number by only taking its sign. For example, the numbers 0.4, \-0.5, and 0.6 will be turned into \+1, \-1, and \+1. While this looks like a broad oversimplification, when we’re dealing with really long vectors of hundreds or thousands of entries, BQ really speeds things up in similarity calculations, while keeping most of the information.

![Binary quantization](https://unable-actionable-car.media.strapiapp.com/image2_8c97776ee1.png)
*Figure 4: Binary quantization turns numbers into their sign, effectively pushing them to the corners of a square. Notice that the distance between points changes slightly, but the calculations become much simpler.*

Meilisearch also leverages **Arroy**, its Rust-based vector store designed for efficient Approximate Nearest Neighbors (ANN) search. Nearest neighbors search is very effective, but it can be really slow, as many distances between pieces of text in the embedding need to be compared. Arroy provides several speeding up techniques that help the model ‘guess’ where the closest articles are in the embedding.

![Regular nearest neighbors search vs Arroy](https://unable-actionable-car.media.strapiapp.com/image5_176e03d5cc.png)
*Figure 5: Regular nearest neighbors search is effective, but too many distances need to be calculated. Arroy uses different techniques to organize data, so that much fewer distances need to be calculated. In this example, a grid is used, and only the neighboring cells are searched, but in general, many other techniques, including tree-based techniques, are used to organize the data for effective and fast nearest neighbors search.*

This powerful combination of Binary Quantization and Arroy allows Meilisearch to handle vast knowledge bases with remarkable indexing speed and performance, ensuring your RAG system delivers fast, accurate answers even for high-dimensional embeddings. 

## Explore Meillsearch’s capabilities today! 

The power of RAG lies not just in the LLM's ability to generate text, but in its foundation of accurate and relevant information retrieval. As we've seen, embracing hybrid search, which skillfully blends the specificity of full-text search with the contextual understanding of semantic search, is key to overcoming the challenges of hallucination and delivering precise answers. With Meilisearch, implementing this crucial search layer into your RAG pipeline becomes remarkably straightforward, allowing you to focus on building truly intelligent applications. 

Ready to supercharge your RAG system with unparalleled search relevance? 

[Explore Meilisearch's capabilities today](https://www.meilisearch.com/cloud) and stay tuned for our next article, where we'll delve into building the complete RAG pipeline with Meilisearch, simplifying its deployment and maintenance.

Meilisearch latest news and company updates