Speculative RAG: A faster retrieval-augmented generation

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

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

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

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

Here’s what we’ll cover:

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

Now, let’s examine the basics more closely.

## What is corrective RAG (CRAG)?

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

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

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

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

## How does corrective RAG improve traditional RAG?

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

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

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

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

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


## Why is CRAG important in LLM applications?

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

Here’s why CRAG matters in LLM applications:

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

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

## What are the key components of corrective RAG?

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

CRAG includes the following key components:


### 1. Retriever

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

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

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

### 2. Evaluator

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

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


### 3. Generator

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


### 4. Feedback loop

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

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

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

## What does a corrective RAG workflow look like?

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

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

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

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

## How to implement corrective RAG

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

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

### 1. Index data with Meilisearch

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

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


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

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


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


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


### 3. Evaluate and correct the context

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


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


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


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

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


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


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


### 5. Log feedback and improve continuously

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


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


This completes the corrective flow. 

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

## When should you use CRAG?

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

Let’s see where we can use it:

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

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

## What are the limitations of corrective RAG?

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

Here are some other CRAG limitations to keep in mind:

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

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

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

## How does corrective RAG differ from speculative RAG?

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

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

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

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

## Final thoughts on building with corrective RAG

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

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

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

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

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

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

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

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

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

## 1. Simple RAG (original)

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

It is the most straightforward implementation.

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

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

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

**Pros:**

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

**Cons:**

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

## 2. Simple RAG with memory

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

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

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

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

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

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

**Pros:**

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

**Cons:**

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

## 3. Agentic RAG

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

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

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

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

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

**Pros:**

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

**Cons:**

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


## 4. Graph RAG

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

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

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

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

**Pros:**

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

**Cons:**

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

## 5. Self-RAG

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

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

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

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

**Pros:**

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

**Cons:**

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


## 6. Branched RAG

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

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

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

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

**Pros:**

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

**Cons:**

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

## 7. Multimodal RAG

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

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

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

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

**Pros:**

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

**Cons:**

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

## 8. Adaptive RAG

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

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

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

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

**Pros:**

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

**Cons:**

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


## 9. Speculative RAG

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

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

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

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

**Pros:**

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

**Cons:**

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

## 10. Corrective RAG

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

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

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

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

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

**Pros:**

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

**Cons:**

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


## 11. Modular RAG

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

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

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

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

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

**Pros:**

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

**Cons:**

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

## 12. Naive RAG

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

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

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

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

**Pros:**

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

**Cons:**

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


## 13. Advanced RAG

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

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

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

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

**Pros:**

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

**Cons:**

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

## 14. HyDE (hypothetical document embedding)

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

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

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

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

**Pros:**

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

**Cons:**

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


## Why are there different types of RAG architecture?

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

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

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

Now, let’s see the importance of RAG.


## What is the importance of RAG?

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

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

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

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

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

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


## What tools are used for RAG?

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

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


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

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


## Build efficient RAG systems with Meilisearch

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

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

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

14 types of RAG (Retrieval-Augmented Generation)

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

Horizontal scaling with sharding

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

Why do we need them?

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

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

This guide breaks down nine advanced RAG techniques worth knowing:

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

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

Let’s get into it.

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

## 1. Text chunking

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

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

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

Here are a few types of chunking:

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

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

## 2. Reranking

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

Here are a few common approaches to reranking:

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

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

## 3. Leveraging metadata

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

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

Here are its key sub-types:

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


## 4. Hybrid search

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

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

Here are the two main approaches to hybrid search:

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


## 5. Query rewriting

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

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

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


## 6. Autocut

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

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

Here are two common strategies for autocutting:

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

## 7. Context distillation

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

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

Two ways to approach this:

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

## 8. Fine-tuning the LLM

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

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

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

## 9. Fine-tuning the embedding models

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

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

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

## What are advanced RAG techniques?

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

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

## Why are advanced RAG techniques needed?

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

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

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


## How can you implement advanced techniques in RAG?

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

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

* Meilisearch
* Weaviate
* LangChain
* Pinecone

Let’s learn a little more about them:


### 1. Meilisearch

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

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


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


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


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


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


### 2. Weaviate

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


### 3. LangChain

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

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


### 4. Pinecone

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

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


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

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

To assess effectiveness, focus on metrics like:


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

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


## Why smarter RAG matters in practice

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

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


Meilisearch latest news and company updates