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 relevant responses in real-world applications.

Why do we need them?

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

When the system cannot surface the right information, users lose trust, and your model 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 DBs, 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 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 results, some good and some not so good. Reranking is the process of reordering results so the most relevant chunks rise to the top before being passed to the LLM.

Here are a few common approaches to reranking:

* **Cross-encoder reranking:** Feeds the 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 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 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 content.
* **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 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 retrieval. It reformulates vague or underspecified queries so the system can better understand intent and return more relevant results. This is especially helpful when dealing with short or typo-heavy queries.

Most modern systems use various approaches 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 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 output. Context distillation helps the model stay focused and accurate when it comes to 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 data to understand better the type of responses you want. 

It’s useful when prompts alone can’t guide the model well enough, especially in regulated industries or niche domains.

* **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 retrieval. Fine-tuning them means reshaping how the system ‘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 generation, setting the foundation for a high-performing, domain-aware RAG system.


## What are advanced RAG techniques?

Advanced RAG techniques go beyond the basics of RAG. 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 systems 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 RAG 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 perfect for implementing advanced RAG pipelines. It supports customizable ranking rules and handles large document collections easily. 

You can implement hybrid search (combining keyword and vector relevance) using Meilisearch’s [hybrid search plugin](https://www.meilisearch.com/solutions/hybrid-search). This balances semantic 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) 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 retrieval smarter, not just faster. They help systems move beyond brute-force search toward context-aware retrieval that scales across domains. 

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

9 advanced RAG techniques to know & how to implement them

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

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

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

## The problem of hallucination and limited context

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

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

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

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

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

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

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

The RAG workflow typically involves three key steps:

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

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

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

## The tools: full-text and semantic search

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

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

The best of both worlds is

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

### When is semantic search better?

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

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

### When is full-text search better?

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

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

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

## How to combine the results: hybrid search scoring

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

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

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

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

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

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

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

## Benefits of hybrid search: precision and recall

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

Imagine you have an email spam filter:

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

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

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

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

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

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

### Hybrid search and precision-recall

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

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

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

## Optimizing performance: binary quantization and arroy

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

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

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

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

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

## Explore Meillsearch’s capabilities today! 

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

Ready to supercharge your RAG system with unparalleled search relevance? 

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

Mastering RAG: unleashing precision and recall with Meilisearch's hybrid search

How do you search in a database with LLMs?

Picture a customer support agent who can simultaneously analyze a blurry screenshot, decipher a frustrated voice message, and cross-reference technical documentation to deliver the perfect solution.

Traditional RAG systems have transformed AI’s ability to retrieve and process text. However, they struggle when customers interact using images, audio, or video.

Multimodal RAG shatters this limitation by creating unified vector spaces where a single query can pull insights from any combination of data types, transforming how we build intelligent applications. The result isn't just better search, it's AI that finally understands the world as humans experience it.

## What is multimodal RAG?

Life doesn’t provide information in neat, single streams. When troubleshooting a complex machine, you don’t just read a manual—you scan diagrams, listen to a technician’s voice note, and watch a video of the problem. Traditional search and AI systems, designed for text alone, often struggle with this mix.

### Understanding multimodal retrieval-augmented generation

Each piece is converted into a vector, a mathematical fingerprint. These vectors exist in a high-dimensional space, where connections form by capturing meaning across different formats, not just matching words.

For example, in customer support, a user might upload a blurry photo of an error screen, describe the issue in chat, and attach an audio clip of a strange noise. A multimodal RAG system retrieves relevant troubleshooting steps from a knowledge base containing annotated images, audio samples of faults, and text documents. It then crafts a response using all three sources.

### Key differences between multimodal RAG and traditional RAG

Traditional RAG systems work like expert librarians who only read books—great with text but unable to process other formats. Multimodal RAG acts like a detective: it reads, listens, and observes, piecing together clues from all sources.

- **Data types:** Traditional RAG handles only text. Multimodal RAG processes images, audio, video, and text simultaneously.
- **Embedding space:** Multimodal RAG projects all data types into a shared vector space, allowing a text query to retrieve images or audio clips.
- **Retrieval power:** It supports “any-to-any” retrieval. For example, a voice query can bring up a diagram, or a photo can retrieve a relevant manual paragraph.

In healthcare, multimodal RAG can analyze an X-ray, doctor’s notes, and a patient’s spoken symptoms together. Traditional RAG would only process the written report.

## How multimodal RAG works

Multimodal RAG works like a jazz ensemble: each part contributes its unique input, combining to create richer results than any single source alone. Imagine yourself as a developer building a search system that handles words, images, audio, and video seamlessly.

### The three stages of multimodal RAG: retrieval, fusion, and generation

![rag pipeline architecture diagram](https://unable-actionable-car.media.strapiapp.com/rag_pipeline_architecture_diagram_56e14cbdbd.avif)



While a text-only RAG system might struggle, a multimodal RAG pipeline handles the variety of data effectively through three stages:

1. **Embedding:** Before retrieval begins, the system preprocesses each input (whether text, image, audio, or video) by encoding it into a vector representation using [powerful multimodal embedding models](https://meilisearch.com/blog/choosing-the-best-model-for-semantic-search). These [embeddings](https://meilisearch.com/blog/what-are-vector-embeddings) capture the semantic and contextual essence of every asset to enable meaningful comparisons across data types.
2. **Storing:** Once the embeddings are created, they are stored in a [vector database](https://meilisearch.com/blog/what-is-a-vector-database) (like Meilisearch, FAISS, Milvus, or Pinecone) alongside document metadata or links to the original files. This step ensures that multimodal data can be efficiently indexed and retrieved by similarity, regardless of modality.
3. **Retrieval:** The system converts each query into a vector. It compares these vectors against a large library of encoded data. For example, Meilisearch stores and retrieves vectors for images, audio, and text. This allows a search like “a red button with a blinking light” to return both textual guides and annotated photos.
4. **Fusion:** After retrieval, the system combines information from different modalities. Cross-modal attention mechanisms align the meaning of a spoken description with visual details in a photo or technical language in a manual. This stage matches nuances, like pairing the melody of a song with the mood of a painting.
5. **Generation:** An LLM synthesizes a response using the fused context. The output might be a step-by-step troubleshooting guide referencing the user’s photo and a technical manual, or a property description blending listing photos with sales data.

**This process enables multimodal RAG to answer complex questions that text-only systems cannot.**

### Exploring the role of embeddings in multimodal search

Embeddings act as universal translators, converting text, images, audio, and video into points in a shared mathematical space. This allows a voice query to retrieve a relevant image or a photo to surface a matching product description.

Embeddings also excel in [federated search](https://meilisearch.com/blog/what-is-federated-search) scenarios. A query can merge results from image and text indexes, normalizing relevancy scores across modalities.

<Callout intent="note">
	
Meilisearch supports [user-provided embeddings](https://www.meilisearch.com/docs/learn/ai_powered_search/search_with_user_provided_embeddings), letting you use models like CLIP or LLaVA to generate vectors externally and index them with your documents.
	
Meilisearch’s hybrid search combines semantic similarity (via embeddings) with classic keyword matching. This ensures a search for “blue running shoes” returns both visually similar products and those with matching descriptions. **This approach creates a search experience that feels intuitive and precise, improving recall and relevance.**
	
</Callout>

## Building a multimodal RAG pipeline

Every strong system starts with a solid foundation. Building a multimodal RAG pipeline is more like conducting a jazz ensemble than laying bricks. Each data modality brings its own unique tone. The real value comes from how they interact.

Let’s explore the practical choreography of data, models, and search, where every step depends on trade-offs and the quirks of your data.

### Data preparation for multimodal RAG: preprocessing and embedding

Imagine a SaaS company with a vast knowledge base: product manuals in PDF, customer screenshots, audio logs from support calls, and video tutorials. The first challenge isn’t technical; it’s understanding the stories these artifacts tell and translating them into a language your AI can grasp.

- **Text:** Clean text and break into passages, then use a model like BERT or a sentence transformer to embed the text as vectors:

```python
from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
passages = ["How to reset your dashboard", "Uploading CSV errors"]
# if saving to JSON:
vectors = model.encode(passages).tolist()
```

- **Images:** Convert images (screenshots, diagrams) into L2-normalized embeddings using CLIP (be sure to specify 'device' as a named argument):

```python
import clip
from PIL import Image
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)
model.eval()  # set eval mode

img = preprocess(Image.open("error_screenshot.png")).unsqueeze(0).to(device)
with torch.no_grad():
    emb = model.encode_image(img)
    emb = emb / emb.norm(dim=-1, keepdim=True)  # L2-normalize
# emb is a (1, 512) normalized tensor, ready for search/indexing
```

- **Audio:** Transcribe and embed support calls using Wav2Vec, making sure to move data to GPU (if available), and aggregate final features with mean-pooling and normalization:

```python
import torchaudio
import torch
from transformers import Wav2Vec2Processor, Wav2Vec2Model

device = "cuda" if torch.cuda.is_available() else "cpu"
processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-base-960h")
model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h").to(device)
model.eval()

waveform, rate = torchaudio.load("call.wav")  # [channels, samples]
inputs = processor(waveform.squeeze().numpy(), sampling_rate=rate, return_tensors="pt")
inputs = {k: v.to(device) for k, v in inputs.items()}

with torch.no_grad():
    hidden_states = model(**inputs).last_hidden_state    # (1, seq_len, hidden_size)
    audio_emb = hidden_states.mean(dim=1)                # (1, hidden_size)
    audio_emb = audio_emb / audio_emb.norm(dim=-1, keepdim=True)
# audio_emb is a pooled, normalized vector for each utterance
```

- **Video:** Extract informative frames, embed each with CLIP (as above). For summary-level retrieval, generate a transcript using an ASR engine and embed as text.

<Callout intent="tip">
	
	Automate enrichment (like tagging, timestamping, linking images to passages) as early as possible in the pipeline.
	
</Callout>

### Setting up the retrieval system: indexing and search optimization with Meilisearch

After embedding, leverage Meilisearch for unified indexing and rapid hybrid querying:

**1. Upload the documents with user-generated embeddings**:Each vector should be stored alongside its respective document.

```bash
curl -X POST 'http://localhost:7700/indexes/support_docs/documents' 
  -H 'Content-Type: application/json' 
  --data-binary @support_docs_with_embeddings.json
```

Each document in `support_docs_with_embeddings.json` should include a field like:

```json
{
  "id": "IMG_0474",
  "type": "image",
  "metadata": { "description": "error screenshot" },
  "vector": [0.348, 0.123, 0.582, ...]
}
```

**2. Configure a vector field in Meilisearch**Define your vector field in `vectorIndexes` (typical for Meilisearch ≥ v1.2):

```bash
curl -X PATCH 'http://localhost:7700/indexes/support_docs/settings' 
  -H 'Content-Type: application/json' 
  --data-binary '{
    "vectorIndexes": {
      "vector": {
        "type": "hnsw",
        "params": { "M": 8, "efConstruction": 64 }
      }
    }
  }'
```

**3. Prepare a hybrid search request:**

```bash
curl -X POST 'http://localhost:7700/indexes/support_docs/search' 
  -H 'Content-Type: application/json' 
  --data-binary '{
    "q": "dashboard spinning wheel",
    "vector": [0.032, 0.89, ...],
    "limit": 10
  }'
```

For pure vector search (no keyword text), pass `q` as an empty string:

```bash
curl -X POST 'http://localhost:7700/indexes/support_docs/search' 
  -H 'Content-Type: application/json' 
  --data-binary '{
    "q": "",
    "vector": [0.032, 0.89, ...],
    "limit": 10
  }'
```

For hybrid search using Meilisearch's internal embedder:

```bash
curl -X POST 'http://localhost:7700/indexes/support_docs/search' 
  -H 'Content-Type: application/json' 
  --data-binary '{
    "q": "dashboard spinning wheel",
    "hybrid": {
      "embedder": "your-embedder-name",
      "semanticRatio": 0.5
    },
    "limit": 10
  }'
```

<Callout intent="note">
	
	Meilisearch provides official SDKs and client libraries for most major programming languages and frameworks.
	
</Callout>

### Integrating the generation component: prompt engineering and model selection

With your most relevant (multimodal) evidence in hand, prepare a coherent prompt for your LLM. Here’s an illustrated example:

```python
# 1) retrieve (using SDK to make code shorter)
query_emb = embed_query(user_question)
results = meili.index("support_docs").search({
  "vector": query_emb,
  "limit": 5
})
# 2) build the context
context = "nn".join([hit["text"] for hit in results["hits"]])

# 3) call the LLM
prompt = f"""You are a helpful assistant. Use ONLY the following context to answer.

Context:
{context}

Question: {user_question}
Answer:"""

response = openai.ChatCompletion.create(
  model="gpt-4",
  messages=[{"role":"user","content":prompt}]
)
print(response.choices[0].message.content)
```

Order evidence for clarity (text → image → other media), trim any irrelevant details, and iteratively refine your prompt template for optimal results.

<Callout intent="tip">

Ready to supercharge your search experience? Deliver lightning-fast search results that will keep your users engaged and boost your conversion rates. 

[Explore Meilisearch Cloud](https://meilisearch.com/cloud)

</Callout>

## Choosing the right vector database for your multimodal application

Selecting a vector database is like picking the right vehicle for a cross-country journey. The terrain—your data, queries, and latency needs—guides the best choice. Here’s a quick comparison:

- **Meilisearch:** Combines [full-text and vector search](https://meilisearch.com/blog/full-text-search-vs-vector-search). Great for ecommerce, web apps, [enterprise search](https://meilisearch.com/blog/enterprise-search), and hybrid user experiences.
- **FAISS:** Blazing-fast, highly customizable, supports C++/Python. Ideal for research and large-scale retrieval.
- **Milvus:** Scalable, cloud-native, supports hybrid search. Suited for enterprise, IoT, and video search.
- **Pinecone:** Managed service, easy scaling, metadata filtering. Fits SaaS and production deployments.

A SaaS team building real-time product search might choose Meilisearch for its hybrid capabilities and developer-friendly API. A research lab processing petabytes of scientific images could rely on FAISS for its speed and flexibility. The decision shapes what’s possible for your users.

## Multimodal RAG: unlocking the future of intelligent, human-like search

Multimodal RAG represents more than just a technical advancement. It's a fundamental shift toward AI systems that understand information the way humans do, across all formats and contexts.

With Meilisearch's vector search capabilities and sub-20ms response times, you can start building these sophisticated multimodal experiences today.

The future of search isn't just about finding information; it's about understanding it completely, and that future is already within reach.



Multimodal RAG: A Simple Guide

Most developers spend weeks building retrieval systems from scratch, wrestling with vector databases and embedding models, only to discover their LLM still hallucinates answers.

The irony? While everyone talks about RAG as the solution to grounding AI responses in real data, the implementation complexity often defeats the purpose entirely.

[LlamaIndex](https://www.llamaindex.ai/) changes this equation by collapsing what used to be a month-long engineering project into a few dozen lines of code, without sacrificing the sophistication that makes retrieval-augmented generation actually work. Instead of building infrastructure, you can focus on what matters: turning your company's knowledge into intelligent, accurate responses that your users can trust.

## Understanding LlamaIndex and RAG for advanced search applications

LLMs are great at generating text, but they can make mistakes or use outdated info. RAG fixes this by connecting language models to up-to-date, relevant data.

### Introducing LlamaIndex: your toolkit for building RAG pipelines

If RAG is the strategy for smarter LLM applications, LlamaIndex is the toolkit that makes it happen. Building a [RAG system](https://www.meilisearch.com/blog/how-to-build-a-rag-pipepline) is like preparing a gourmet meal: you need quality ingredients (your data), the right tools (to process and understand that data), and a recipe (the workflow). LlamaIndex provides all of this.

Formerly GPT Index, LlamaIndex is an open-source framework that simplifies building RAG systems. It offers components that manage your data’s journey, from ingestion to indexing to integration with LLMs for answer generation.

### Core components of a LlamaIndex RAG system: from raw data to smart answers

![rag pipeline architecture diagram](https://unable-actionable-car.media.strapiapp.com/rag_pipeline_architecture_diagram_56e14cbdbd.avif)



Turning a raw document into a context-aware answer with LlamaIndex follows five clear stages:

- **Loading:** Bring your data into the system. LlamaIndex supports many document loaders, making it easy to import PDFs, text files, websites, APIs, and more.
- **Indexing:** Convert loaded documents into [vector embeddings](https://meilisearch.com/blog/what-are-vector-embeddings), numerical representations capturing the meaning of your text. This helps find relevant information even if queries use different words.
- **Storing:** Save your index and metadata to avoid reprocessing large datasets every time you start your application.
- **Querying:** When a user asks a question, LlamaIndex transforms the query into an embedding and searches the indexed data for the most relevant text chunks. It can also apply [advanced search strategies](https://meilisearch.com/blog/introducing-hybrid-search) to improve results.
- **Generation:** The retrieved context and user query go to an LLM, which crafts a human-like answer grounded in your specific data.

**This workflow ensures the LLM always accesses precise, relevant information.**

### Key benefits of using LlamaIndex for RAG development

Using LlamaIndex for RAG projects streamlines development. It simplifies complexity by abstracting data connection, transformation, and retrieval details. This lets developers build sophisticated RAG applications with less boilerplate code.

LlamaIndex’s modular design lets you swap components—embedding models, vector stores, or LLMs—to fit your needs and budget. This flexibility is crucial as AI technology evolves.

For tech leaders and developers, this means faster iteration, more reliable applications, and the ability to deliver intelligent, data-driven experiences.

## Building your foundational LlamaIndex RAG pipeline: a step-by-step guide

Let’s build a LlamaIndex RAG system that answers questions using your own documents. We’ll go step by step, from project setup to asking your first queries. This guide uses Meilisearch documentation files as an example, but you can apply these steps to any documents.

### Setting up your development environment for a LlamaIndex RAG project

Start by preparing a Node.js environment. Make sure you have **Node.js version 18 or higher (20+ recommended)**. Check your version with:

```bash
node -v
```

Create a new project directory and initialize it:

```bash
mkdir rag-tutorial
cd rag-tutorial
npm init -y
```

This creates a folder named `rag-tutorial`, moves you into it, and sets up a basic Node.js project.

Update your `package.json` to use modern JavaScript modules and TypeScript. It should include:

- `"type": "module"` for ES module syntax
- Scripts to run TypeScript files with `tsx`

Example:

```json
{
  "name": "rag-tutorial",
  "version": "1.0.0",
  "type": "module",
  "main": "rag-llamaindex.ts",
  "scripts": {
    "start": "tsx rag-llamaindex.ts",
    "interactive": "tsx interactive-rag.ts",
    "test-setup": "tsx test-setup.ts"
  }
}
```

Install the necessary npm packages:

```bash
npm install llamaindex @llamaindex/openai @llamaindex/readers dotenv tsx
```

<Callout intent="note">
	
	Starting with Node.js v23.6.0, developers can run TypeScript files directly without manual transpilation. This feature became default in v24.1.0.
	
	
</Callout>

Each package serves a purpose:

- `llamaindex`: Core LlamaIndex.TS library
- `@llamaindex/openai`: Connects to OpenAI models for text generation and embeddings
- `@llamaindex/readers`: Tools for reading data from various sources, including `SimpleDirectoryReader`
- `dotenv`: Loads environment variables from a `.env` file to keep API keys secure
- `tsx`: Runs TypeScript files directly in Node.js

Set up your OpenAI API key by creating a `.env` file in your project root:

```text
OPENAI_API_KEY=your_actual_openai_key_here
```

Replace the placeholder with your real key to keep credentials private.

Create folders for your data and index storage:

```bash
mkdir data storage
```

- `data` will hold your documents
- `storage` will save the processed index

Add a `tsconfig.json` file for TypeScript configuration:

```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "ESNext",
    "moduleResolution": "node",
    "allowSyntheticDefaultImports": true,
    "esModuleInterop": true,
    "strict": true,
    "skipLibCheck": true
  }
}
```

With this setup, your environment is ready. Next, bring in your data.

### Ingesting and loading diverse data sources effectively with LlamaIndex

Now, feed your LlamaIndex RAG system some knowledge. For this tutorial, we use Markdown (`.mdx`) files from Meilisearch documentation, but you can use PDFs, web pages, or database entries.

Copy your `.mdx` files into the `data` directory. For example:

```bash
# Copy documentation files to data directory
# find ../documentation -name "*.mdx" -exec cp {} ./data/ ;
```

Ensure your `data/` folder contains the files you want to index.

Use `SimpleDirectoryReader` from `@llamaindex/readers/directory` to read these files. In your main TypeScript file (e.g., `rag-llamaindex.ts`), import and use it like this:

```typescript
import "dotenv/config";
import { SimpleDirectoryReader } from "@llamaindex/readers/directory";

const reader = new SimpleDirectoryReader();
const documents = await reader.loadData("./data");
console.log(`📄 Loaded ${documents.length} documents.`);
```

Each file becomes a `Document` object containing its content and metadata.

LlamaIndex supports many data formats. You can combine multiple sources into a single index to create a comprehensive knowledge base.

With your documents loaded, you’re ready to index them.

### Indexing data for optimal retrieval: creating your first LlamaIndex vector store

Make your documents searchable by meaning, not just keywords. Vector indexing organizes text using numerical vectors that capture semantic meaning.

Set it up like this:

```typescript
import { VectorStoreIndex, storageContextFromDefaults, Settings } from "llamaindex";
import { openai, OpenAIEmbedding } from "@llamaindex/openai";
```

- `VectorStoreIndex`: Manages the vector index
- `storageContextFromDefaults`: Handles where your index is saved
- `Settings`: Configures language and embedding models
- `openai` and `OpenAIEmbedding`: Set up OpenAI’s LLM and embedding models

Configure your models:

```typescript
Settings.llm = openai({ 
  model: "gpt-4o",
  temperature: 0.0,
  maxTokens: 1024
});

Settings.embedModel = new OpenAIEmbedding({
  model: "text-embedding-ada-002",
});
```

This setup ensures **factual, focused answers and efficient embeddings**.

Build your index with:

```typescript
console.log("🔄 Creating vector embeddings... (this may take a few minutes)");
const storageContext = await storageContextFromDefaults({ persistDir: './storage' });
const index = await VectorStoreIndex.fromDocuments(documents, { storageContext });
console.log("💾 Index built and saved to storage.");
```

This process:

- Splits documents into smaller chunks for better retrieval
- Converts each chunk into a vector using the embedding model
- Stores vectors and text chunks in the index
- Saves the index to the `./storage` directory for future use

Depending on your data size, this may take a few minutes. Once done, your system can answer questions.

<Callout intent="success">
Looking for the best search experience in town? Deliver lightning-fast search results that will keep your users engaged and boost your conversion rates.
[Explore Meilisearch Cloud](https://meilisearch.com/cloud)
</Callout>

### Implementing the query engine and generating responses with your basic LlamaIndex RAG

With your data indexed, ask questions and get intelligent answers. LlamaIndex’s query engine handles this smoothly.

Get your `VectorStoreIndex` and create a query engine:

```typescript
const queryEngine = index.asQueryEngine({ 
  similarityTopK: 5
});
```

The `similarityTopK` parameter controls how many relevant chunks the engine retrieves per query.

Ask a question like this:

```typescript
const question = "What is Meilisearch and what are its main features?";
const result = await queryEngine.query({ query: question });

console.log("📖 Answer:");
console.log(result.toString());
```

Behind the scenes:

- Your question converts into a vector
- The engine finds the most relevant document chunks
- These chunks form the context
- LlamaIndex builds a prompt including your question and context
- The LLM generates an answer grounded in your data
- The answer is returned and displayed

Here is an example of the final result against the Meilisearch documentation:

![untitled](https://unable-actionable-car.media.strapiapp.com/untitled_361dc96a33.gif)



This ensures **answers are accurate and based on your documents, not just the LLM’s pre-trained knowledge**.

Now you have a working LlamaIndex RAG pipeline. Next, let’s improve efficiency for repeated use.

### Persisting and efficiently reusing your LlamaIndex for subsequent RAG operations

LlamaIndex can persist the index, saving time and cost. Indexing involves chunking documents and making API calls for embeddings, which can be resource-intensive. You don’t want to repeat this every time you run your app.

Persistence uses `storageContext` and a `loadOrBuildIndex` function. When building the index:

```typescript
const storageContext = await storageContextFromDefaults({ persistDir: './storage' });
const index = await VectorStoreIndex.fromDocuments(documents, { storageContext });
```

This saves the index to `./storage`.

On later runs, try loading the saved index first:

```typescript
try {
  const storageContext = await storageContextFromDefaults({ persistDir: './storage' });
  const index = await VectorStoreIndex.init({ storageContext });
  console.log("✅ Loaded existing index from storage.");
} catch (error) {
  console.log("📚 Building new index from documentation files...");
  // ...build logic
}
```

If a saved index exists, it loads instantly—no need to reprocess documents or embeddings.

Benefits include:

- **Cost savings** by avoiding repeated embedding API calls
- **Time savings** since loading is faster than rebuilding
- **Efficiency** as heavy processing happens only once
- **Automatic management** with minimal effort

This persistence makes your LlamaIndex RAG system practical and efficient, ensuring your initial processing investment pays off over time.

With these steps, you’ve built a foundational LlamaIndex RAG pipeline: from setup and data ingestion to indexing, querying, and efficient reuse. This base is ready for further enhancements as your needs grow.

## Optimizing your LlamaIndex RAG for production-level performance and relevance

You’ve built your foundational LlamaIndex RAG pipeline. Now, refine every step—from data preparation to delivering insights—to maximize performance, relevance, and efficiency. This process requires understanding how all components work together to create a system that is not only smart but truly effective.

### Master advanced data chunking strategies for superior LlamaIndex RAG context

Think of your documents as vast libraries and chunks as the pages or paragraphs your LLM reads. Giving the LLM an entire book for one question is overwhelming, but a single, out-of-context sentence isn’t enough. **Chunking finds the “just right” snippet for effective understanding.**

#### Summary retrieval

Default chunking (around 512 tokens) is a good start, but production systems need more nuance. One effective method is **decoupling retrieval and synthesis chunks**:

- Embed concise summaries of each feature section for broad retrieval.
- When a query matches a summary, pull detailed, sentence-level chunks from that section for the LLM to synthesize the answer.

This approach is like using a table of contents to find the right chapter, then reading specific paragraphs within it.

#### Structured retrieval

**Structured retrieval** adds another layer. If your data has metadata—such as product categories, version numbers, or author tags—use it to narrow the search space before semantic search begins. For example, if a user asks about a feature in “version 3.0,” filter to only v3.0 documents. This pre-filtering makes vector search faster and more focused.

Also, use **dynamic chunk retrieval**. Different questions require different amounts of context:

- Simple factual queries may need only a few small chunks.
- Complex comparative questions benefit from more or larger chunks.

Adjusting the number and size of retrieved chunks based on query complexity ensures the LLM gets the optimal context, improving answers and reducing token usage.

### Enhance LlamaIndex RAG retrieval with reranking and hybrid search techniques

After retrieving candidate chunks using vector similarity (often controlled by `similarityTopK`), the process isn’t complete. Vector search finds semantically similar content, but “similar” doesn’t always mean “most relevant.”

[**Hybrid search**](https://www.meilisearch.com/blog/hybrid-search) **combines semantic search with keyword-based search**. For example, if a user looks for documentation on a specific API error code like “ERR_CONN_RESET_005,” pure vector search might find general connection error documents. A hybrid approach uses the exact error code as a keyword to pinpoint documents containing that string, then applies semantic similarity to understand context. This blend often yields more precise results, especially for queries with specific entities or codes.

Refining the initial set of retrieved chunks is also important. After fetching the top K chunks, you can rerank them based on:

- Direct keyword overlaps.
- Scores from a smaller, faster model assessing relevance to the question.

This ensures the LLM receives the best possible context.

“Multi-step searches” further improve retrieval. An initial query identifies a broad topic or document set, then a focused follow-up query (possibly generated by the LLM) dives deeper into that subset. This coarse-to-fine approach enhances final context quality.

### Select optimal embedding models and LLMs for your specific LlamaIndex RAG use case

Choosing the [right embedding model](https://meilisearch.com/blog/choosing-the-best-model-for-semantic-search) and LLM is like selecting the engine and transmission for a car—it affects performance, cost, and suitability. There is no universal best; it depends on your needs.

Experiment with different embedding models and dimensionality. The `text-embedding-ada-002` model from OpenAI balances performance and cost well.

However, if your data is specialized—such as legal or medical texts—a domain-specific fine-tuned model may perform better. Higher-dimensional embeddings capture more nuance but increase computational and storage costs, so balance is key.

For the generative LLM, `gpt-4o` offers a strong mix of cost and quality. For high-volume, low-latency chatbots, smaller, faster, and cheaper LLMs may be more suitable, even if they sacrifice some response nuance. For complex research or analysis, investing in a top-tier model can be worthwhile. Adjust settings like `temperature` (e.g., `0.0` for factual Q&A) and `maxTokens` to fine-tune behavior and control costs.

Consider an ecommerce example:

- Use a fast, affordable LLM for simple product questions.
- Use a more powerful model and higher `similarityTopK` for complex comparisons.

Conditional model selection optimizes both user experience and operational costs.

### Evaluate your LlamaIndex RAG pipeline with key metrics and benchmarking for success

After refining chunking, retrieval, and model selection, evaluate your system regularly to ensure it performs well.

Focus on these key areas:

- **Retrieval quality**: Are retrieved chunks relevant? Use human evaluation to review top K documents for sample queries and check if they are on-topic and informative.
- **Generation quality**: Are LLM answers accurate, coherent, and faithful to context? Avoid hallucinations. Human judgment is crucial early on.
- **End-to-end performance**: How fast does the system respond? Include embedding, retrieval, and generation time. Latency matters for user-facing apps.
- **Cost-effectiveness**: Track API calls for embeddings and generation. Check if optimizations like chunking or `similarityTopK` tuning reduce costs without hurting quality.

For example, a RAG system helping developers navigate a codebase might succeed if:

- Developers spend less time searching for information.
- Answers to technical questions are more accurate.
- Users provide positive feedback.
- Fewer follow-up questions go to human colleagues.

Benchmark against a “golden dataset” of human-verified question-answer pairs to measure progress. Tweaking components like embedding models, chunk size, or prompts should improve these benchmarks.

## Your next steps in the RAG revolution

Building a production-ready LlamaIndex RAG system transforms how your applications handle knowledge retrieval and generation. It makes it move beyond static responses to dynamic, context-aware interactions with your data.

The combination of LlamaIndex's streamlined development experience with robust production patterns creates a foundation that scales from prototype to enterprise deployment.



LlamaIndex RAG tutorial: step-by-step implementation

Here's a counterintuitive truth about modern AI development: the most sophisticated language models often perform worse than simpler alternatives when deployed in production.

Companies spend thousands of dollars fine-tuning state-of-the-art models, only to discover that a lightweight approach using RAG delivers better results at a fraction of the cost.

The fine-tuning vs RAG debate isn't just about technical preferences. It's about understanding when complexity becomes your enemy and when simplicity scales. Most teams make this choice based on outdated assumptions about what "better AI" actually means in real-world applications.

## Fine-tuning vs RAG: understanding the key differences

Deciding how to adapt a LLM involves choosing between fine-tuning, which builds deep expertise into the model, and Retrieval-Augmented Generation (RAG), which links the LLM to the latest relevant information. Both aim to enhance the LLM’s capabilities but use different approaches.

### What is retrieval-augmented generation?

Imagine a top student, not going back to class, but instead gaining access to an endless, well-organized library and a team of expert researchers. That’s the idea behind RAG.

Instead of embedding all knowledge within the model, RAG lets the LLM pull relevant information from external sources right before responding. These sources can include your company’s knowledge base, real-time news feeds, or large document collections.

![RAG workflow diagram explanation](https://unable-actionable-car.media.strapiapp.com/RAG_workflow_diagram_explanation_53f23eb06c.avif)

RAG works by:

- Breaking external data into manageable pieces and converting each into a numerical “embedding” that captures its meaning.
- Storing these [embeddings](https://meilisearch.com/blog/what-are-vector-embeddings) in a specialized [vector database](https://meilisearch.com/blog/what-is-a-vector-database) designed for fast searches.
- Turning the user’s query into an embedding.
- [Searching the database](https://www.meilisearch.com/blog/how-do-you-search-in-a-database-with-llm) to find the most relevant information.
- Including this retrieved data in the prompt given to the LLM, providing up-to-date, contextual knowledge.
- Having the LLM craft a response using both its built-in understanding and the freshly retrieved information.

<Callout intent="note">
	Keep in mind that RAG responses may take a bit longer to generate as the system needs time to search through external databases and retrieve relevant information before the LLM can craft its response. The exact delay depends on your RAG system's architecture and the size of your knowledge base.	
</Callout>

**RAG grounds responses in specific, current, and verifiable facts, reducing the risk of outdated or inaccurate answers.** It updates knowledge in real time without changing the model itself.

<Callout intent="note">
	Curious about implementing a RAG workflow in practice? Explore this step-by-step guide on [how to build a RAG pipeline](https://www.meilisearch.com/blog/how-to-build-a-rag-pipepline).	
</Callout>

### What is fine-tuning?

Take the same highly educated graduate. Fine-tuning sends him to a specialized training program. You take a pre-trained model and train it further on a smaller, carefully chosen dataset tailored to your field or task. This could include areas such as legal analysis, medical interpretation, or your company’s unique language.

The goal is not just to add facts, but to adjust the model’s internal workings so it becomes an expert in your area. This process involves providing targeted examples and tweaking its internal settings while preserving its broad knowledge. The result is a model that understands the subtle details of its specialty, often improving accuracy significantly.

It is especially powerful for **shaping the model’s output style, tone, and formatting rules**, enabling consistent answers. Fine-tuning also leads to low-latency inference: because curated knowledge is baked directly into the model, there’s no delay from pulling external data.

Additionally, fine-tuned models operate independently of external databases, **providing advantages in privacy, offline capability, and cost-effective serving at scale**. If you need your AI to “think and speak” like an expert, or to deliver high precision on repetitive, clearly defined tasks, fine-tuning delivers that lasting edge.

<Callout intent="note">	
	Looking for an easy way to start fine-tuning your own OpenAI models? Check out [OpenAI’s fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning) for straightforward, step-by-step instructions and best practices to optimize your models for your unique use case.
</Callout>

## Choosing the right approach: fine-tuning or RAG?

Deciding between fine-tuning and Retrieval-Augmented Generation (RAG) means selecting the best tool for your specific challenge. Each method has strengths that fit different scenarios. Consider these key factors to choose the best approach (or a combination) for your project and users.

![](https://unable-actionable-car.media.strapiapp.com/fine_tuning_versus_rag_50c84257a9.avif)

### Data freshness and update frequency

If your AI assistant discusses stable topics like historical events, fine-tuning on curated texts creates a consistent, knowledgeable expert. The information becomes part of the model.

For real-time tasks like stock market analysis or breaking news summaries, the data changes constantly. Fine-tuning would require frequent retraining, which is impractical. RAG excels here by connecting to dynamic external databases. It pulls the latest articles, market data, or updates as they happen. **RAG keeps information current without constant retraining, making it ideal for applications needing up-to-the-minute data.**

### Domain specificity and task complexity

Consider how specialized your AI must be. For a virtual legal aide needing deep contract law knowledge, fine-tuning is best. It helps the model absorb proprietary data, jargon, and reasoning patterns. This creates an expert that understands facts, style, tone, and domain rules.

**Fine-tuning suits tasks requiring high precision in stable, complex fields like medical text interpretation or compliance.**

RAG works well for broader domains or when expertise involves gathering information from many sources. For example, a customer support bot for a fast-changing SaaS product benefits from RAG. It accesses the latest FAQs, troubleshooting guides, and community discussions, providing relevant answers even for new issues.

**RAG focuses on finding the right information rather than becoming the ultimate expert.**

### Cost and resource considerations

Fine-tuning large models demands a significant upfront investment (a bunch of GPU computes time for each training). It also requires careful curation, cleaning, and annotation of high-quality, domain-specific datasets, which can slow progress. However, once fine-tuned, the model runs efficiently without relying on external retrieval.

RAG lowers the barrier to entry by starting with a pre-trained base model. The main costs involve building and maintaining retrieval infrastructure like vector databases and indexing pipelines. While it avoids frequent retraining, ongoing inference costs may be higher due to retrieval steps. Fine-tuned models risk becoming outdated as base LLMs improve, requiring further investment. **RAG offers flexibility and long-term efficiency in fast-changing environments.**

### Data governance and security implications

Data location and access matter, especially in regulated industries or with sensitive information.

Fine-tuning simplifies data governance and privacy. The entire process can stay within your infrastructure, embedding knowledge in the model. Once deployed, it can operate offline without external access. This helps comply with regulations like GDPR or HIPAA and gives tighter data control.

RAG interacts with external knowledge bases, which introduces privacy and security concerns. You must ensure retrieval doesn’t expose sensitive data and that external sources are secure and compliant. Using third-party APIs or databases subjects you to their security and data policies. **RAG requires robust retrieval pipelines and careful data residency and access controls to maintain security.**

### Performance, latency, and scalability

User experience depends on response speed and accuracy. Fine-tuned models deliver **faster responses** because answers come directly from internal knowledge. This low latency suits real-time applications like chatbots or instant translation. Fine-tuned models also offer high precision for trained tasks.

RAG adds a retrieval step before generating responses, which increases delay. Even with fast search engines, RAG responses can be 30-50% slower than fine-tuned models. This delay may be acceptable for detailed reports or research but can hinder real-time use. Scaling RAG requires managing both the LLM and retrieval system, including vector databases and indexing.

## Hybrid approaches: combining fine-tuning and RAG

**Combining fine-tuning and RAG creates a more powerful system** that leverages the strengths of both approaches.

Fine-tuning provides deep domain expertise and specialized language understanding, while RAG ensures access to current, relevant information. This hybrid approach delivers enhanced contextual understanding, improved accuracy, and more nuanced outputs. For example, a financial advisory bot can combine expert knowledge with real-time market data.

**Implementing hybrid systems requires careful design,** beyond simply adding RAG to a fine-tuned model. Emerging strategies include Domain-Adaptive Pre-training (DAP), Retrieval Augmented Fine-Tuning (RAFT), and Hybrid Instruction-Retrieval Fine-Tuning.

Real-world applications, such as Document Retrieval-Augmented Fine-Tuning (DRAFT) for compliance assessment, show promising results with 7% improved correctness over baseline models.

<Callout intent="note">
	Success depends on preventing fine-tuned models from over-relying on internal knowledge while ignoring retrieved information.
</Callout>

## Making the right choice for your AI strategy

The fine-tuning vs RAG decision ultimately comes down to understanding your specific use case, data requirements, and long-term goals.

While fine-tuning excels in static domains requiring deep expertise and consistent outputs, RAG shines when you need dynamic, up-to-date information with transparent sourcing.

Fine-tuning vs RAG: Choosing the right approach

How to build a RAG pipeline: А step-by-step guide

[In Meilisearch v1.6](https://www.meilisearch.com/blog/meilisearch-1-6), we revolutionized search by combining the precision of full-text search with the intelligence of AI. This hybrid approach isn't just another feature—it's a fundamental reimagining of how search should work. Today, we'll pull back the curtain on our implementation and show why Meilisearch's unique approach to hybrid search delivers superior results.

Join us as we explore the mechanics of hybrid search, examine conventional implementation methods, and reveal how Meilisearch's innovative solution raises the bar for search relevance.

## What is hybrid search?

Search is always about finding the documents that are the most relevant to a user’s query.

Hybrid search is about combining the results of two complementary approaches to search: full-text search and semantic search.

[Full-text search](https://www.meilisearch.com/blog/how-full-text-search-engines-work) analyzes the words that appear in a query in a lexical manner, excelling at correcting typos and completing incomplete queries. It is also fast, and its results are easy to understand in retrospect.

[Semantic search](https://www.meilisearch.com/blog/semantic-search) leverages Large Language Model (LLM) technology to understand the meaning of words in the query. It excels at finding documents that contain synonyms to the user’s query and other similar concepts.

Both search approaches build a list of relevant documents according to their respective methods. Hybrid search combines these lists to produce a final list of results.

The golden question is, how to combine them?

![Diagram containing two lists of documents as shapes (squares for full-text, diamonds or triangles for semantic), and an arrow with an interrogation mark that produces a new list of documents containing both kinds of shapes](https://unable-actionable-car.media.strapiapp.com/how_to_merge_55aea77e87.png)

## The traditional way of mixing results is flawed

The traditional method of mixing the results from both lists is called [_Reciprocal Rank Fusion_ (RRF)](https://medium.com/@devalshah1619/mathematical-intuition-behind-reciprocal-rank-fusion-rrf-explained-in-2-mins-002df0cc5e2a), because it considers the **rank** of the documents in each list of results, and uses that as a basis to compute the final list of results.

In this context, the rank of the document refers to its position in the list of results, indicating how close it appears to the top.

For example, in a list of 20 documents, the result ranked first can be attributed 20 points. RRF can then attribute points to documents in each of the lists, sum the points for each document, and reorder the documents accordingly. Here’s a [detailed explanation](https://learn.microsoft.com/en-us/azure/search/hybrid-search-ranking) about an implementation of RRF on Azure AI Search.

However, this method of mixing results is flawed, because to function properly, it assumes that documents from all the lists of results are of comparable relevance: that is, all the documents in all lists are “good documents” that we want to return.

![Keyword search. Pikachu uses "imprecise query". It's super effective!](https://unable-actionable-car.media.strapiapp.com/pikachu_hybrid_search_f4f9e6c29f.jpg)

But, like Pokémons, each search method is vulnerable to different types of search queries. Covering for the weakness of the other method is the whole point of mixing them!

So let’s say you’re using a query that is fine for semantic search, but gives underwhelming results for keyword search. Using RRF, you might get some variant of the following:

![Illustrated example of the downfall of rank fusion](https://unable-actionable-car.media.strapiapp.com/RFF_merge_789ff4e216.png)

Recursive rank fusion is like wasting fine chocolate by mixing it with spoiled milk!

To address this issue, we require additional information about the documents listed in our results.

## Ranking is not enough: Scoring documents

The main idea is that you can score _how_ relevant a document is from 0 (not relevant at all) to 1 ("perfect” match), independently of its rank in the list.

Naturally, documents closer to the top of the list are more relevant, but the first document might be anywhere between 0 and 1. Then, you compare the scores in both lists and rank the documents across both lists that way.

Fortunately, Meilisearch already scores documents for full-text search (for more details about this, refer to [our previous article about scoring](https://www.meilisearch.com/blog/from-ranking-to-scoring)), and semantic search natively ranks documents depending on how similar they are to the query (although the details are complicated).

So we have a score for both full-text search and semantic search, but can we compare them?

## Making the scores comparable

When you have two scores ranging from 0.0 to 1.0, it can be tempting to compare them, but for this to work, similarly relevant documents must be scored similarly with both methods.

One difficulty that arises when performing this comparison is that the models used in semantic search tend to use only a portion of the full vector space they could use, resulting in vectors that have a similarity of at least 0.5 even for texts that appear entirely dissimilar. Furthermore, even very similar texts might be capped in similarity around 0.7, which will cause them to rank lower than good full-text results.

Fortunately, Meilisearch provides the tools to solve that particular problem. Meilisearch allows you to perform an affine transformation to the scores of the semantic search, so that the scores can be offset by the observed mean similarity between vectors, and the results that are packed around that mean similarity can be spread more in the 0.0, 1.0 space. For more details, refer to [the documentation on the](https://www.meilisearch.com/docs/reference/api/settings#distribution) `distribution` [field](https://www.meilisearch.com/docs/reference/api/settings#distribution).

For models known to Meilisearch (such as OpenAI models), a suitable default distribution is already applied to configured embedders, so users don’t have to configure it themselves!

With this operation, our scores are comparable, and depending on the query, the method that produces the most relevant documents will be favored by the hybrid search

![Failing example, running with Meilisearch, yields better results](https://unable-actionable-car.media.strapiapp.com/meili_merge_9bb48a7b7d.png)

## What else goes into making hybrid search right?

Scoring documents is a decisive relevancy advantage of Meilisearch over the traditional approach based on Reciprocal Rank Fusion, but there are a lot more aspects involved in making hybrid search right:

- We developed our bespoke vector store, [arroy](https://github.com/meilisearch/arroy), to leverage our database backend (LMDB) and meet our performance target. Arroy supports Approximate Nearest Neighbor search, multiple distances, native document filters, and binary quantization. Arroy doesn’t block a reader while writing or a writer while reading, and allows for incremental updates.
- We kept flexibility in mind with the mantra of making easy things simple, and hard things possible: users that are new to hybrid search can quickly setup an embedder with our default provider and configuration, but users can also carefully optimize their embedding process with multiple supported provider (or even the ability to provide your own with [REST embedders](https://www.meilisearch.com/docs/learn/ai_powered_search/configure_rest_embedder) and [user-provided embeddings](https://www.meilisearch.com/docs/learn/ai_powered_search/search_with_user_provided_embeddings)) and [document templates](%5B%3Chttps://www.meilisearch.com/docs/learn/ai_powered_search/document_template_best_practices%3E%5D(%3Chttps://www.meilisearch.com/docs/learn/ai_powered_search/document_template_best_practices#sample-document%3E)) to customize how documents are turned into text to embed.
- Best-in-class full-text search engine, seamlessly integrated with semantic search, with support for efficient and expressive [sorting and filtering](https://www.meilisearch.com/docs/learn/filtering_and_sorting/working_with_dates) of documents.

Search is foundational; it needs to be rock solid to reliably serve the needs of your application. Meilisearch’s hybrid search implementation scores documents to merge results while preserving their relevancy. Scores also power the [federated search](https://www.meilisearch.com/docs/learn/multi_search/multi_search_vs_federated_search#what-is-federated-search%3F), a generalized version of semantic search that unifies results from multiple lists of intermediate hits.

Our users use federated search to perform hybrid searches across multiple vector stores, frequently combining image and text search requests.

## Why Meilisearch's hybrid search stands apart

Meilisearch's innovative approach to hybrid search goes beyond simply combining full-text and semantic search results.

By implementing a sophisticated scoring system instead of traditional rank fusion, carefully calibrating score comparability, and building a robust technical foundation with arroy, we've created a hybrid search solution that consistently delivers more relevant results.

This thoughtful implementation ensures that the strengths of each search method are preserved while compensating for their weaknesses, setting a new standard for search relevance in modern applications.

Meilisearch latest news and company updates