How to Build RAG Applications on Rails: Step-by-Step Guide

Today, we’re excited to share that Meilisearch is [live on AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-7ougkqatzyr7i). You can now get Meilisearch with one click directly through your AWS account!

This builds on our existing partnership with AWS. Earlier this year we even showcased Meilisearch at VivaTech, and since then have been expanding our collaboration to make search with AWS even easier!

## Why this matters

- You can use your AWS budget and keep one consolidated bill.
- Move faster with standardized AWS terms and streamlined procurement.
- Ship confidently with enterprise-grade options: SLAs, high availability, multi‑region replication, and deployment in your preferred AWS region.

## What you get with Meilisearch

Meilisearch is developer-first, comes with a simple API, and allows you to leverage search instantly with your existing AWS workflow. We stand out with the following features:

- Unified search, one API: full‑text + vectors + hybrid retrieval.
- Great relevance out of the box: typo tolerance, filters/facets, synonyms, ranking rules.
- Built for application search: ultra‑low latency, instant indexing, and clean SDKs.
- Designed for developers: quick integration, straightforward tuning, and clear docs.

## When to choose Meilisearch vs. OpenSearch

AWS does have their own search offering with the OpenSearch service, but Meilisearch can be the right option when you need:

- User‑facing product/docs/in‑app search with extremely low latency.
- Minimal DevOps and fast onboarding with consistent low‑latency responses.
- Simple, powerful controls for ranking rules, facets, synonyms, and hybrid (keyword + vector) search.

On the other hand, OpenSearch is recommended if you need:

- Log analytics, observability, or heavy aggregations across massive datasets.
- Deep Elasticsearch/OpenSearch DSL compatibility for analytics-style workloads.

**Rule of thumb**: Meilisearch is purpose-built for high-quality, user-facing discovery in applications. OpenSearch fits analytics‑heavy and observability scenarios.

## How to get started on AWS Marketplace

