Agentic RAG (retrieval-augmented generation) gives your RAG pipelines agent-like decision-making ability. Instead of retrieving blindly, agentic RAG plans, retrieves, and validates steps to provide context-rich answers.

Why is this important? It helps developers by improving reliability, reducing fragmented responses, and enabling LLMs to handle more challenging tasks. 

The key benefits of agentic RAG are stronger reasoning, higher accuracy, and better explainability, while the key drawbacks are more computation, dependency on orchestration, and added complexity.

Agentic RAG works through a loop of retrieval, planning, and evaluation. Tools like Meilisearch, LangChain, and LlamaIndex make these pipelines possible.

Let’s break down what agentic RAG is in detail.


## What is agentic RAG?

Agentic RAG is an advanced method that equips a RAG pipeline with agent-like reasoning. 

Instead of relying on static retrieval, it uses planning, decision-making, and iterative evaluation to determine when and how to retrieve context. Naturally, this makes the process more adaptive and precise.

Technically, agentic RAG refers to retrieval systems that embed autonomous agents into the pipeline to refine context, rerank sources, and validate outputs before passing them to the language model. This ensures that responses are relevant and explainable. 

Curious to see an example? Let’s get right to it.

## An example of agentic RAG in action

While there are plenty of examples of agentic RAG in action, we’ll stick to two. 

The first example would be an AI customer support agent that actually considers a query instead of returning the first matching document it finds. 

It takes time to think whether to search product manuals, FAQs, or previous tickets before giving you an answer. 

This can be applied in finance as well. Imagine a compliance assistant that’s smart enough to retrieve regulatory filings and cross-check them against internal policies before it generates an output. 

In both these cases, agentic RAG acts as a decision-maker instead of just a retriever.

## How does agentic RAG work?

Agentic RAG turns retrieval into a step-by-step process with reasoning behind it. The ‘agent’ plans, validates, and iterates instead of just generating the top result ASAP. 

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

The workflow of agentic RAG looks like this:

1. **Query understanding:** It starts by understanding the query. Then, if needed, it breaks it down into sub-tasks.
2. **Planning retrieval:** The agent decides which sources to consult and in what order, be they structured databases, document collections, or APIs.
3. **Context retrieval:** The relevant passages are retrieved through vector, hybrid, or keyword search. Tools like Meilisearch make this stage efficient and customizable based on your preference.
4. **Evaluation and correction:** The retrieved context is scored for relevance, consistency, and completeness. The passages with low confidence are reranked, filtered, or replaced.
5. **Generation with oversight:** The LLM produces a draft response, but the agent may call for additional retrieval steps or corrections before finalizing.
6. **Feedback loop:** Agent logs, confidence scores, and user feedback are used to refine retrieval and planning for future queries.

For the pipeline to work, specific key components are critical:

* Retriever for fast recall (e.g., Meilisearch)
* Planner that breaks down queries and decides retrieval order
* Evaluator that checks factual grounding and confidence
* Feedback loop to continuously improve outputs

Combining these elements allows agentic RAG to transform retrieval from a static lookup into a proper decision-making process. 

Now, let’s see why this approach is important for LLM applications.

## Is agentic RAG important?

