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.

Why traditional hybrid search falls short (and how we fixed it)

When we discovered that 70% of our team was already using AI tools daily—but with wildly varying results—we knew we needed a systematic approach. Not another vague "AI transformation" initiative, but a practical framework for separating AI hype from real value.

Here's the concrete system we developed to evaluate and implement AI tools across our company and what we've learned so far.

## The surprising reality we uncovered

When we began our AI journey at Meilisearch, we expected to find pockets of adoption. Instead, we discovered something more interesting: **universal experimentation but inconsistent value**.

### The adoption paradox

Our company-wide assessment revealed that every single team member had already experimented with AI tools, with an impressive 70% incorporating them into daily workflows.

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

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

But the numbers told only half the story:

Despite high adoption rates, team sentiment about AI's value showed surprising variation. Many were using the tools but questioning whether they were truly beneficial or just creating a new kind of busywork.

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

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

This gap between usage and perceived value became our first critical insight.

### Four critical insights that changed our approach

<Callout intent="note">

**Previously Shared Insights:**

- 🧠 [𝐃𝐨𝐞𝐬 𝐀𝐈 𝐛𝐞𝐜𝐨𝐦𝐞 𝐥𝐞𝐬𝐬 𝐯𝐚𝐥𝐮𝐚𝐛𝐥𝐞 𝐚𝐬 𝐲𝐨𝐮𝐫 𝐞𝐱𝐩𝐞𝐫𝐭𝐢𝐬𝐞 𝐠𝐫𝐨𝐰𝐬?](https://www.linkedin.com/posts/gillianmcauliffe_aitransformation-professionalgrowth-futureofwork-activity-7292477225889660928-7UXm/?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAXkmQUBijf17cl9IKQZhMWLN67r9deqvAc) How your relationship with AI changes at different levels of expertise.
- 🔍 [**Unlocking Our AI Knowledge-Sharing Blueprint:**](https://www.linkedin.com/posts/gillianmcauliffe_aitransformation-futureofwork-knowledgesharing-activity-7290061146634485762-fm1D/?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAXkmQUBijf17cl9IKQZhMWLN67r9deqvAc) Understanding what people want to know to get started.
- 🤝 [Preserving Human Connection in an AI-Enhanced Workplace](https://www.linkedin.com/posts/gillianmcauliffe_aitransformation-teamwork-futureofwork-activity-7287036478092632066-boTG/?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAXkmQUBijf17cl9IKQZhMWLN67r9deqvAc): Will we lose what's special about our teams by bringing in AI?

</Callout>

Through in-depth interviews across all departments, we uncovered patterns that wouldn't have appeared in simple usage statistics:

1. 🌿 **Environmental impact:** Our teams have raised thoughtful concerns about the environmental impact of AI.
2. **🤔 The expertise paradox:** As team members' domain expertise increases, their perception of AI's value often follows a U-curve. Beginners find AI helpful for learning, experts leverage it as a powerful accelerator, but those in the middle sometimes find it more hindrance than help.
3. **🎯 The trust dilemma:** AI's "inconsistent brilliance" creates a fundamental trust issue—sometimes transformative, sometimes bafflingly off-target—making teams reluctant to integrate it into mission-critical processes.
4. **✨ Creative acceleration:** Despite skepticism, nearly everyone reported dramatic improvements in creative processes—from eliminating writer's block to transforming editing workflows.
5. 🔭 **Prompt sophistication gap:** Most team members were still using basic prompting techniques, unaware of how dramatically their results could improve with more advanced approaches.

This investigation revealed we weren't facing an adoption problem but a **value extraction challenge**. People were using AI tools but were not consistently getting meaningful results. We needed a framework to help teams identify where AI could actually create value—and where it was just adding complexity.

## ⚖️ Our solution: the AI value scoring matrix

Based on these insights, we developed a systematic framework to cut through the AI hype cycle. Rather than chasing the latest tools or models, we created a data-driven method to identify where AI could create genuine value for our specific context.

**The value scoring matrix:** Each potential AI use case is evaluated across multiple weighted dimensions aligned with our organizational priorities. This transforms the abstract question of "where should we use AI?" into a concrete, comparable set of scores.

**Our Six Critical Dimensions:**

| **Dimension** | **Weight** | **What We Assess** | **Why It Matters** |
|--------------------|------------|--------------------------------------------------------------------|----------------------------------------------------------------------------------|
| Feasibility | 20% | Implementation difficulty with current skills/resources | Prevents us from chasing technically impressive but impractical applications |
| Revenue Impact | 25% | Potential to increase top-line growth | Ensures AI initiatives contribute to business success |
| Data Readiness | 15% | Availability and quality of necessary data | Many AI projects fail due to data issues, not technology limitations |
| Time to Value | 15% | Speed to tangible results | Builds momentum with quick wins |
| Risk | 10% | Potential challenges or downsides | Protects against unintended consequences |
| Internal Impact | 15% | Number of people/teams benefiting | Prioritizes broad improvements over narrow optimizations |

Here's how we applied this framework to evaluate potential AI initiatives:

This systematic approach cut through subjective debates about which AI tools to adopt, replacing them with evidence-based decisions that aligned with our strategic priorities.

## Early results: beyond the AI hype cycle

Our scoring matrix has already transformed how we approach AI at Meilisearch:

### 1\. From endless options to strategic focus

Instead of drowning in the constant stream of new AI products, our teams now have a clear filter: "Does this tool address one of our high-scoring use cases?" This has dramatically reduced distractions and FOMO while increasing meaningful adoption.

### 2\. Balanced investment: "Ferraris" and "cargo ships"

We're strategically balancing our implementation:

- **"Ferrari" projects:** Quick wins that generate excitement and momentum (e.g., automating our internal documentation updates)
- **"Cargo ship" initiatives:** Substantial efforts with transformative potential (e.g., reimagining our customer support workflow with AI assistance)

### 3\. Creating a dedicated space for experimentation

One crucial lesson: AI adoption requires protected time. We've integrated dedicated "AI exploration blocks" into our work schedules and upcoming offsite, focusing specifically on our highest-scoring use cases.

### 4\. Addressing real concerns

The scoring matrix naturally incorporates ethical considerations through the risk dimension. We've operationalized this by:

- Favoring smaller, more efficient models when possible
- Prioritizing open-source options that allow us to run models locally
- Building in time for human review of AI-generated content

## The framework in action: a case study

After applying our scoring matrix to use cases identified through internal discussions, we quickly surfaced high-impact opportunities. One standout example was improving our code review process—specifically, reducing time to first review for pull requests (PRs).

This use case scored highly across multiple dimensions:

- High feasibility with existing tools
- Direct impact on development velocity
- Clear time-to-value metrics
- Broad internal impact across engineering teams

We implemented CodeRabbit, an AI-powered code review assistant that provides immediate PR feedback. While maintaining our essential human review process, the tool identifies common issues and provides automated PR descriptions. After a two-week trial period, we measured both quantitative metrics and gathered team feedback.

The results validated our scoring framework's prediction:

- Decreased average time to first review
- Improved PR documentation quality
- Positive team adoption and engagement
- Cumulative time savings across the engineering organization

## What's next: your turn

We're sharing this framework because we believe it can help other organizations cut through AI hype and focus on value creation.

The key to successful AI adoption isn't about having the fanciest tools—it's about having the clearest framework for identifying where AI truly adds value in your specific context.

🚀 How we're making AI work at Meilisearch

## What is RAG, and why should you care?

Every day, millions of people interact with ChatGPT, Claude, and other large language models, fundamentally changing how we interact with computers. The appeal is obvious: instead of learning specific interfaces, users can simply communicate in natural language. The machine adapts to the human, not the other way around.

This shift has organizations scrambling to create similar experiences with their own data. Whether it's building a support chatbot that understands product documentation, crafting an assistant that writes personalized emails, or developing an internal tool to help employees access company knowledge, they all require the same foundation: giving LLMs access to proprietary information.

Enter Retrieval Augmented Generation (RAG), a workflow that's deceptively simple in concept:

1. User asks a question
2. The system retrieves relevant documents based on that question
3. LLM generates an answer using those retrieved documents as context

When implemented correctly, RAG provides more accurate, up-to-date responses while reducing hallucinations. But here's where most engineers go wrong: they default to vector databases without considering whether that's actually the optimal approach.

## The engineer's shortcut: Vector databases

The typical RAG implementation looks something like this:

```
User Question → Convert to Embedding → Query Vector DB → Retrieve Similar Documents → Generate Answer

```

It makes intuitive sense. Vector embeddings capture semantic meaning, so similar concepts cluster together in the vector space. By converting questions and documents to the same embedding space, you can find relevant information even when the exact keywords don't match.

Engineers love this approach because it seems elegant. You don't need complex query parsing or keyword matching – just transform everything to vectors and let similarity algorithms do the work.

But this shortcut creates two critical problems that significantly degrade the quality of the results.

## Problem 1: Unrefined queries lead to irrelevant results

The first major issue occurs at the initial step: we take the raw user query, convert it directly to an embedding, and use that to retrieve documents.

Think about what happens when you use Google. You don't always search with your actual question – you distill it to key terms that are more likely to yield relevant results. If you want to know "What's the best way to organize React components in a large project?", you might search for "React component organization best practices large applications."

LLMs excel at this kind of query refinement, but in the standard vector DB approach, we skip this crucial step. The embedding captures the semantic meaning of the original question, but that doesn't always align with the optimal search query.

## Problem 2: Vector search sacrifices precision for recall

The second problem is more fundamental: vector similarity search is strong at recall but often weaker at precision compared to traditional full-text search.

Vector search excels at finding conceptually related content (recall) - documents that discuss similar topics, even if they use different terminology. However, it's less effective at pinpointing exactly what you need (precision).

Full-text search, on the other hand, prioritizes precision. When exact keyword matches exist, they're usually highly relevant. The trade-off is that full-text search might miss conceptually similar content that uses different terminology.

This explains why many RAG systems that rely exclusively on vector databases end up implementing additional re-ranking steps after initial retrieval. It's also why vector databases increasingly add full-text capabilities – they recognize the inherent limitations of pure vector search.

## A more human approach to RAG

Since we're trying to build systems that mimic human intelligence, shouldn't we structure our RAG pipelines to mirror how humans actually search for information?

When people need to find information, they:

1. Reframe their question into effective search terms
2. Use search engines optimized for retrieving relevant information
3. Scan results to identify the most useful content

A better RAG design would follow this pattern:

```
User Question → LLM Refines Into Search Query → Hybrid Search (Combining Full-text and Semantic) → Retrieve Relevant Documents → LLM Generates Answer

```

This approach addresses both problems:

1. The LLM refines the user's original question into an optimized search query
2. Hybrid search combines the precision of full-text search with the recall of semantic search

## The solution: Simpler (and better) RAG with search engines

Here's my contrarian take: instead of jumping to vector databases for RAG, start with a quality search engine that combines full-text and semantic capabilities.

Modern search engines like Meilisearch offer hybrid search functionality that delivers better overall relevance than pure vector retrieval. They're also:

- Easier to deploy and maintain
- Optimized for fast queries at scale
- Designed with relevance as the primary objective
- More intuitive for debugging search results

For most RAG applications, the workflow becomes much simpler:

1. The user submits a question
2. LLM transforms that question into an effective search query
3. The search engine retrieves relevant documents using hybrid search
4. LLM generates a response using those documents as context

This approach aligns with how humans actually search for information, leveraging the strengths of both LLMs and search technology while avoiding unnecessary complexity.

## The power of simplicity in RAG: Back to search basics

Vector databases certainly have their place in the machine learning ecosystem, but they're not always the best foundation for RAG systems. By taking a step back and considering how humans search for information, we can build more effective, simpler RAG architectures.

The next time you're designing a RAG system, consider whether a good search engine might be the better choice. Your users (and your future self maintaining the system) will thank you.

Meilisearch latest news and company updates