1. [Open the listing and choose a plan](https://aws.amazon.com/marketplace/pp/prodview-7ougkqatzyr7i) (Growth or Dedicated) and a contract term 
2. Subscribe via AWS Marketplace
3. Create your Meilisearch project and generate an API key.
4. Index your data using the REST API or official SDKs (JS, Python, Go, PHP, Ruby, and more).
5. Configure relevance: ranking rules, synonyms, stop‑words, and facets.
6. Plug in your UI and iterate with monitoring and tuning as needed.

## Pricing and procurement notes

- Contract‑based subscription with usage‑based options to help avoid overprovisioning.
- Additional AWS infrastructure charges may apply (see AWS Pricing Calculator as needed).
- Need something tailored? Talk to sales for a customized offer.

## Security, compliance, and support

- AWS Marketplace vetting and standardized procurement processes.
- Enterprise support available: SLAs, Technical Account Management, and shared Slack/Teams channels (details defined per contract).
- See the listing and documentation for region availability, high availability, and replication.


## FAQs

- Can I use my AWS commit? Yes—purchases flow through AWS Marketplace.
- Do I have to manage infrastructure? Meilisearch Cloud handles operations for you.
- How do migrations work from Elasticsearch/OpenSearch/Algolia? Export your data, map fields, and re‑index; we provide guidance and best practices.
- How do I size my deployment? Start with our sizing guidance and talk to sales for a customized recommendation.

## Try Meilisearch on AWS

[Get Meilisearch on AWS Marketplace today](https://aws.amazon.com/marketplace/pp/prodview-7ougkqatzyr7i?sr=0-2): 

Have questions or unique requirements? Talk to sales for a customized offer.

Meilisearch is now available on AWS Marketplace!

Here's a recap of everything that happened this month!

---

## 💬 New and improved Geosearch

We introduced a new geo backend to store geojson and filter on polygon in v1.22.0 🐦‍🔥

This make the ```_geojson``` field filterable, when mean you can then send your documents with a ``` _geojson``` field filled with a valid geojson

You can also filter your documents with the new``` _geoPolygon``` filter - meaning you ** draw any polgyon** and get instant search!
## Improved vector storage

We Introduced a new vector store backend for better performance, especially if using the binary quantization. You need to enable the new ```vectorStoreSetting``` experimental feature and change the vectorSetting index setting to "experimental" for the indexes where you want to try the new vector store!

This should give you much more improved performance!
## Now supporting Persian language

With the latest update to [charabia](https://github.com/meilisearch/charabia), we now have Persian language support as well!
## Other news

- Check out the [Experimental voice demo](https://voice.meilisearch.com/) we launched earlier this month
- [We're growing our team](https://www.meilisearch.com/careers) and are looking for talented senior software engineers
 - October 13th will be the start of [launch week](https://www.meilisearch.com/launch-week-q3-2025), where we'll be discussing our newest features!

---

Receive this updates in your inbox by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=newsletter&utm_source=blog), or 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=july-25-updates).

Meilisearch September Updates

RAG (retrieval-augmented generation) evaluation is the process of measuring how well a system actually retrieves relevant information to generate accurate answers for the users. It helps improve retrieval logic as well as the response quality.

RAG evaluation is crucial for identifying gaps in the system’s performance and reliability across various use cases.

The most common methods associated with RAG evaluation are human evaluation, reference answer scoring, and retrieval relevance checks.

In addition to this, the most widely used retrieval metrics are Exact Match, F1 score, Recall, Precision, BLEU, and ROUGE. The tools you’ll see used most often in this domain include Meilisearch, LangChain, RAGatouille, and Haystack. 

Now that the stage is set, let’s have a deeper look at what RAG evaluation is and the methods involved.

## What is RAG evaluation?

RAG evaluation is the process that determines how effectively a [RAG system](https://www.meilisearch.com/blog/what-is-rag) retrieves information and then uses that information to generate accurate answers for users. 

You might have noticed that RAG evaluation covers both retrieval and generation. This is to provide a clear view of the system's overall correctness. 

Once you have that, it becomes easier to identify weaknesses, test improvements, and benchmark different models or approaches. 

## Why is RAG evaluation important?

RAG evaluation is important because it helps determine whether your system is actually delivering responses that are relevant and helpful to users. 

Without this kind of evaluation, it's difficult to know if your pipeline is improving or drifting off course.

RAG evaluation can help teams identify and address issues early. This can include spotting hallucinations, irrelevant retrieval, and complex, inaccurate answers: 

* **Reduces hallucination risk:** Evaluation highlights the generation based on weak retrieval, allowing you to correct it immediately.
* **Improves user trust:** This evaluation helps make your RAG system fact-based and transparent, improving user confidence.
* **Enables faster iteration:** With regular evaluation, you can measure impact across changes and optimize performance quickly.

Next, let’s look at the methods used in RAG evaluation. 

## What methods are used in RAG evaluation?

The different methods used in RAG evaluation are shown in the image below:

![RAG Evaluation Methodologies.png](https://unable-actionable-car.media.strapiapp.com/RAG_Evaluation_Methodologies_28942e88c7.png)

These approaches evaluate both the retriever and generator, ensuring no compromise on high-quality outputs at any step.


### End-to-end evaluation

First up is the end-to-end evaluation. It focuses on the overall output of the RAG system. 

The factors under consideration are the usefulness, accuracy, and fluency of the generated response without breaking down the pipeline components. 

While it provides a quick way to compare systems, it doesn’t reveal which part of the pipeline – if any – actually failed.

### Retriever evaluation

Retrieval evaluation, as its name suggests, focuses on whether the retrieval system brings back relevant documents for the query. 

The evaluators can be human or automated. Either way, their function is to judge the quality of the retrieved context using a relevance score. 

You can pinpoint the weakness that led to poor answers downstream. 

### Grounding evaluation

Grounding eval checks if the generated response remains faithful to the retrieved content. 

How do we find that out? The output is compared with the supporting context to check factual accuracy. Naturally, this helps you spot and fix potential hallucinations.


## What are the key RAG evaluation metrics?

RAG evaluation metrics measure the quality of the retrieved documents and the accuracy of the generated response. Developers can use this information to identify where the pipeline is failing and make the necessary corrections.

Some of the key RAG evaluation metrics to know are the following:

* **Precision and recall:** Precision measures the percentage of retrieved docs that are actually relevant, while recall assesses the percentage of relevant documents that were retrieved. You need both to achieve a balance between accuracy and coverage in information retrieval. 

![Precision and recall.png](https://unable-actionable-car.media.strapiapp.com/Precision_and_recall_13f62b830c.png)

* **Groundedness:** This metric evaluates whether the generated output is factually consistent with the retrieved documents. A high groundedness score means the model is less likely to hallucinate.
* **Faithfulness:** Faithfulness measures how well the generated text sticks to the facts in the source material. Unlike groundedness, faithfulness seeks to identify distortions or unsupported claims.
* **Answer relevance:** Is the final answer even relevant to the user’s query? This is determined through answer relevance that relies on human ratings or automated scoring methods.
* **Fluency:** Fluency assesses how natural and readable the generated response is. After all, the target user is human. While secondary to accuracy, fluency impacts user trust and the overall experience.

Together, these metrics serve as essential benchmarks for any RAG applications, providing a complete and honest picture of the RAG system.

## What are the challenges in RAG evaluation?

RAG evaluation has a few unique challenges that we’ll list here:

1. **No universal benchmarks:** Unlike classic machine learning, there is no universal benchmark for RAG evaluation that applies to every [type of RAG system](https://www.meilisearch.com/blog/rag-types), as they all differ in architecture.
2. **Human evaluation costs too much:** Groundedness and relevance often require human judgment, which is expensive and hard to scale.
3. **Dynamic data and drift:** The frequent interaction of RAG pipelines with evolving knowledge bases means that evaluation results soon become outdated.
4. **Trade-offs between metrics:** There’s always a trade-off between the metrics. For instance, optimizing for fluency might reduce faithfulness. Similarly, improving recall could harm precision. 

## How is RAG evaluation implemented?

Different tools, frameworks, and services are responsible for implementing RAG evaluation. The evaluation process is mostly a combination of human review, automated evaluation, and continuous monitoring. 

Most teams prefer to conduct offline testing first and then move on to live monitoring once the pipeline is deployed. 

### Popular RAG evaluation frameworks

Popular open-source frameworks, such as Ragas, TruLens, and DeepEval, are a major help when it comes to automated testing. 

These frameworks use automated tests to help measure retrieval precision and factual consistency, and monitor hallucination rates. Through the LLM-as-a-judge grading they provide, you can easily identify weaknesses and correct them within the system.

For an easily digestible overview of retrieval layers and orchestration platforms, feel free to check out our guide on[ the top RAG tools](https://www.meilisearch.com/blog/rag-tools). 

### Synthetic test datasets

Another common method is creating synthetic evaluation datasets that replicate real-world query patterns. 

How does this help? It allows developers to benchmark retrieval quality and groundedness under a controlled set of conditions. You get to identify coverage gaps before the pipeline enters the production stage.

### Human-in-the-loop validation

There’s no alternative to human insight. Even with strong automation, human evaluation remains critical. 

Subject matter experts review sampled queries to verify if the retrieved content is relevant and the generated answers are accurate. It provides a nuanced view of the system that metrics alone cannot determine.

### Continuous monitoring in production

As a developer, you already know that evaluation does not stop once a system is live. Production monitoring tracks key metrics, including latency, error rates, and feedback loops. 

A reliable retrieval layer, such as Meilisearch, supports this process by consistently delivering fast, high-quality context that evaluation frameworks depend on.

Together, these approaches form a cycle of pre-deployment testing, human review, and real-time monitoring. As a result, the RAG pipelines remain accurate, efficient, and trustworthy over time.

## What are the best practices in RAG evaluation?

Best practices give you the most efficient way to ensure that pipelines are tested thoroughly and fairly. Early weakness detection, hallucination spotting, and maintaining reliability are all part of these best practices.

![Best Practices in RAG Evaluation.png](https://unable-actionable-car.media.strapiapp.com/Best_Practices_in_RAG_Evaluation_06aaf08217.png)

Some of the key best practices include:

* **Use more than one test set:** Evaluate your system with multiple data types and domains, rather than relying solely on a single benchmark. This exposes weaknesses that would otherwise go unnoticed.
* **Combine human and automated checks:** Humans provide context-sensitive judgments, while automated metrics offer speed and scale. A balance between both is your best bet.
* **Test the robustness of the system:** Introduce adversarial or noisy inputs to see how well the system maintains accuracy under less-than-ideal conditions.
* **Track longitudinal performance:** Don’t stop evaluating pipelines. Continue over a staggered time period. This helps identify model drift and measure whether improvements stick.
* **Target user expectations:** Design evaluations that mirror how end-users will interact with the system. Metrics should reflect usefulness, not just technical accuracy.

These practices make RAG evaluation a reliable part of development, ensuring systems remain stable and trustworthy at scale. To explore techniques that can further improve pipeline performance, take a look at our article on[ advanced RAG techniques](https://www.meilisearch.com/blog/rag-techniques).

## How long does it take to evaluate a RAG pipeline?

The answer to this question lies in the variables. Smaller prototypes can be evaluated within hours, while production-scale pipelines require days of rigorous evaluation. 

The duration also depends on factors such as dataset chunk size, evaluation methods, and the number of metrics being tracked. 

For example, using human annotators for quality checks is slower but provides better, more nuanced insights than automated benchmarks. 

The complexity of the pipeline also affects the timeline.

## Are there any papers on RAG evaluation?

Yes, there are several notable papers on RAG evaluation, and most of them can be found on arXiv. Here are some recent ones from 2024 and 2025:

* ‘Evaluation of Retrieval-Augmented Generation: A Survey’ (2024) by Hao Yu et al.
* ‘Evaluating Retrieval Quality in Retrieval-Augmented Generation’ (2024) by A. Salemi et al. 
* ‘VERA: Validation and Evaluation of Retrieval-Augmented Systems’ (August 2024) by Tianyu Ding et al.
* ‘Unanswerability Evaluation for Retrieval-Augmented Generation’ (December 2024) by Xiangyu Peng et al.
* ‘Retrieval Augmented Generation Evaluation in the Era of Large Language Models’ (April 2025) by Aoran Gan et al.
* ‘The Viability of Crowdsourcing for RAG Evaluation’ (April 2025) by Lukas Gienapp et al. 

These papers provide a rich foundation for anyone wanting to understand or benchmark RAG evaluation methods, metrics, and emerging best practices.

## The future belongs to teams that master RAG evaluation

RAG evaluation is not just a technical exercise – it is the feedback loop that keeps RAG systems honest, reliable, and ultimately useful. 

In practice, evaluation becomes the difference between a system that only looks impressive in demos and one that consistently delivers value in production.

As data sources shift, user expectations evolve, and generative models grow more complex, the ability to adapt evaluation strategies will separate cutting-edge teams from those left chasing errors downstream. 

RAG evaluation: Metrics, methodologies, best practices & more

Modular RAG refers to a method of building [retrieval-augmented generation (RAG) systems](https://www.meilisearch.com/blog/what-is-rag) where the entire setup is divided into smaller and independent components. This makes designing, customizing, or upgrading the pieces easier.

The key components of modular RAG are the retriever, which finds useful information, the generator, which turns the information into responses, and additional modules such as rerankers, memory, or vector databases, which improve the accuracy of the artificial intelligence system. Each module handles a specific function that contributes to the overall quality.

Modular RAG works by retrieving relevant context from external knowledge sources, passing it through a generative model, and allowing different modules to handle tasks such as filtering, summarization, or reasoning, depending on the task's requirements.

The key advantages of modular RAG are increased flexibility, easier debugging, and better scalability. The key disadvantages of modular RAG are added complexity in system design and potential challenges in integrating the different modules.

You can implement modular RAG by combining retrievers and LLMs into a RAG pipeline that fits your use case.

This article will discuss everything you should know about the modular RAG framework.

## What is modular RAG?

Modular RAG is a way of building RAG systems that treats each part of the process as separate but connected modules. Instead of having one rigid design, you get to choose the system build that works best.

In modular RAG, you can create a pipeline that adapts to your needs, be it faster retrieval or more accurate answers. Because you are not forced to use the same retrieval method, vector database, or language model every time, you get finer control over how information is retrieved, processed, and turned into answers. 

For example, you might love how one company's embedding model works but dislike its retrieval system. With modular RAG, you can retain the embeddings and change to a different retrieval process. You can even experiment with multiple language models to see the best-performing one for your use case.

Modular RAG is subdivided into three different components:

* The retriever that gathers context
* The generator that creates responses
* Additional modules, such as filters, memory, or rerankers, that refine the output to suit the user’s needs

Now, let’s see the working mechanism behind modular RAG.

## How does modular RAG work?

Modular RAG works by breaking the [RAG process](https://www.meilisearch.com/blog/how-to-build-rag) into separate components, with each component handling a specific task. 

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

These components can include:

* **Retriever:** The retriever searches a knowledge base or [vector database](https://www.meilisearch.com/blog/what-is-a-vector-database) for relevant information.
* **Reranker or filter:** This is optional but recommended. Before sending the results forward, a reranker or filter can reorder, clean, or narrow down the retrieved data so that only the most useful content is passed along to the next component.
* **Generator:** The generator (typically a large language model such as OpenAI GPT) takes the refined context and uses it to produce a response.
* **Additional modules:** Depending on the use case, additional modules such as memory modules or summarizers can be slotted in to improve accuracy or break down complex queries.
* **Output delivery:** Finally, the GenAI system returns an accurate response that is grounded in the retrieved information.

Let’s see some examples of modular RAG.

## What is an example of modular RAG?

An example of modular RAG in action can be an online shopping assistant. 

Let’s say you search for ‘running shoes under $100.’ The router first decides the best way to handle that query: either through keyword search or by semantic similarity search. 

The retriever then digs through the store’s product database. 

Next, the processing modules clean up the results, filter out any irrelevant items, and then rank the best fits. 

The generator takes that context and produces a useful reply such as, ‘Here are three running shoes under $100 that match your style.’

If the store later wants to add a recommendation setup or customer reviews as part of its process workflow, it can be done without changing the overall setup.

## What are the advantages of modular RAG?

The key advantages of using modular RAG over traditional and one-piece [RAG types](https://www.meilisearch.com/blog/rag-types) are the following:

* **Easy maintenance:** You can fix, upgrade, or replace a single part without worrying that the entire system will break.
* **Faster development:** Different teams can work on separate modules in parallel, allowing for faster deployment and optimization of new features.
* **Easy customization:** Different industries have different needs for modular RAG. A legal assistant may add citation tracking, while an e-commerce chatbot may use recommendation modules. Modular RAG makes it easy to tailor the modules to your needs.
* **Scalable performance:** Modules that handle heavier workflow can be given extra resources, while lighter ones can run with less. 
* **Reliability:** Since the AI system is divided into separate components, weak spots can be easily spotted and fixed, making it more reliable over time.

## What are the disadvantages of modular RAG?

The disadvantages of implementing modular RAG are the following:

* **Higher setup costs:** More modules mean more infrastructure and skilled people are needed to run them, which drives costs up. 
* **Complexity overload:** Managing several modules at once is not easy. There are more parts to manage individually and collectively. Troubleshooting the modules can also involve complex procedures, particularly in identifying the root cause of the issues.
* **Learning curve:** Teams using modular RAG must understand how each module works and fits together, which can slow down onboarding and often requires knowledge of data science and NLP.

## What is the architecture of modular RAG?

The architecture of modular RAG is built around breaking the whole system into smaller parts that work together. Here is how the typical architecture looks:

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

* **Client query interface:** This is where the user’s query first comes in. 
* **Retrieval module:** The query from the client query interface is sent to the retrieval module. This module includes a vector search store (used for semantic search), a document store (used for traditional text search), and a cache layer (used to quickly retrieve recent or repeated queries). Together, they act like a library housing the important information.
* **Reasoning module:** Here, the context processor organizes what was retrieved, the inference engine helps the system reason through it, and the state manager keeps track of any history or ongoing context.
* **Generation module:** This is the last phase. The LLM generates a draft response, the template engine structures it neatly, and the output validator checks it for accuracy before delivering the final response to the user.

The architecture of modular RAG makes it easy to use for domain-specific use cases, such as customer support or enterprise knowledge graphs.

## How can modular RAG be implemented?

Modular RAG can be implemented by combining several independent pillars. Each pillar addresses a different aspect of the system and can work on its own or alongside the others. 

Let’s look at these pillars:  

### 1. Data pipeline

The data pipeline handles how datasets are ingested and processed. You can create multiple data pipelines based on the type of content. 

For example, an ETL pipeline that implements modular RAG for customer support documents and another that handles technical manuals. Each use case has its processing pipeline that knows how to handle that specific content. 

Techniques such as chunking and carefully selecting the chunk size can significantly improve retrieval quality.

### 2. Microservices 

The system is divided into independent services that communicate with each other via API calls. Your ‘retrieval’ service can handle document searches, while the ‘reasoning’ service processes the logic, and your ‘generation’ service crafts the final response.

[Meilisearch](https://www.meilisearch.com/docs) can be used as the retrieval service because it can quickly index and retrieve documents without heavy infrastructure overhead.

### 3. Routing layer

The routing layer directs queries based on rules or classifiers and decides which module or pipeline should handle user queries using retrieval strategies or classifiers. You can use simple keyword matching for simple queries, but machine learning classifiers are better for complex queries. 

### 4. Containers for technical implementation

Containers for technical implementation manage how services are packaged and deployed. They make it easy to scale specific modules up or down, swap one out if needed, or update a service without breaking the whole setup.

### 5. Monitoring and orchestration tools

Monitoring and orchestration tools ensure smooth coordination, error handling, and balancing of generation processes. They track how each module performs, catch errors before users find them, and coordinate complex queries that need multiple modules to work together.

## How can modular RAG be evaluated?

Evaluating modular RAG requires tracking metrics across modules:  

* Information retrieval quality via precision and recall.  
* Post-retrieval validation to ensure the correct retrieved documents.  
* End-to-end evaluation of speed and quality, compared against baseline pipelines.

The most comprehensive setup is a ‘sandboxed RAG playground,’ which includes static data, swappable modules, and an LLM to evaluate answers across different configurations.

You want to measure both individual module performance and overall system effectiveness. 

For individual modules, you can track metrics like retrieval accuracy, response time, and resource usage. Each specialized module should behave like an expert in its field, meaning your legal module should confidently handle legal queries, while the technical one should handle engineering problems perfectly.

End-to-end [RAG evaluation](https://www.meilisearch.com/blog/rag-evaluation) matters just as much as module benchmarks. Run complex queries and observe how well the modules work with each other. Check if the system returns an accurate answer. 

In addition, compare the overall quality of information retrieval against a single-pipeline baseline to determine if modular RAG is an improvement.

Another consideration is comparing latency and quality trade-offs. Modular systems often introduce increased latency due to the coordination overhead, so you will need to balance response speed with answer quality.

Real-world testing with iterative feedback loops and augmentation scenarios is great for evaluating modular RAG. It is better to use actual user queries on your system than synthetic test cases. 

Also, pay attention to edge cases where routing gets tricky or where the modules need to collaborate.

## How does modular RAG compare to naive RAG?

Modular RAG uses multiple specialized components that capture domain-specific details and deliver more accurate results, while naive RAG relies on a single retrieval system that may overlook nuances. 

Modular RAG is like a team of specialists, while naive RAG is more like relying on a generalist.

Compared to naive RAG, modular RAG is more powerful for complex queries, though it requires more effort to build and maintain. 

Naive RAG, on the other hand, is quick and straightforward. Your query goes into one retrieval step, documents come back, and an answer is generated.

## How does modular RAG compare to advanced RAG?

Modular RAG can be seen as an evolution of advanced RAG techniques, taking the same core idea but pushing it further by emphasizing modularity, scalability, and flexibility. 

Advanced RAG represents an improvement over naive RAG by incorporating smarter algorithms, enhanced reranking, or multiple retrieval steps. But it is still often built as one big pipeline. 

Modular RAG breaks this apart into smaller, specialized modules that can be swapped, upgraded, or scaled independently.

Both approaches are powerful, but modular RAG shines when you want control, scalability, and the freedom to adjust as your needs evolve.

## Are there papers on modular RAG?

Yes, there are different papers on modular RAG:

1. ‘Modular RAG: Transforming RAG Systems into LEGO-like Reconfigurable Frameworks,’ published July 2024 by Yunfan Gao, Yun Xiong, Meng Wang, and Haofen Wang (arXiv). It introduces the modular RAG paradigm and lays out a flexible, multi-module architecture that evolves beyond the classic linear RAG flow. 
2. ‘Retrieval-Augmented Generation for Large Language Models: A Survey’ by Gao *et al.,* published December 2023 on arXiv. It covers the broader RAG evolution, including the various modular approaches.
3. ‘RAG and RAU: A Survey on Retrieval-Augmented Language Model in Natural Language Processing’ by Hu and Lu, published April 2024 on arXiv. It examines modular components and their interactions. 
4. ‘A Survey on RAG Meets LLMs: Towards Retrieval-Augmented Large Language Models’ by Ding *et al.,* published May 2024 on arXiv. It explores modular architectures and training strategies.


## Start building intelligent RAG systems with Meilisearch

If you are looking to build smarter RAG systems, Meilisearch is your go-to tool. 

It is easy to set up, meaning you can focus more on building intelligent retrieval workflows rather than battling with designing RAG infrastructure. 

Meilisearch also shines at delivering highly relevant documents with low latency, making it ideal for feeding accurate context into your generative AI models.

Modular RAG: What it is, how it works, architecture & more

Traditional retrieval-augmented generation (RAG) is powerful, but it often treats information as isolated chunks, missing the connections between entities that give answers depth and context. 

GraphRAG changes that by combining knowledge graphs with large language models, allowing AI to reason across linked data, trace relationships, and produce richer, more accurate responses. 

Whether you’re building advanced chatbots, analyzing legal documents, or exploring healthcare research, GraphRAG offers explainable and scalable results. 

In this article, we explain how GraphRAG works, why it matters, and the tools and steps needed to implement it effectively.

## What is GraphRAG?

GraphRAG stands for Graph Retrieval-Augmented Generation. It is an advanced approach that follows the [basic principles of RAG](https://www.meilisearch.com/blog/what-is-rag) systems, but it also combines knowledge graphs with large language models to produce context-rich and accurate responses. 

While the common assumption might be that it retrieves isolated chunks, GraphRAG actually uses the structure of the graph to map the relationship between the entities or documents. This allows the model to reason and provide more depth in answers. 

Let’s look at how GraphRAG works in practice.

## How does GraphRAG work?

GraphRAG works by blending structured data from a graph with language model reasoning. 

The process starts with indexing and retrieval steps similar to those in a traditional [RAG retrieval workflow](https://www.meilisearch.com/blog/rag-techniques), but extends them with a graph layer for connected reasoning and contextual information that reflects real-world relationships. 

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

Let’s look at a sequential progression of a typical RAG workflow:

1. **Build the knowledge graph:** Start by collecting your source material – documents, datasets, or domain-specific content. From this, you extract entities (such as people, concepts, or places) and the relationships between them, either with natural language processing tools or manual curation. These entities and connections are then stored in a graph database or graph data structure.
2. **Retrieve relevant context:** When a user submits a query, the system first searches for relevant nodes and edges in the graph. A search engine like Meilisearch can quickly handle text or metadata retrieval before moving on to graph traversal. The result is a set of related entities and their connections, forming a structured context for the query.
3. **Generate with LLMs:** Finally, the retrieved subgraph, supporting documents, and the user’s query are passed to the LLM. The model combines the textual content with the graph’s relationships to produce a context-rich answer that responds directly to the query and provides supporting details tied to the graph’s structure.

In practice, this setup helps the LLM understand how different pieces of information fit together and provides a better overall explainability.

## What are the benefits of using GraphRAG?

The key benefits of GraphRAG include:

* **Improved accuracy:** Graph traversal only brings you the most relevant nodes and documents, so there’s a reduction of noise in the search results.
* **Stronger reasoning:** Structured connections in a graph let the LLM follow logical paths, making its answers more coherent and less prone to hallucinations than when reasoning over unstructured data.
* **Explainability:** GraphRAG makes tracing how an answer was formed easier. Developers can better view and explain the nodes and relationships supporting the output.
* **Scalability:** Graph structures make it easier to expand knowledge bases while keeping retrieval efficient, even as the volume of data grows.

Based on these benefits, it’s clear that GraphRAG can be invaluable in domains that rely on precision and trust, such as healthcare, finance, and law. 

## How is GraphRAG different from baseline RAG?

GraphRAG represents one of the different [types of RAG](https://www.meilisearch.com/blog/rag-types), and its retrieval process differs from baseline RAG. 

Baseline RAG is vector search-based, while GraphRAG uses structured relationships to get the end result. GraphRAG can still use vector and full-text search, but relationships drive what gets retrieved.

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

Key differences between baseline RAG and GraphRAG include:

* **Data structure:** Baseline RAG stores documents as [embeddings in a vector database](https://www.meilisearch.com/blog/what-are-vector-embeddings), while GraphRAG models entities and relationships as nodes and edges, optionally combined with embeddings.
* **Retrieval:** Baseline RAG relies on semantic similarity over vectors, whereas GraphRAG uses graph traversal with local or global search, often combined with vector or text search.
* **Query processing:** Baseline RAG sends a single query to the vector index, while GraphRAG follows a multi-step process that interprets the query, selects a subgraph, and may generate graph queries such as Cypher.
* **Context assembly:** Baseline RAG provides top-k chunks by similarity, while GraphRAG assembles a subgraph, community summaries, and linked documents aligned to the question.
* **Reasoning:** Baseline RAG is limited to reasoning within the retrieved chunk, whereas GraphRAG enables relational reasoning across connected facts and summaries.
* **Explainability:** Baseline RAG makes it difficult to trace why a chunk was retrieved, while GraphRAG offers traceable paths and nodes that support each answer.

## What is a knowledge graph in GraphRAG?

A knowledge graph is a structured representation of information in which entities are stored as nodes and the connections between them are relationships. 

The nodes don’t always represent the same thing. Each one can represent a different document, concept, or data point. The relationships tell you how these nodes are linked. All of this helps genAI use better context to generate its answers.

Next, we will look at common use cases where GraphRAG shines.

## What are common use cases for GraphRAG?

GraphRAG is ideal in domains where the answers must be based on structured relationships and context.

Let’s see some examples:

* **Advanced chatbots:** GraphRAG helps chatbots deliver more relevant responses through a better-established context from linked sources.
* **Answering complex queries:** GraphRAG contributes significantly to handling queries that span multiple topics, such as linking research findings across disciplines.
* **Financial services:** This industry has arguably the most use for GraphRAG, which can help connect company data, market trends, and regulatory filings to support investment analysis.
* **Healthcare research:** In healthcare, GraphRAG contributes to research by linking patient records, studies, and treatment outcomes for more informed recommendations.
* **Legal document analysis:** In the legal domain, GraphRAG helps map case law, statutes, and prior rulings to answer legal questions with supporting references.
* **Scientific knowledge exploration:** This is another use case involving connecting datasets, experiments, and literature to build hypotheses.

These use cases highlight the variety and potential influence of GraphRAG when applied correctly. 

Moving on, we will review tools that can help you implement it.


## What tools are available for implementing GraphRAG?

We already know that GraphRAG tools are designed to manage knowledge graphs, retrieve relevant nodes and documents, and integrate with LLMs for generation. 

But, depending on the goal, you may need a graph database, a fast search engine, or an orchestration framework.

[RAG tools](https://www.meilisearch.com/blog/rag-tools) commonly used in Graph RAG applications include:

* **Meilisearch:** Our fast, developer-friendly search engine that can serve as the initial retrieval layer before graph traversal.
* **LangChain:** A framework for chaining retrieval and generation components, with support for graph-based workflows.
* **Weaviate:** An open-source vector database with built-in support for knowledge graphs, allowing you to combine semantic search with graph-based retrieval.
* **FAISS:** A high-performance library for efficient similarity search across large-scale embeddings, often used alongside graphs to speed up relevant information retrieval with specialized algorithms.
* **Haystack:** A flexible framework for building end-to-end RAG pipelines, including integration with graph databases and LLMs.
* **Neo4j:** A widely used graph database that supports Graph RAG approach implementations.
* **GitHub repositories:** Many generative AI examples of GraphRAG can be found on GitHub, shared by both independent developers and enterprise providers like Microsoft or OpenAI.

The right combination of tools depends on the format your data sources, scale, and reasoning needs. 

Now, it’s time to go through the steps to implement GraphRAG.

## How to implement GraphRAG

GraphRAG follows a relatively simple pattern involving fast text indexing, building a graph of entities and links, and retrieving a focused subgraph before LLM generation uses that structure.

Here’s a practical path [you can build](https://www.meilisearch.com/blog/how-to-build-rag):


### 1. Prepare data and set up Meilisearch

The first step ingests documents, normalizes fields, and creates fast text and filter search.

Fast recall ensures the graph only has to operate over a smaller, high-relevance subset of documents instead of the entire dataset, which keeps queries efficient.


```python
# Install Meilisearch client
# pip install meilisearch
from meilisearch import Client
client = Client("http://127.0.0.1:7700", "MASTER_KEY")

# Create an index and add documents
idx = client.index("docs")
docs = [
  {"id":"r1","title":"AML report 2024","body":"Acme Ltd acquired Nova Bank in 2021."},
  {"id":"r2","title":"Filing 10-K","body":"Nova Bank operates in New York."}
]

# Add docs and make title filterable
idx.add_documents(docs)
idx.update_settings({"filterableAttributes":["title"]})
```


**Note:** `update_settings` is asynchronous. In production, you’d check the task status before searching. Otherwise, results may not be immediately available.

Next, use these docs to build the graph.


### 2. Build the knowledge graph

Step two involves extracting entities and relationships and storing nodes and edges in a database or in-memory graph.

Unlike flat text, a knowledge graph preserves the relationships between entities (who did what, where, when) giving the LLM structured context for reasoning.


```python
import spacy
nlp = spacy.load("en_core_web_sm")

text = "Acme Ltd acquired Nova Bank in 2021. Nova Bank operates in New York."
doc = nlp(text)

# Extract entities
entities = [{"id": ent.text, "type": ent.label_} for ent in doc.ents]

# For simplicity, define relations manually
relations = [
    ("Acme Ltd", "ACQUIRED", "Nova Bank"),
    ("Nova Bank", "OPERATES_IN", "New York")
]

# Connect to Neo4j
from neo4j import GraphDatabase
driver = GraphDatabase.driver("bolt://localhost:7687", auth=("neo4j", "password"))

# Insert entities and relations
def add_entities_and_relations(entities, relations):
    with driver.session() as session:
        for e in entities:
            session.run(
                "MERGE (n:Entity {name: $name, type: $type})",
                name=e["id"],
                type=e["type"]
            )
        for src, rel, dst in relations:
               # Ensure relation label is safe before using it
               session.run(
                     f"""
                MATCH (a:Entity {{name: $src}}), (b:Entity {{name: $dst}})
                MERGE (a)-[r:`{rel}`]->(b)
                """,
                src=src, dst=dst
            )
add_entities_and_relations(entities, relations)
```


**Note:** In practice, you’d extract relations automatically (e.g., using dependency parsing or an IE model). Here they’re hard coded for clarity.


### 3. Connect retrieval to the graph

This step takes the user query, does fast recall in Meilisearch, maps results to entities, and expands the subgraph.

This step ensures the LLM sees only the relevant neighborhood of connected entities, reducing noise and making the answer more precise.


```python
q = "Who owns Nova Bank and where do they operate?"
hits = idx.search(q, limit=5)["hits"]

# Map results to seed entities (here done manually, but usually via NER/metadata)
seed_entities = ["Nova Bank"]

with driver.session() as session:
    graph_results = session.run("""
        MATCH (n:Entity {name: $name})-[r]-(m)
        RETURN n.name AS source, type(r) AS relation, m.name AS target
        LIMIT 50
    """, name=seed_entities[0])

edges = [dict(record) for record in graph_results]
print("Retrieved edges:", edges)
```


Next, pack the right context for generation.


### 4. Assemble context and generate with the LLM

This step summarizes nodes, edges, and linked passages. It builds a compact prompt that shows content and relationships.

The assembled context presents both the facts and their links, so the LLM can generate an answer that reflects not just content but relationships.


```python
context = {
    "nodes": entities,
    "edges": [{"src": e["source"], "rel": e["relation"], "dst": e["target"]} for e in edges],
    "supporting_text": [hit["body"] for hit in hits]
}

prompt = f"""
Question: {q}
Graph nodes: {context['nodes']}
Graph edges: {context['edges']}
Supporting text: {context['supporting_text']}
Answer with cited nodes and edges.
"""

# Example with OpenAI
from openai import OpenAI
client = OpenAI()  # expects OPENAI_API_KEY in environment

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}]
)

print(response.choices[0].message.content)
```


Moving to the final step, we will measure quality and tighten the loop.


### 5. Evaluate and improve

The final step involves checks for grounding, novelty, and path coverage. It adds caching, reranking, and guardrails.


```python
# Feedback storage
feedback_log = []
CONFIDENCE_THRESHOLD = 0.7

# Logging query feedback
def log_query_feedback(query, answer, confidence, missing_entities=None):
    feedback_log.append({
        "query": query,
        "answer": answer,
        "confidence": confidence,
        "missing_entities": missing_entities or []
    })

# Confidence / gap detection
def needs_expansion(entry):
    return (
        entry["confidence"] < CONFIDENCE_THRESHOLD
        or len(entry["missing_entities"]) > 0
    )

# Auto-expand graph
def auto_expand_graph(missing_entities):
    for entity in missing_entities:
        # Placeholder: implement recall + entity extraction
        docs = search_index(entity)
        for doc in docs:
            entities, relations = extract_entities_relations(doc["content"])
            upsert_graph(entities, relations)

# Feedback loop runner
def run_feedback_loop():
    for entry in feedback_log:
        if needs_expansion(entry):
            auto_expand_graph(entry["missing_entities"])
```


Evaluation closes the loop: it helps detect missing entities, reduce latency, and keep answers grounded and reliable.

**Note:** `search_index`, `extract_entities_relations`, and `upsert_graph` are placeholders. In a real pipeline, you’d implement these functions to query Meilisearch, run NER/RE, and insert results into Neo4j.


## Key takeaways on building with GraphRAG

GraphRAG brings structure and reasoning to retrieval-augmented generation, improving accuracy, context, and explainability. Combining a knowledge graph with a fast search layer gives LLMs the context they need to deliver better answers – a crucial step toward [mastering RAG](https://www.meilisearch.com/blog/mastering-rag).

What is GraphRAG: Complete guide [2025]

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 large language models (LLMs) to handle more complex 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 information 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 AI model. This ensures that accurate responses are generated consistently.

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 chatbot 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, leveraging tool use and automation to improve results.

## 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 user query. Then, if needed, it breaks it down into sub-tasks.
2. **Planning retrieval:** The agent decides which data sources to consult and in what order, be they structured databases, document collections, or APIs.
3. **Context retrieval:** The relevant documents 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 data 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 data 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 with multi-agent systems coordinating tasks.

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 complex 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.
* **Multimodal applications:** Agentic RAG integrates text, images, and structured data for real-time data analysis in media and research contexts.

By adapting retrieval to domain-specific needs, agentic RAG improves the reliability and usability of artificial intelligence 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.
* **Smarter routing:** Agents determine which sources or external tools to consult, reducing noise and improving function selection.

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 retrieved 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 retrieval 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 external 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 through embedding-based methods. 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 training 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 information and organizes it 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 systems use 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 RAG agents that think before they answer. 

That added deliberation may cost more computing and complexity. Still, it sets the foundation for agentic 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).

Meilisearch latest news and company updates