Yes, agentic RAG is important because it addresses the core weaknesses of [traditional RAG](https://www.meilisearch.com/blog/what-is-rag) pipelines. 

Right off the bat, it reduces hallucination by validating context. Structured planning eliminates fragmented retrieval and automatically improves reliability for fact-heavy queries. 

For example, it helps in compliance research, where accuracy is critical, and in customer support, where context switching can cause irrelevant answers.

## Where is agentic RAG used?

Agentic RAG is applied in domains with significant reliance on accurate retrieval and adaptive reasoning. 

Let’s see some common use cases below:

* **Customer support:** Customers love accurate and context-aware responses, so agentic RAG in this field is becoming a must-have. 
* **Healthcare:** Agentic RAG can be applied in the form of clinical assistants capable of validating medical literature and patient records before producing an output.
* **Legal research:** The legal domain can benefit from agentic RAG, which maps statutes, precedents, and case law and cross-checks context before drafting summaries or legal arguments.
* **Financial services:** In finance, compliance bots retrieve regulatory filings, compare them with internal policies, and highlight discrepancies for auditors.
* **Education:** You will find intelligent tutoring systems that plan which sources to pull from and explain answers with supporting context.
* **Enterprise knowledge management:** Agents review large document repositories to rank and validate sources, which helps resolve contradictions and eliminate noise.
* **Scientific research:** RAG systems explore datasets and published papers, iteratively validating evidence to support hypothesis building.

By adapting retrieval to domain-specific needs, agentic RAG improves the reliability and usability of AI systems. 


## What are the benefits of implementing agentic RAG?

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

The key benefits of implementing agentic RAG are:

* **Improved accuracy:** Agentic RAG brings about a major difference in accuracy of responses by improving context and reducing hallucinations.
* **Context-aware reasoning:** Planning retrieval steps connects multiple sources into a coherent response. 
* **Explainability:** Each decision, including what was retrieved, why it was chosen, and how it influenced the output, can easily be traced. Hence, the output becomes transparent to both developers and end users.
* **Adaptability:** Agentic RAGs dynamically adjust retrieval strategies for different queries, making pipelines more flexible than static RAG implementations.
* **Continuous improvement:** With feedback loops, the system learns from past queries to refine retrieval and planning over time.

Together, these benefits make agentic RAG a strong candidate for mission-critical AI systems.


## Are there drawbacks in agentic RAG implementation?

Indeed, there are tradeoffs for agentic RAG’s advanced usability and benefits. These include:

* **Higher computational cost:** With great power comes a higher recurring cost. The added steps of planning, reranking, and evaluation increase latency and resource usage, which can be a bottleneck for real-time applications.
* **Complexity of setup:** Unlike standard RAG, agentic pipelines require orchestration between retrievers, evaluators, and feedback loops. This raises the barrier to adoption.
* **Dependency on evaluators:** The accuracy of corrective steps often relies on evaluator models or heuristics. If these are weak or misaligned, the whole system can crumble.
* **Risk of overcorrection:** In some cases, agentic RAG is smarter than it needs to be. This leads to overcorrection, which might discard useful information. 

These drawbacks highlight the need for careful infrastructure planning before implementing agentic RAG. 

We also need to consider the challenges of deploying agentic RAG.

## What are the challenges of implementing agentic RAG?

Beyond drawbacks, teams face practical challenges when deploying agentic RAG. Let’s look at some below:

* **Data integration:** Many enterprises operate across siloed systems and formats. Building pipelines that unify structured, semi-structured, and unstructured data is not easy, to say the least. 
* **Scalability:** Agentic RAG requires extensive strategic planning and evaluation, which becomes more challenging during scaling.
* **Security and compliance:** Security is obligatory and keeping up with compliance adds a lot of complexity to the architecture. 
* **Developer expertise:** Implementing orchestration logic demands experience with frameworks, retrievers, and agent systems. Keeping up with the adoption could be difficult if your team is not skilled enough.

Next, let’s look at the tools commonly used in agentic RAG pipelines.


## What tools are used in agentic RAG pipelines?

[Different RAG tools](https://www.meilisearch.com/blog/rag-tools) support agentic RAG:

* **LangChain:** LangChain is a widely used orchestration framework that connects retrievers, evaluators, and generators into an agentic workflow. It allows the LLM to decide when to retrieve, when to generate, and when to validate. It’s central to many agentic setups.
* **LlamaIndex:** A tool designed for indexing and structuring data, which helps agents plan retrieval strategies across multiple knowledge sources. It is often used to build a hierarchical context or combine unstructured and structured data.
* **Vector databases (e.g., Weaviate, Pinecone):** These provide scalable [vector search](https://www.meilisearch.com/blog/what-is-vector-search) that supports semantic similarity. Agents use them for dense retrieval before applying correction or validation steps.
* **Meilisearch:** A fast, developer-friendly search engine that fits as the initial retrieval layer in agentic RAG. It stands out thanks to its hybrid search, filters, and typo tolerance, which help agents recall precise candidates before running corrective or validation loops. For AI agent deployment, it provides speed and fine-grained control, which keeps pipelines responsive while maintaining relevance. It’s an all-in-one package for developers.

These tools create the infrastructure agents need to plan, retrieve, evaluate, and refine responses. 

Now, let’s walk through how to implement an agentic RAG pipeline.


## How can you implement agentic RAG?

There’s a methodical implementation for agentic RAG. It requires a step-by-step process that includes layering planning, validation, and feedback on top of a standard retrieval–generation pipeline. 

The following steps show how to set it up using Meilisearch for retrieval and an LLM for reasoning:


### 1. Ingest and index documents with Meilisearch

The first step is preparing your data. The documents are indexed in Meilisearch so the agent can query them quickly. This provides a fast recall layer before validation and reasoning.


```python
from meilisearch import Client
client = Client("http://127.0.0.1:7700", "MASTER_KEY")
index = client.index("docs")

docs = [
  {"id": "1", "title": "Onboarding Guide", "body": "Steps to onboard a new user securely."},
  {"id": "2", "title": "Security Policy", "body": "MFA is mandatory for admins."}
]
index.add_documents(docs)
```


This gives the agent a searchable knowledge base to work with.


### 2. Retrieve candidates and build context

Next, the agent recalls relevant candidates and organizes them into a usable context for reasoning.


```python
query = "How do I onboard a new user with MFA?"
hits = index.search(query, {"limit": 5})["hits"]

context = "\n".join([f"{h['title']}: {h['body']}" for h in hits])
```


By structuring evidence, the system avoids sending raw, noisy text directly to the model.


### 3. Validate and refine context

Before passing context to the generator, the agent checks for gaps or contradictions. If key terms are missing, it expands the query with synonyms or related phrases.


```python
def needs_more_context(hits):
    return not any("MFA" in h["body"] for h in hits)

if needs_more_context(hits):
    more = index.search("multi-factor authentication", {"limit": 5})["hits"]
    hits += more
```


This step ensures the generator sees comprehensive and accurate information.


### 4. Generate the final answer and log feedback

Finally, the agent generates a response with citations and logs feedback to improve future runs.


```python
from openai import OpenAI
client = OpenAI(api_key="YOUR_API_KEY")

prompt = f"Q: {query}\nContext:\n{context}\nAnswer with citations."
resp = client.chat.completions.create(model="gpt-4o", messages=[{"role":"user","content":prompt}])

answer = resp.choices[0].message.content
print(answer)
```


The feedback on confidence and missing facts can be stored to refine retrieval strategies over time. 

In the following section, let’s tackle some of the most frequently asked questions about the performance of agentic RAG.


## How does agentic RAG perform?

A recent[ survey on agentic RAG](https://arxiv.org/abs/2501.09136) highlights that it enables flexibility, scalability, and context awareness across complex domains like healthcare, finance, and education.

Another[ study on Search-R1](https://arxiv.org/html/2507.10411v1) found that effective retrievers shorten reasoning steps and improve answer quality, with query performance prediction strongly correlating with final accuracy.

Finally, in recommendation systems, an[ agentic RAG framework](https://arxiv.org/abs/2506.21931) achieved a 42.1% improvement in NDCG@5 and 35% in Hit@5 compared to standard RAG approaches. 


### How does agentic RAG differ from traditional RAG?

We already know that traditional RAG uses one-shot retrieval followed by generation. Agentic RAG is more capable and comprehensive. It plans, iterates, and retrieves adaptively through context validation. 


### How does agentic RAG differ from naive RAG?

Naive RAG uses static retrieval rules with no feedback, while agentic RAG defers retrieval decisions to the agent within a reasoning and feedback loop. This enables retrieval to evolve based on the context.


### How does agentic RAG differ from graph RAG?

[Graph RAG](https://www.meilisearch.com/blog/graph-rag) uses structured relationships for retrieval, but is still a single-pass retrieval system. Agentic RAG layers planning and feedback on top of graph or vector retrieval, enabling reasoning over evolving multi-hop paths.


### How does agentic RAG differ from adaptive RAG?

[Adaptive RAG](https://www.meilisearch.com/blog/adaptive-rag) adjusts retrieval parameters based on query difficulty. Agentic RAG, on the other hand, goes further. It actively generates new retrieval queries mid-reasoning to fill gaps or refine context.


### How does agentic RAG differ from an MCP?

Agentic RAG is a retrieval-planning paradigm. In contrast, an MCP (multi-choice prompt) is a prompting technique focused on structured output design. It’s not associated with retrieval optimization or adaptive querying.


## Start building intelligent RAG systems

By treating retrieval as a process of reasoning rather than a static lookup, agentic RAG forces us to design systems that think before they answer. 

That added deliberation may cost more computing and complexity. Still, it sets the foundation for AI that is not only more accurate but also more trustworthy, explainable, and adaptable to real-world challenges.


What is agentic RAG? How it works, benefits, challenges & more

In our [previous post](https://www.meilisearch.com/blog/mastering-rag), we dove into the complexities of **hybrid search**, a powerful technique that combines the precision of keyword-based searching with the contextual understanding of vector-based searching. We learned that this dual approach is essential for retrieving relevant information from your data.

![what-is-rag.png](https://unable-actionable-car.media.strapiapp.com/what_is_rag_410e6d690f.png)

But a great search is only part of the story. Today, we'll zoom out and explore the complete **Retrieval Augmented Generation (RAG)** workflow, showing how Meilisearch simplifies the entire process. In short, RAG has 3 steps: **Query regeneration** (rewriting the user’s question), **Retrieval** (searching for the answer to the question in a database), and **Generation** (using the question and the search results to formulate an answer to the question). While our last discussion focused on **step 2** of the RAG pipeline (the retrieval step), we'll now cover the whole system, from preparing the initial query to generating the final, informed response.

## The Motivation for RAG

Before we get into the nuts and bolts, let's briefly recap why RAG is a game-changer. Large Language Models (LLMs) are remarkable at generating human-like text, but they have two significant limitations:

* **Limited Knowledge:** LLMs are trained on vast amounts of public data, but their knowledge is static. They can't access real-time information (e.g., the results of yesterday’s game) or specific, private data (e.g., your company's internal documents).  
* **Hallucinations:** When faced with a question they don't have a definitive answer for, LLMs will sometimes "hallucinate", they make up plausible-sounding but factually incorrect information. This is because they are designed to predict the next word in a sequence, not to be a factual knowledge base. In short, the LLM doesn’t even *know* it is lying, as it has no concept of this, only a muscle-memory that indicates what is the word that will most likely follow the current text.

RAG solves these problems by giving the LLM a new superpower: the ability to "look up" information before answering. It’s like giving an LLM a personal librarian who can find and summarize relevant documents from your private data, and help the LLM formulate the best possible response.

### An Analogy: You've Been Doing RAG Your Whole Life

To understand the RAG workflow, let's use a simple, everyday example. Imagine a friend asks you, "Hey, I'm trying to remember who won the last World Cup of the 20th century, but for the life of me I can’t recall, do you know?"

You wouldn't just type their exact question into Google. Instead, your brain performs a series of RAG-like steps:

1. **Query Rephrasing:** You rephrase their question into a more effective search query, like "1998 World Cup winner" or "football world cup champion late 90s." You know that a good search query is precise and uses keywords that are likely to appear in the documents you want to find.  
2. **Information Retrieval:** You type your refined query into Google, which then retrieves a list of web pages, articles, and other sources that are likely to contain the answer. This is the **retrieval** step.  
3. **Synthesis and Generation:** You quickly scan the top few search results, read the key information (e.g., several articles with titles such as "France was the 1998 World Cup champion", “Les bleus have won the cup\!”, or “Zidane and his team have won the 1998 World Cup”), and then, based the articles you skimmed, formulate a clear, concise response for your friend: "France won the 1998 World Cup." This is the **generation** step.

This is exactly what RAG does. It's a three-step process that allows an LLM to answer questions using external, up-to-date, or private data.

## The RAG Workflow in Detail

The RAG process can be broken down into three main stages.

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

### Step 1: Generating a Better Search Query

The user's initial question is rarely the best search query. A well-crafted search query is crucial for retrieving the most relevant documents. This step involves techniques to improve the initial user query:

* **Query Expansion:** Adding synonyms or related terms to broaden the search. For example, if a user asks about "Meilisearch's documentation," a query expansion model might also include terms like "Meilisearch docs" or "Meilisearch reference." If the query is “Who won the world cup at the end of the last century”, a query expansion model may include terms like “1998 world cup”, “soccer world champions”, etc.  
* **Query Rephrasing:** Rewording the query to make it more direct and concise, helping the search engine find a better match. A user query like "What are some of the features of Meilisearch's hosted solution?" could be rephrased to "Meilisearch Cloud features." If the query is something poorly written like “Gee, I wonder who won the last world cup in the previous century”, the model can rephrase it as “1998 football world cup champion.”

These methods ensure that even if the user's phrasing is a bit clunky or non-technical, the search engine receives an optimal query.

![generating-better-search-query.png](https://unable-actionable-car.media.strapiapp.com/generating_better_search_query_a7854dbb72.png)

### Step 2: The Search for an Answer

This is where the magic of retrieval happens. As we discussed in our [previous post](https://www.meilisearch.com/blog/mastering-rag), the most effective way to search is through a **hybrid approach**. This method combines:

* **Full-Text Search:** Identifies documents containing the exact keywords from your query. This is great for factual recall and precision.  
* **Semantic Search:** Finds documents that are contextually or semantically similar to your query, even if they don't contain the exact keywords. This is powered by [**vector embeddings**](https://www.meilisearch.com/blog/what-are-vector-embeddings), which represent the meaning of text.

Meilisearch excels at this step by providing a unified, integrated hybrid search engine. Unlike systems that require you to manage a separate vector database, a keyword search engine, and a re-ranking model, Meilisearch handles all of this out of the box with a scoring method, reducing complexity and operational overhead.

![searching-for-answer.png](https://unable-actionable-car.media.strapiapp.com/searching_for_answer_54ca6d051c.png)

### Step 3: Generating a Good Response

Once the most relevant documents are retrieved, the LLM is given two key pieces of information:

1. **The Original User Query:** The question the user asked.  
2. **The Retrieved Documents:** The "context" or "ground truth" information found in step 2\.

These are combined with a carefully crafted **preamble** or **system prompt**, which provides the LLM with specific instructions. This is a critical step for preventing hallucinations. A good preamble does the following:

* **Instructs Synthesis:** Tells the LLM to synthesize information from the provided documents rather than just repeating them.  
* **Requires Citations:** Instructs the LLM to cite the sources it used, reinforcing accuracy and giving the user confidence in the answer.  
* **Handles Ambiguity:** Instructs the LLM to explicitly state when it cannot find an answer in the provided documents (e.g., "I couldn't find any information on that topic"), preventing it from generating a fabricated response.

![generating-good-response.png](https://unable-actionable-car.media.strapiapp.com/generating_good_response_9de799617d.png)

## Meilisearch Advantages: Streamlining, latency, and more

### A Streamlined RAG System

[Building a RAG pipeline](https://www.meilisearch.com/blog/how-to-build-a-rag-pipepline) from scratch can be a complex and brittle process. It often involves integrating multiple services: a traditional search engine, a vector database, an embedding model, and a re-ranking model. Each of these components needs to be deployed, configured, and maintained independently.

This is where Meilisearch's approach stands out.

Meilisearch simplifies the [RAG workflow](https://www.meilisearch.com/blog/how-to-build-a-rag-pipepline) by providing a single, powerful platform that integrates hybrid search natively. Instead of managing a complex web of interconnected services, developers can leverage Meilisearch's unified solution. This dramatically reduces **operational overhead** and the number of moving parts that can break or fall out of sync.

* **Simplified Deployment:** Meilisearch's all-in-one architecture means you can get your RAG system up and running faster. There's no need to spend time configuring separate APIs or dealing with compatibility issues between different tools.  
* **Easier Maintenance:** When new embedding models are released or your data schema changes, updating a multi-component system can be a nightmare. Meilisearch's integrated approach means that updates and fine-tuning are managed from a single point, making your system more robust and easier to evolve.

### Latency Improvements

One of the most significant performance advantages of Meilisearch's unified approach is **latency**. In a multi-component RAG system, the user query might have to go through several network hops and API calls:

1. Query to an embedding model (API call).  
   2. Embeddings sent to a vector database (API call).  
   3. Query sent to a full-text search engine (API call).  
   4. Results from both are sent to a re-ranking model (another API call).  
   5. Finally, the re-ranked results are sent to the LLM (API call).

Each of these steps adds milliseconds of latency. Meilisearch performs all of these steps internally in a single search request, drastically reducing the total time from query to retrieved documents. This leads to a much faster and more responsive user experience.

In essence, Meilisearch's unified solution allows you to focus on what matters most: building an amazing user experience powered by your data. It provides the performance, ease of use, and flexibility needed to build and scale a state-of-the-art RAG application without the headaches of managing a complex infrastructure. If you’d like a hands-on tutorial on implementing RAG with Meilisearch, check out [this blog post](https://www.google.com/url?q=https://www.meilisearch.com/blog/how-to-build-rag).

From RAG to riches: Building a practical workflow with Meilisearch’s all-in-one tool

Adaptive RAG explained: What to know in 2025

Speculative RAG is a smarter way to retrieve information from knowledge bases and generate responses. 

It is a bit like giving your AI system a head start. Rather than waiting to find all the information before writing an answer, the AI system begins drafting answers while searching for more details. 

This makes it faster than traditional RAG, which first retrieves all the information it needs before generating a response. 

Here is a summary of what you’ll learn in this article:

* What speculative RAG is and how it works
* How it’s different from traditional RAG
* Its key benefits and limitations
* Why drafting is important in speculative RAG
* Specific use cases for speculative RAG
* How to implement speculative RAG, and more 

Let’s dive right in. 

## What is speculative RAG?

Speculative RAG improves how AI systems answer questions by performing two steps at once: 

1. First, a smaller model drafts several possible answers using the first bits of information it finds. 
2. A larger model then refines these drafts before selecting the best response. 

Recent [papers from Google Research](https://research.google/blog/speculative-rag-enhancing-retrieval-augmented-generation-through-drafting/) show that speculative RAG can increase accuracy by up to 12.97% while reducing response time by 51% compared to other RAG systems.

Let’s dive deep into why speculative [RAG](https://www.meilisearch.com/blog/what-is-rag) is better than traditional RAG systems.

## How does speculative RAG improve traditional RAG?

Speculative RAG improves on traditional [RAG types](https://www.meilisearch.com/blog/rag-types) by changing how the process flows. 

In a standard RAG setup, the AI system retrieves all the documents it needs before generating the answer. 

With speculative RAG, both the retrieval and generation phases happen simultaneously. While the documents are still being retrieved, a small model starts drafting possible answers using whatever information it already has. 

These small-model drafts are not the final result; they are more like quick sketches. Once the rest of the documents arrive, a larger and more powerful model (usually a generalist language model) checks the drafts, refines them by filling in the missing details, and then picks the best one as the answer. 

Each draft is generated from a different slice of the retrieved documents, making this a smart approach. It is like getting several mini-answers from multiple points of view, then having an expert pull together the strongest parts from each one.

## What are the benefits of speculative RAG?

Let’s explore the key benefits of using speculative RAG.

![Benefits of Speculative RAG.png](https://unable-actionable-car.media.strapiapp.com/Benefits_of_Speculative_RAG_e21dfdf177.png)

### 1. Lower latency

The speed boost is one of the most noticeable improvements when using speculative RAG. It does not sit idle waiting for all the search results. Instead, it starts sketching answers as soon as the first bits of information come in, then refines them when it gets the rest. 

### 2. Better handling of complex questions

Speculative RAG is a good tool to use for questions that require piecing together information from multiple sources. Because it explores several answer paths simultaneously, it is better equipped to connect the dots and still produce an accurate answer. 

### 3. Good resource management

Speculative RAG reduces the computational load by letting a smaller, specialized RAG model handle the early work, leaving the larger (and more powerful) model free to focus on finalizing the answer. 

This approach reduces token usage and computing costs.

### 4. Improved response quality

The multi-draft approach of speculative RAG generates better answers because it gathers several perspectives before deciding on the final response. The bigger model picks the best one, which is usually accurate. 

During the verification phase, it spots mistakes or gaps that a traditional RAG system might miss. 

The different drafts available in speculative RAG also help to capture different angles and details that could be overlooked when dealing with complex questions.

## Why is drafting important in speculative RAG?

Drafting is the reason speculative RAG works so well. The parallel generation of multiple drafts from various documents allows the model to explore different options before deciding what to do. 

Each draft is generated from a distinct subset of retrieved documents. This diversity is crucial because complex questions often have multiple angles, and you need to consider all of them. 

The verification stage of the process works like quality control. It checks each draft before it makes the final decision. 

A generic language model reviews the drafts, detects any mistakes, and then fills the gaps to choose the best answer.

This two-step approach (parallel generation followed by verification) produces more accurate answers than the traditional single-step RAG systems.

## How does speculative RAG work technically?

Speculative [RAG works](https://www.meilisearch.com/blog/how-to-build-rag) by breaking the traditional RAG workflow into two big steps that operate like a tag team: drafting and verification. 

These big steps can be further broken down into smaller steps:

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

### Drafting

Drafting in speculative RAG is where the model begins sketching answers before completing the retrieval process. It is the first phase that sets the tone for the final output.

* **Step 1:** Once you input the query, the system begins parallel document retrieval from the knowledge base. Speculative RAG uses standard embedding similarity to find the most relevant matches.
* **Step 2:** The retrieved documents are ranked by relevance and passed forward for partitioning and draft generation.
* **Step 3:** The retrieval pipeline can integrate data from multiple sources (such as databases or APIs) when necessary. This process expands the coverage without slowing it down.
* **Step 4:** The retrieved documents are divided into unique subsets so that each draft can draw from a different perspective.
* **Step 5:** The smaller model (a specialist RAG drafter) generates multiple candidate responses simultaneously, each based on its own document cluster.


### Verification

The verification phase uses a generic language model to evaluate and select the best draft from the candidates generated in parallel. 

It also makes sure the answer is accurate and aligns with the query.


* **Step 1:** The draft evaluation feeds all candidate responses to the [large generalist language model](https://www.meilisearch.com/blog/how-do-you-search-in-a-database-with-llm) for a comprehensive review.
* **Step 2:** Quality scoring is then applied, which analyzes each draft against criteria such as accuracy and relevance to the original query.
* **Step 3:** Cross-checking each draft candidate against the retrieved document subsets catches potential inconsistencies.
* **Step 4:** The final selection chooses the highest-scoring draft or merges the best parts of multiple drafts into a single response.


### Final output

This stage delivers the refined response after all the verification checks are complete. 

* **Step 1:** First, the system shapes the chosen draft into the correct output format, ensuring it is clear and easy to read. 
* **Step 2:** Citations and links to the sources are integrated so that users can easily trace and verify every draft claim.
* **Step 3:** A quality assurance check ensures accuracy and alignment with the original query intent.
* **Step 4:** Finally, the response is packaged with useful metadata (such as confidence scores, processing time, and source attribution) before it is presented to the user.

## When should you use speculative RAG?

Speculative RAG is useful when you need quick and accurate answers, especially to complex questions requiring multiple information sources. 

Some use cases of speculative RAG are:

* **Chatbots:** With speculative RAG, bots can rapidly respond while ensuring the answers are from verified sources. Users can get quick and reliable replies despite thousands of conversations happening simultaneously. 
* **Summarization:** Instead of skimming and scanning through long documents, speculative RAG helps create a few quick summaries and return the one that best captures the query's original intent.
* **Customer service:** When dealing with convoluted questions, speculative RAG can pull relevant information from past tickets or FAQs. It then verifies the response so customers get the correct answer the first time. 
* **Technical Q&A:** Speculative RAG can help developers verify that the LLM output is accurate. The verification can be from multiple sources, such as code repositories or API documentation.
* **Financial analysis and reporting:** Investment analysts often need to pull information from market reports, news, and financial statements quickly. With speculative RAG, they can generate multiple analytical angles simultaneously and produce the most accurate investment appraisal.
* **Legal document analysis:** Lawyers working on complex cases usually review many precedents. Speculative RAG can help explore different argument angles from multiple sources at once, then select the strongest case strategy after verifying it against trusted legal databases.

## How to implement speculative RAG

Let’s [build a simple speculative RAG](https://www.meilisearch.com/blog/how-to-build-rag) system that searches documents with Meilisearch, creates several possible answers with OpenAI, and then uses AI to decide which one is best. 

### 1. Setting up Meilisearch

If you do not already have Meilisearch installed, you can install it with:


```python
# Install Meilisearch
curl -L https://install.meilisearch.com | sh
```


Once installed, start the server with a master key:


```python
# Launch Meilisearch
./meilisearch --master-key="aSampleMasterKey"
```


For security, store your credentials in a .env file. Add the following values to the file:


```python
MEILI_URL=http://127.0.0.1:7700
MEILI_KEY=aSampleMasterKey
OPENAI_API_KEY=your_openai_api_key_here
```


Note that you will need to generate an OpenAI API key to complete the setup.


### 2. Set up the environment and dependencies

In this step, we will create a Python file. We will import the necessary libraries and load environment variables. 

We will also create an API client that will communicate with the Meilisearch server. 

Lastly, we create an index to store the knowledge base.


```python
import meilisearch
import asyncio
import os
import time
from dotenv import load_dotenv
from openai import OpenAI

# Setup environment variables
load_dotenv()
MEILI_URL = os.getenv("MEILI_URL", "http://127.0.0.1:7700")
MEILI_KEY = os.getenv("MEILI_KEY", "aSampleMasterKey")
OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]

# Initialize clients
ms = meilisearch.Client(MEILI_URL, MEILI_KEY)
oa = OpenAI(api_key=OPENAI_API_KEY)
index = ms.index('simple_kb')
```



### 3. Create a knowledge base

Now comes the foundation of our RAG system – the knowledge base itself. We will build a simple customer support knowledge base, but the same principle applies whether you're dealing with legal documents, technical manuals, or any other domain.

Each document in our knowledge base has an ID, a topic (for easy categorization), and content (the actual information). This structure makes it easy for Meilisearch to find relevant information when users ask questions. 


```python
# Sample knowledge base - just 3 simple docs
docs = [
 {"id": 1, "topic": "password reset", "content": "To reset password: 1) Click forgot password 2) Check email 3) Follow link"},
 {"id": 2, "topic": "slow internet", "content": "For slow internet: 1) Restart router 2) Check other devices 3) Call ISP"},
 {"id": 3, "topic": "email issues", "content": "Email problems: 1) Check spam folder 2) Verify settings 3) Try different browser"}
]

def setup_kb():
 """Add documents to Meilisearch"""
 try:
 index.delete()
 time.sleep(1)
 except Exception:
 pass # Index doesn't exist yet
 
 # Add documents and wait for indexing
 index.add_documents(docs)
 time.sleep(3)
 print("Knowledge base ready")
```



### 4. Smart document search

This is where we implement our RAG system's ‘retrieval’ part. When a user asks a question, we find the most relevant documents from our knowledge base. 

However, we should address how users might phrase the same question differently.

Meilisearch excels at this because it handles typos and different phrasings and can search across multiple fields simultaneously. 

Our fallback logic catches cases where the primary search finds nothing, ensuring we always return something useful.


```python
def search_docs(question):
 """Find relevant docs"""
 results = index.search(question, {
 'limit': 2,
 'attributesToSearchOn': ['topic', 'content']
 })
 
 # Try keyword search if no results
 if len(results['hits']) == 0:
 if 'password' in question.lower():
 results = index.search('password', {'limit': 2})
 elif 'internet' in question.lower() or 'slow' in question.lower():
 results = index.search('internet', {'limit': 2})
 elif 'email' in question.lower():
 results = index.search('email', {'limit': 2})
 
 return results['hits']
```



### 5. Generate multiple drafts in parallel

Now, we build the core of the speculative RAG. We generate multiple parallel responses and pick the best one. 

To do this, we use different temperature settings for each draft. This way, the LLM creativity changes: lower values produce more focused, conservative responses, while higher values encourage more creative, varied outputs.


```python
async def generate_draft(question, docs, draft_num):
 """Generate one draft response"""
 context = "\n".join([f"- {doc['content']}" for doc in docs])
 
 prompt = f"Context:\n{context}\n\nQuestion: {question}\nAnswer briefly:"
 
 response = oa.chat.completions.create(
 model="gpt-3.5-turbo",
 messages=[{"role": "user", "content": prompt}],
 max_tokens=100,
 temperature=0.3 + (draft_num * 0.3) # Different creativity levels
 )
 return response.choices[0].message.content
```


Notice the async function here. With async, all three calls happen simultaneously. Temperature also changes (0.3, 0.6, 0.9) giving three distinct ‘personalities.’


### 6. Pick the best draft

Now we need a judge. We use an AI model to evaluate all options and select the best. 

GPT-4 (or GPT-4o-mini) is better at evaluation than GPT-3.5-Turbo but it's also more expensive. By using it only for the selection step, we get the best of both worlds: quality evaluation at reduced cost.


```python
def pick_best_draft(question, drafts):
 """Use GPT-4 to pick the best draft"""
 drafts_text = "\n".join([f"Draft {i+1}: {draft}" for i, draft in enumerate(drafts)])
 
 prompt = f"Question: {question}\n\n{drafts_text}\n\nWhich draft is best? Reply with just the number (1, 2, or 3):"
 
 response = oa.chat.completions.create(
 model="gpt-4o-mini",
 messages=[{"role": "user", "content": prompt}],
 max_tokens=10
 )
 
 try:
 best_num = int(response.choices[0].message.content.strip())
 return drafts[best_num - 1]
 except (ValueError, IndexError):
 return drafts[0]
```



### 7. Put it all together

This demonstrates the full speculative RAG pipeline: retrieving relevant documents, generating multiple candidate responses in parallel, and selecting the best one. 


```python
async def answer_question(question):
 """Main function: speculative RAG in action"""
 print(f"\nQuestion: {question}")
 
 # Search for relevant docs
 docs = search_docs(question)
 
 # Generate 3 drafts in parallel - this is the key improvement
 tasks = [generate_draft(question, docs, i) for i in range(3)]
 drafts = await asyncio.gather(*tasks)
 
 # Pick best draft using GPT-4
 best_answer = pick_best_draft(question, drafts)
 
 # Show results
 print("\nAll drafts:")
 for i, draft in enumerate(drafts, 1):
 print(f"{i}. {draft}")
 
 print(f"\nBest answer: {best_answer}")
```



### 8. Demoing the project

Let's test the system with some realistic questions: 


```python
async def main():
 setup_kb()
 
 questions = [
 "I forgot my password",
 "My internet is really slow"
 ]
 
 for q in questions:
 await answer_question(q)

if __name__ == "__main__":
 asyncio.run(main())
```


When we run the Python file, we see our system's ability to understand intent and match it to the right knowledge base entries.


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

<Callout intent="tip">

[Get the full code here!](https://drive.google.com/file/d/1cNVEKa8f--qmtUP9s3A7CJl8tOb5LfwP/view?usp=sharing)

</Callout>


## What are the limitations of speculative RAG?

While speculative RAG has many benefits, there are also a few limitations you should be aware of. Here are some of them:

* **Model compatibility:** Some language models are not optimized for fast back-and-forth between generation and verification. To use speculative RAG efficiently, you may need to use specific models, which can limit your choices if you already have a preferred provider.
* **Implementation complexity:** Building a solid RAG flow is already complex. You must select the right vector database, embedding model, text splitter, retriever, and the LLM that ties it together. With speculative RAG, you are adding an extra layer: building a drafting and verification pipeline and ensuring your models (both small and large) work well together. This requires additional planning and a clear idea of how every moving piece works together, making it more complex.
* **Potential accuracy trade-offs:** Even with verification, mistakes can sneak through, especially if the retrieved sources are outdated or incomplete. If your drafter model generates poor-quality drafts, even the best verifier can only pick the least bad option. 
* **Higher computational costs:** Running multiple drafts and verification checks in parallel can be expensive in terms of computing time and API costs, especially at large scale.

## How does speculative RAG compare to re-ranking?

The main difference between speculative RAG and reranking is that speculative RAG generates multiple answer drafts, verifies them, and picks the best one, while re-ranking focuses on arranging the retrieved documents by relevance before generating a single answer.

Both are appropriate for different scenarios. 

You use re-ranking when your main problem is getting the right documents to the top of your search results, especially with straightforward queries. 

Speculative RAG is better when you need genuinely better answers and can afford the extra computational cost. 

![Speculative RAG vs. Re-ranking.png](https://unable-actionable-car.media.strapiapp.com/Speculative_RAG_vs_Re_ranking_5b7c1fa1a7.png)

## Final thoughts on using speculative RAG in production

Speculative RAG is one of those [techniques](https://www.meilisearch.com/blog/rag-techniques) that makes you realize how bright the future is with search. 

If you are dealing with complex queries where answer quality matters and you need the responses quickly, speculative RAG should be your go-to tool. 

You might need a higher computational budget and technical expertise compared to other standard RAGs, but the boost in user experience is hard to miss.

Speculative RAG: A faster retrieval-augmented generation

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

Instead of allowing irrelevant or weak context to enter your 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](https://www.meilisearch.com/blog/rag-types) 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 content 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) retrieves documents from a database and feeds them directly to the LLM. The LLM then uses this raw context to generate an answer. 

In a traditional RAG pipeline, irrelevant, noisy, or incomplete information 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 curated, high-quality content 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. 

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.


## 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 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 evaluator evaluates the retrieved context quality. Based on relevance and confidence 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. 


### 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 queries, 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.

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).
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.
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.
6. **Iteration:** User feedback, confidence scores, and query logs feed into the feedback loop, helping the system improve retrieval quality over time.

Now, let’s see how to implement corrective RAG in practice.


## How to implement corrective RAG

Corrective RAG adds a quality gate between 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.


### 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 domains or changing data without retraining or 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 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

Here's everything we shipped this month at Meilisearch.

## Horizontal scaling with sharding

[![Horizontal scaling with sharding](https://unable-actionable-car.media.strapiapp.com/horizontal_scaling_with_sharding_792a7928b3.jpg)](https://www.meilisearch.com/blog/horizontal-scaling-with-sharding)

We introduced experimental support for sharding, enabling horizontal scaling. [Read more](https://www.meilisearch.com/blog/horizontal-scaling-with-sharding).

## SOC2 compliance

[![SOC 2 Type II announcement.jpg](https://unable-actionable-car.media.strapiapp.com/SOC_2_Type_II_announcement_fc6def3aea.jpg)](https://www.meilisearch.com/blog/soc2-typeii-compliance)

Meilisearch is now SOC2 Type II compliant. [Read more](https://www.meilisearch.com/blog/soc2-typeii-compliance).

## Multi-modal search

[![Example payload for a multi-modal request](https://unable-actionable-car.media.strapiapp.com/multi_modal_request_120e32cdc9.jpg)](https://www.meilisearch.com/blog/meilisearch-1-16#new-multi-modal-search-and-embeddings)

Leverage the new fragments API to get out-of-the-box multi-modal embeddings and search. [Read more](https://www.meilisearch.com/blog/meilisearch-1-16#new-multi-modal-search-and-embeddings).

## Product updates

New search features
- Stabilize the `STARTS_WITH` [filter](https://www.meilisearch.com/docs/learn/filtering_and_sorting/filter_expression_reference#starts-with) with improved performance
- Allow using the `EXIST` filter on `_vectors` fields

DX improvements
- Allow sorting on the [documents API](https://www.meilisearch.com/docs/reference/api/documents)
- Allow renaming indexes via the [index update](https://www.meilisearch.com/docs/reference/api/indexes#update-an-index) and [index swap](https://www.meilisearch.com/docs/reference/api/indexes#swap-indexes) APIs
- Search API responses can now [include query and documents vectors](https://www.meilisearch.com/docs/reference/api/search#display-vectors-in-response)
- New [webhooks API](https://www.meilisearch.com/docs/reference/api/webhooks) to trigger workflows after task processing
- Transfer documents between instances with the [export API](https://www.meilisearch.com/docs/reference/api/export)
- Improved hybrid search performance when using filters

Dashboard improvements
- Login: multiple OAuth providers can now be linked to the same account
- Tasks: allow tasks cancellation from the UI

## In the news

- [Introducing Meilisearch Enterprise Edition](https://www.meilisearch.com/blog/enterprise-license) Meilisearch is moving to a dual licensing model to serve both our community and enterprise users better.

- [What is RAG and how does it work?](https://www.meilisearch.com/blog/what-is-rag) Our complete guide to Retrieval-Augmented Generation.

- [Meilisearch voice search demo](https://voice.meilisearch.com/) Search for electronic products using your voice.

- `_geoPolygon` [filter prototype](https://chantiers-paris.vercel.app/) Check out this map of Paris construction sites built using the upcoming geo filter.

- [Flexible infrastructure pricing](https://www.meilisearch.com/pricing/platform) Customize the infrastructure for your Meilisearch deployment.

---

_We’re always looking to promote new projects from our [Discord community](https://dub.sh/meili-discord?utm_campaign=newsletter&utm_source=blog&utm_medium=july-25-updates). Share yours!_

---

## Contributors shout-out

Thanks to [@curquiza](https://github.com/curquiza), [@dureuill](https://github.com/dureuill), [@irevoire](https://github.com/irevoire), [@Kerollmops](https://github.com/Kerollmops) [@LeSuisse](https://github.com/LeSuisse), [@ManyTheFish](https://github.com/ManyTheFish), [@martin-g](https://github.com/martin-g), [@Mubelotix](https://github.com/Mubelotix), and [@qdequele](https://github.com/qdequele) for their contribution to [Meilisearch](https://git.new/meilisearch) 🙌

## We’re hiring

Check out our open position:
- [Senior Software Engineer](https://www.meilisearch.com/careers)

---

Receive this updates in your inbox by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=newsletter&utm_source=blog&utm_medium=august-25-updates). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-25-updates) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions).

For anything else, join our developers community on [Discord](https://dub.sh/meili-discord?utm_campaign=newsletter&utm_source=blog&utm_medium=august-25-updates).

August Changelog

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

Instead of relying only on what the model learned during training, RAG uses real-time data (from documents or databases) before generating its response.

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 uses.

![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 your 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 content to a language model for answer generation. The process is predictable.

Simple RAG is used in basic Q&A 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 search 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 is still referring to Paris. 

RAG with memory is used in personal AI assistants, conversational agents, customer support bots, 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 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
* Makes intelligent decisions 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 information. 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 insights

**Cons:**

* Requires significant work to build the knowledge graph
* Slower than basic RAG types
* 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 documents, 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 different interpretations based on your question, retrieving answers for each one, and then comparing the answers to pick the most relevant one.

Branched RAG is used in comprehensive market research, where 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 responses

**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 system 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 strategy 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 systems
* 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 information for those anticipated questions while still working on your actual question, so when you do ask that follow-up, it already has the relevant documents 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 results
* 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 components handle different parts of the process, and you can combine them however you want, depending on the task. 

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 domains in research environments, production systems, or research platforms.

**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 process.

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 is a more refined version of RAG that combines multiple steps (such as reranking, memory, feedback loops, branching, improved 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 processes: 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 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 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 system 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 search with AI generation. It retrieves information from a knowledge base and uses it to generate a more relevant and accurate answer.

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

RAGs are widely used for various applications. 

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, 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 real information. 

Combining strong retrieval with effective generation 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)

At Meilisearch, our main goal is simple: give developers and businesses a super-fast, really helpful, and easy-to-use search experience. While making our search engine awesome is what we do, keeping your data safe and private is just as important. 

This has been our focus since Day 1 of Meilisearch, but we didn’t have an official way to attest it. Today, we're excited to share some big news that shows how serious we are about this:

**Meilisearch has successfully passed its SOC2 Type II compliance check!**

This isn't just a fancy attestation – it shows how much we care about keeping your data secure and running things smoothly. For you, our users, this means you can feel even more confident that your important data is safe with us, thanks to our strong and regularly checked systems.

Also, we have to mention that this wouldn’t have been possible without the help of our partners from [Prescient Security](https://prescientsecurity.com/) and [Vanta](https://www.vanta.com/), who greatly helped us throughout the audit process.

## Understanding SOC2 Type II compliance

So, what exactly is SOC2 Type II? 

It's basically an audit standard from the [AICPA](https://www.aicpa-cima.com/home) (that's the American Institute of Certified Public Accountants). It checks how well a service company handles things like security, making sure stuff is available, keeping data accurate, and protecting private info. 

Getting Type II compliant means an independent auditor didn't just look at our systems once: they actually tested how well they worked over a prolonged period of over six months.

This tough audit process digs deep into how we manage customer data, focusing on five key areas:

- **Security**: This is all about protecting our systems from people who shouldn't have access. Think network safety, who can get in, and spotting any intruders. (Officially, this was the focus of the audit. Nevertheless, we made improvements to all 5 areas as a result of it!)
- **Availability**: This means our systems, products, and services are there when you need them, just like we promise. It covers how we keep things running, recover from problems, and handle unexpected issues.
- **Processing integrity**: This checks if our data handling is complete, correct, on time, and approved. It's about making sure your data is accurate and doesn't get messed up.
- **Confidentiality**: This is about keeping sensitive information private and safe from being seen or shared without permission. It includes things like encryption and limiting who can see what.
- **Privacy**: This looks at how we collect, use, keep, share, and get rid of personal information, making sure we follow our own privacy rules and general privacy guidelines. It's all about how we handle your personal data.

SOC2 Type II is the 'gold standard' for security because it gives you a clear, independent stamp of approval that a company is serious about protecting data. It's not just about having rules, it's about proving those rules actually work *all the time*.

## Meilisearch’s commitment to security

Our journey to SOC2 Type II compliance was a natural step for Meilisearch because we’ve always been about keeping your data safe. 

From the very beginning, we’ve focused on building a product and a company that truly cares about your data’s safety and privacy. This focus is built into everything we do – how we develop our products, how we run our operations, and even our company culture and processes.

To meet the tough requirements, we put in place and thoroughly tested a bunch of controls and measures for all the important areas:

- **Security**: We have strong controls to make sure only authorized people can get into our systems and access sensitive data. Our setup is protected by advanced tools that spot and stop threats, and we have a solid plan to quickly deal with any security issues. We also regularly check for weaknesses and fix them before they become problems.
- **Availability**: Meilisearch is built to be always on and reliable. We constantly watch our systems to make sure they’re running and available when you need them. We’ve also got comprehensive backup and recovery plans that we test regularly, so we can get things back up and running fast if something unexpected happens.
- **Processing integrity**: We have strict rules for how we handle data to make sure it’s accurate, complete, and done the right way. Our development and release processes include automated checks to prevent errors and keep your data in good shape throughout its journey with us.
- **Confidentiality**: Keeping your sensitive information private is super important to us. We encrypt your data when it’s stored and when it’s moving around. We also have clear rules about what data is confidential and limit who can see it, only giving access to those who absolutely need it. Everyone on our team gets regular training on how to handle sensitive information the right way.
- **Privacy**: Meilisearch is all about handling personal information properly, following global privacy rules. Our privacy program makes sure we’re open about how we collect and use data, gives you control over your own data, and sticks to relevant privacy laws. We have clear steps for how long we keep data, how we make it anonymous, and how we securely get rid of it.

We don't just do security to tick boxes. We keep investing in the best security tech, do regular internal checks, and make sure everyone on our team thinks security first. This proactive approach helps make sure Meilisearch stays a reliable and secure platform for all your search needs.

## What This Means for You: Our Users and Customers

Meilisearch getting SOC2 Type II compliant ensures you don’t just have to trust our word (although you can totally do 😉) and that the following perks are indecently verified for you, our awesome users and customers:

- **More trust and confidence**: This audit is like an independent stamp of approval that Meilisearch has solid systems in place to protect your data. You can feel even better about our security and know your information is in good hands.
- **Better data protection**: Because we stick to SOC2 Type II standards, you can be sure that your data – whether it’s product lists, user details, or anything else important – is handled with super care and kept safe from anyone who shouldn’t see it.
- **Easier for your own compliance**: For many companies, working with vendors who are SOC2 compliant is a must for their own rules and regulations. Our attestation makes it simpler for you to get internal approval and helps you keep up with your own compliance needs.
- **Less risk for you**: When you use a search solution that’s SOC2 Type II compliant, you greatly lower the chances of data breaches or security hiccups. This proactive way of handling security means fewer potential problems and helps keep your business looking good.
- **A leg up on the competition**: In today’s world, where data safety is a big deal, choosing a search provider with proven security credentials gives you an edge. It shows your own customers that you care about security and helps build their trust.

## The road ahead: always getting better

Achieving SOC2 Type II compliance is a huge win, but for us at Meilisearch, it's not the finish line – it's a major milestone on an ongoing journey. 

(It’s not the beginning either, as security is deeply ingrained in the architecture of the product and the company.) 

Security isn't a one-and-done thing, it's a continuous process of learning, adapting, and improving.

We're always looking for ways to make Meilisearch even more secure and reliable. You can expect us to keep investing in top-notch security practices and exploring new certifications that further strengthen our commitment to your data. We're passionate about building a search solution you can truly trust, and that means constantly pushing ourselves to be better.

Got questions about our security? Want to dive deeper into our audit report (under NDA, of course)? Don't hesitate to reach out to our team. We're always happy to chat about how we keep your data safe.

## Conclusion: your trust, our priority

So, there you have it! Meilisearch is officially SOC2 Type II compliant. This is a big deal for us, and we hope it’s an even bigger deal for you. It means we’re serious about protecting your data and providing a search experience that’s not just fast and relevant, but also incredibly secure.

We really value your trust. We promise to be open, dependable, and always put your data security first. If you haven’t already, we invite you to experience the power and peace of mind that comes with Meilisearch. Try it out, and see how easy and secure search can be!

Meilisearch is now SOC2 Type II compliant: A big step for trust and security

We’d like to share an important announcement: Meilisearch is moving to a dual licensing model to better serve both our community and enterprise users.

Meilisearch has been an open source project from the beginning, and it is thanks to our users and community that we have come this far, which is why it’s important to emphasize that **we’re not abandoning open source.**

Open source remains at the heart of Meilisearch. This licensing change simply allows us to grow sustainably while keeping core innovations free and accessible. Major developments in our search engine will continue to be part of the open source engine, and we will also continue to build and support our developer SDKs.

This new license is part of a broader strategic effort that enables us to enhance our enterprise and cloud offering. Being able to engage with large business willing to pay for our technology will enable us to continue building in the open and supporting the community.

## Why a new license?

Our vision for the enterprise license is to serve business needs while ensuring open source remains fully accessible for developers. 

**The enterprise license will be limited exclusively to features that are only relevant to large businesses with advanced security and observability needs.** 

In particular, these are features that:

- Target large-scale deployments with lots of data – such as sharding
- Dramatically increase ROI or boost conversion rates – such as analytics
- Provide new and enhanced security-related capabilities – such as fine-grained access controls

To be more transparent, the new license also allows us to delve deeper into experimental product features more freely and also aligns with our strategic roadmap. Here’s how we think it’s going to help our business:

- Open up opportunities in new verticals where customers need to self-host due to complex security concerns or regulations
- Provide a path for large enterprises already self-hosting at scale to gain more value. For example, there are massive companies with 200+ Meilisearch servers that we believe could benefit from enterprise-ready features and dedicated support – we want to better serve them with these new offerings.
- Create a clear separation: open source for developers, and the enterprise edition for larger businesses with specific security, scale, and ROI requirements

<Callout intent="tip">

Free EE licenses will be available for indie projects and non-profits upon request.

</Callout>

This new license comes as a part of version 1.19, and as we move forward, we’d like to highlight that we will continue to work closely with the community to iterate on this license and the pricing model that comes with it.

## In conclusion: What’s changing?

We’re now going to have two licenses:

- **Community Edition (CE)** → Remains fully open source (MIT). Everything developers need to build and experiment, available at no cost.
- **Enterprise Edition (EE)** → Enterprise-grade features under the Business Source License (BUSL), designed for scaling, advanced security, and observability.

**Our goal is simple**: Keep Meilisearch open source and free of charge, while also meeting the needs of enterprise customers who rely on Meilisearch at massive scale. We want to work towards a future where developers and businesses both thrive with Meilisearch.

<Callout>

If you have any thoughts or questions, we encourage you to open a discussion on [Discord](https://discord.com/invite/hTD5hU2yWV).

</Callout>

Introducing the Meilisearch Enterprise Edition license

Meilisearch uses sharding to distribute a single index across multiple server instances, thereby going beyond the limits of a single machine. This enables you to handle massive datasets and high-traffic loads by scaling your search infrastructure horizontally.

This guide will walk you through what sharding is, how it benefits you, and how to implement it step-by-step.

## How Meilisearch sharding works

Meilisearch sharding is designed for simplicity and robustness. Instead of you manually splitting data, Meilisearch handles the distribution automatically.

When you send a batch of documents to any node in your sharded cluster, the receiving node instantly forwards the *entire payload* to every other node. Each node then independently decides which documents it's responsible for and only indexes its assigned subset.

This design was chosen for its reliability. It avoids a single point of failure for data distribution and simplifies the logic, ensuring that every node has the opportunity to process the data without complex coordination. 

<Callout intent="tip">
This also means you can send your indexing tasks to any node, making it easy to load balance your writes.
</Callout>

### Distribution algorithm

To ensure a document is always stored on the same shard, Meilisearch uses a consistent hashing algorithm (**Rendezvous Hashing** using `twox-hash`) on each document's **primary key**.

For this algorithm to work, **you must set a `primaryKey` for your index before adding documents.** The `primaryKey` is the unique identifier used as the input for the hash function. Without it, Meilisearch cannot guarantee that a specific document will consistently land on the same shard, which would lead to data duplication and inconsistencies.

### Important: Enterprise Edition and licensing

Sharding is an advanced feature available exclusively in [Meilisearch Enterprise Edition](https://www.meilisearch.com/blog/horizontal-scaling-with-sharding) (EE). All [Meilisearch Cloud](https://meilisearch.com/cloud) users get access to Enterprise Edition features.

**A note on self-hosting**: The EE features are governed by the **Business Source License 1.1**, which allows you to use, test, and develop with sharding for free in non-production environments. A commercial license agreement with Meilisearch is required to use sharding in a production environment.

<Callout intent="tip">
To get started with Meilisearch Enterprise Edition, [get in touch](mailto:sales@meilisearch.com).
</Callout>

## How to set up sharding

### Prerequisites

1. **Meilisearch Enterprise Edition**: Ensure you are running a version of Meilisearch that includes this feature (v1.19+).
2. **Identical Setup**: All Meilisearch instances in your cluster must run the exact same version and share the same `MEILI_MASTER_KEY`.
3. **Primary Key**: The index you intend to shard **must** have a `primaryKey` configured before you begin adding documents.

<Callout intent="tip">
As of Meilisearch 1.19, network and sharding are experimental features. See how to [enable experimental features](https://www.meilisearch.com/docs/learn/resources/experimental_features_overview#activating-experimental-features).
</Callout>

### Step 1: Configure the network on each node

The sharding feature is enabled and configured by using the network API. First, you must [update the network](https://www.meilisearch.com/docs/reference/api/network#update-the-network-object) of **all nodes** in your cluster to enable sharding.

**On all nodes:**

```json
{
 "sharding": true
}
```

Then, you need to configure each node to make it aware of the network topology: give it a name and list the other nodes it will communicate with. For a 3-node cluster, [update the network](https://www.meilisearch.com/docs/reference/api/network#update-the-network-object) as follows:

**On `node-1`:**

```json
{
 "self": "node-1",
 "remotes": {
 "node-2": { 
 "url": "http://node-2-address:7700", 
 "searchApiKey": "your-search-api-key",
 "writeApiKey": "your-write-api-key"
 },
 "node-3": { 
 "url": "http://node-3-address:7700", 
 "searchApiKey": "your-search-api-key",
 "writeApiKey": "your-write-api-key"
 }
 }
}
```

*(Repeat this for `node-2` and `node-3`, updating the `self` value and `remotes` accordingly.)*

* `self`: A unique name for the current node. 
* `remotes`: A map of all other nodes in the network.
* `writeApiKey`: This API key must have the `documents.add` permission and is used to securely authorize the forwarding of documents between nodes.
* `searchApiKey`: This API key must have permission to search in the relevant indexes.

#### Step 2: Add documents as usual

You add documents the same way you always have, by sending a request to `/indexes/{index_uid}/documents`. You can send this request to **any node** in the cluster. Meilisearch handles the rest under the hood.

```bash
curl -X POST 'http://node-1:7700/indexes/movies/documents' \
 -H 'Content-Type: application/json' \
 -H 'Authorization: Bearer YOUR_API_KEY' \
 --data-binary @movies.json
```

#### Step 3: Monitor the distributed task

The task response has been enhanced to give you visibility into the distributed operation. The task object now includes a root-level `network` field.

When you query the task on the original node, you will see the status of the operation on the other shards:

```json
{
 "uid": 123,
 "status": "processing",
 // ... other task fields
 "network": {
 "remoteTasks": {
 "node-2": { "taskUid": 56 },
 "node-3": { "taskUid": 89 }
 }
 }
}
```

#### Step 4: Search your distributed index

To search against a distributed index, you need to use [federated search](https://www.meilisearch.com/docs/learn/multi_search/performing_federated_search) to make queries against multiple indexes and consolidate results in a single response. 

In practice, this can be done by making a multi-search request against multiple nodes. The request parameters need to be similar, except for the network configuration. In our example, the [multi search request](https://www.meilisearch.com/docs/reference/api/multi_search) would look like this:

```json
{ 
 // enables federated search
 "federation": {},
 "queries": [ 
 { 
 "indexUid": "movies", 
 "q": "star wars",
 "federationOptions": { 
 "remote": "node-1" 
 }
 }, 
 { 
 "indexUid": "movies", 
 "q": "star wars",
 "federationOptions": { 
 "remote": "node-2" 
 }
 }, 
 { 
 "indexUid": "movies", 
 "q": "star wars",
 "federationOptions": { 
 "remote": "node-3" 
 }
 }
 ] 
}
```

## Moving forward

Sharding is a powerful feature that enables horizontal scaling and high availability for your search infrastructure. By distributing your index across multiple nodes, you can handle larger datasets and higher query loads with ease. 

We’re looking forward to seeing sharding evolve thanks to early adopters’ feedback. Our roadmap includes supporting dynamic network topology changes, automatic settings propagation, and improving multi-search on sharded nodes.

Meilisearch Cloud users can get started by asking the support to enable sharding for their projects. For companies interested in self-hosting Meilisearch Enterprise Edition, [get in touch with our sales team](mailto:sales@meilisearch.com).

Meilisearch latest news and company updates