What is vector search? Complete guide [2025]

Personalized search is the key to keeping short-attention-span folks interested in your product or service. Users expect results that feel made for them, and personalized search is the key to meeting that expectation — and turning search into a conversion engine.

Here’s what we’ll cover:

* What personalized search means and how it’s different from traditional search.
* How it works behind the scenes: from data collection to result ranking.
* What types of data power it and why they matter.
* Benefits and challenges to consider before implementing it.
* Use cases across industries like e-commerce, streaming, and SaaS.
* Examples in action that demonstrate how personalized search is already everywhere.
* How to implement it using Meilisearch’s high-performance, developer-friendly toolkit.


## What is personalized search?

As the name suggests, personalized search is when search results are tailored to the searchers based on the latter’s unique characteristics, behaviors, and preferences. 

It refers to the search method where your demographics and behavior — past searches, purchases, browsing activity, location, and interests — are used to present the most relevant search results for a search query you initiate.

Unlike traditional search, which delivers the same results to everyone using the same query, personalized search relies on user data to adapt what each person sees in the results. 

You’ve likely seen this in action on platforms like Netflix (suggested titles based on your viewing history), Spotify (custom playlists tailored to your listening history), or Amazon (product recommendations based on your purchasing history).

Today, delivering generic results isn’t just outdated — it’s a missed opportunity. Users expect relevance as the default. 

The better you get at providing it, the more likely they are to click, buy, and stay.

## How does personalized search work?

Personalized search combines behavioral insights and machine learning to make real-time changes to what users see.

![How personalized search works.png](https://unable-actionable-car.media.strapiapp.com/How_personalized_search_works_14ee43ed10.png)

Here’s a high-level look at how [AI-powered personalized search](https://meilisearch.com.cn/blog/ai-powered-search ) works:


### 1. Data collection

The system gathers user-specific signals, such as search history, clicks, the pages users visit, location, and past purchases.


### 2. User modeling

These signals are then used to build a user profile. This user profile could be:

* Session-based (just the current visit)
* Persistent (across different sessions)
* Anonymous or authenticated


### 3. Query handling

Once the user submits a search query, the algorithm interprets it within the context of the user’s profile created in the previous step, adjusting the results based on perceived preferences.


### 4. Ranking & re-ranking

Finally, the system layers personalization on top of relevance scoring. Even if a product matches a keyword exactly, its position can shift depending on what is most relevant *for that user*.

Behind the scenes, features such as collaborative filtering (recommending items based on similar users’ preferences), content-based filtering (suggesting items similar to past content the user has interacted with), and hybrid models determine what rises to the top. Many systems also employ heuristics to facilitate fast decision-making and predict user needs.

Meilisearch supports these processes through its flexible API, which allows the integration of user-specific filters and [vector-based recommendations](https://meilisearch.com.cn/blog/personalization-recommendations ) without compromising on speed, even at scale.


## What data is used in personalized search?

Personalized search can draw from a wide range of data signals. Some are implicit (inferred through behavior) while others are explicit (user-defined preferences).

Here are the common types of data used:

* Search history, like past searches and interactions
* Click, browse, and time-spent-on behavior
* Device type and OS
* Geolocation for localized results
* Time of day/week
* Account information (if logged in)
* Language and filter preferences
* Social signals (likes, shares, follows)
* Interaction with filters, facets, or categories

The richness of your personalization depends on the data you can ethically and transparently collect without violating user trust or data privacy regulations. This user data then informs algorithms to deliver the best results for the highest user satisfaction.


## What is the difference between personalized and traditional search?

The main difference between personalized and traditional search is how results are selected and ranked.

Traditional search relies heavily — or entirely — on matching query terms with indexed content using a static algorithm. Everyone sees the same result for the same input. It’s predictable and uniform, but it's also less relevant.

Personalized search, by contrast, incorporates user data and adjusts results based on the individual user. This provides unique results and improves relevance, but adds complexity, especially around data management, compliance, and UX consistency.

Here’s a quick side-by-side comparison.

![What is the difference between personalized and traditional search_.png](https://unable-actionable-car.media.strapiapp.com/What_is_the_difference_between_personalized_and_traditional_search_b9f818eebf.png)

Personalized search’s reliance on user data introduces variability and complexity. 

Even though it may require more setup, it also returns more value, especially in customer-facing products and services.


## What are the benefits of personalized search?

Personalized search delivers measurable benefits across UX, engagement, revenue, and brand performance.

Here are the key advantages:

* **Higher customer engagement:** Users spend more time interacting with your site or product because of the greater relevance of search results.
* **Boosted revenue:** Relevant suggestions improve click-through rates and sales for most brands.
* **Lower bounce rates:** Users find what they’re looking for faster, so they stay on your site longer.
* **Surfaced niche content:** Personalization helps uncover niche or under-ranked content that users might otherwise miss.
* **Improved retention and loyalty:** A personalized experience builds long-term trust and brand affinity.
* **Better monetization opportunities:** You can highlight relevant high-margin or preferred content/products more effectively.

These benefits drive tangible business outcomes, resulting in a revenue boost of [up to 40%](https://www.mckinsey.com/capabilities/growth-marketing-and-sales/our-insights/the-value-of-getting-personalization-right-or-wrong-is-multiplying) for companies employing personalization. 


## What are the challenges of personalized search?

Personalized search is not without its drawbacks across user data privacy, scalability, and complexity.

![Challenges of personalized search.png](https://unable-actionable-car.media.strapiapp.com/Challenges_of_personalized_search_1b30b4a33b.png)

Implementing personalized search involves hurdles such as:


### 1. Data privacy and compliance

Personalized search often relies on collecting user data, raising GDPR, CCPA, and similar concerns.

Use opt-in consent, clearly communicate the type of data collected, and anonymize or aggregate data wherever possible. Consent management should be baked into your UX from day one.


### 2. Cold start problem

New users or fresh content lack enough data to be included in personalization, taking search back to its traditional state.

You can overcome this by combining contextual signals (e.g., from geolocation or device) with collaborative or content-based filtering. You can also use fallback strategies like popular or trending content to give your personalized search algorithm a foundation.


### 3. Performance and scalability

Real-time re-ranking and personalization at scale are computationally intensive, which raises concerns about costs and scalability.

Use caching, vector databases, or edge computing to maintain speed without sacrificing relevance.


### 4. Over-personalization

Too much personalization can trap users in a ‘filter bubble,’ where they're only shown results they’re likely to agree with, limiting content diversity and discovery.

A good solution for this would be to blend personalized and generic results. For example, use sections like ‘For You’ and ‘Trending Now.’ You could also allow manual user adjustment for a more human-in-the-loop approach.


### 5. Integration complexity

Personalization involves combining multiple data sources, APIs, systems, and service layers, which can be pretty complex.

Choose modular customizable tools like Meilisearch that make it easier to implement personalization in stages for streamlined integration.

Balancing the benefits and drawbacks of personalized search will take you beyond basic search into new realms of possibility.


## What are the use cases for search personalization?

Personalized search has different use cases and applications across various industries. 

![What are the use cases for search personalization_.png](https://unable-actionable-car.media.strapiapp.com/What_are_the_use_cases_for_search_personalization_dbdca13b7e.png)

Some areas where personalized search shines are:


### E-commerce

In e-commerce, personalized search helps users discover what they're likely to purchase. By analyzing previous purchases, browsing history, and the most frequently accessed categories or brands, marketplace search results prioritize items that match users' purchasing habits, thereby predicting their choices.

You can also include price sensitivity and availability to create more relevant, context-based product recommendations.


### Media streaming

Media platforms employ personalization to display content that users are likely to enjoy, based on their viewing history, preferred genres, or browsing behavior. 

For example, the platform could suggest a new period-piece series after the user completes a historical show, or optimize search results to highlight content with familiar actors or directors.

This approach reduces choice fatigue, improves user retention, and helps surface lesser-known but contextually relevant content that might otherwise be buried in extensive catalogs.


### Travel booking

Travel search personalization tailors results by analyzing details from previous searches, favorite spots, airlines, hotel categories, or even loyalty programs. 

For example, if you’re a frequent flyer, you might find business class options at the top of your search results. A returning user could be shown offers for destinations similar to those they’ve visited.


### SaaS platforms

Personalized search in SaaS applications can prioritize the most relevant documentation, feature, or dashboard based on a user's role, past use, or recent activity. 

For instance, developers might first receive content regarding API references, while analytics tools may be the most relevant content for marketers.

Such role-based tailoring speeds up onboarding, reduces support overhead, and enables users to derive value from the product sooner, thereby improving employee engagement and retention.


### Online education

Learning management systems and online learning platforms use personalized search to suggest courses, modules, or learning pathways to students based on their interests, skill levels, and learning history. Whether resuming a suspended course or exploring a new subject, students can use personalization to discover relevant resources, certifications, or subsequent modules.


## What is an example of personalized search?

Let’s bring personalized search use cases to life with some real-world examples.


### 1. ‘Pizza near me’

Let’s say you are searching for good pizza places in your location using the keyword ‘pizza near me.’

Without personalization, a system, such as a food delivery app or Google, will show all registered and available pizza places on the app. 

Limited personalization may result in filtering based on a 5- or 10-mile radius around your location, such as Google’s ‘See results closer to you.’

![Results closer to you Google feature.png](https://unable-actionable-car.media.strapiapp.com/Results_closer_to_you_Google_feature_e9aed062ff.png)

Source: [Google](https://www.google.com/?gl=us)

With actual real-time personalization, the app will show and rank pizzerias you’ve ordered from before, that are open now, and fit your exact delivery radius. 


### 2. Online shopping

Online marketplaces like Amazon and Trendyol aim to offer customers the widest selection of lifestyle products. First visitors will likely receive ‘random’ suggestions, perhaps only personalized to their device type or geolocation.

After a few rounds of online ‘window shopping’ or order placing, the results become more targeted, prioritizing your favorite categories, brands, preferred price range, or products you viewed last time.

![Marketplace product recommendations.png](https://unable-actionable-car.media.strapiapp.com/Marketplace_product_recommendations_b03c36171e.png)

Source: [Trendyol](https://www.trendyol.com/)

Personalization reduces friction, makes discovery intuitive, and accelerates action in every case. 

But how do you get all this for your system? 

Meilisearch makes it easy!


## How to implement search personalization

Now that we’ve covered the ‘why’ and ‘what,’ let’s look at the ‘how.’

With Meilisearch, real-time search, relevance tuning, and fast indexing enable personalized search through features like filters, [vector search](https://meilisearch.com.cn/blog/what-is-vector-search), and multi-tenancy.

Here’s how to approach it:


### With localized content

Personalized search with localized content uses geosearch or filters to prioritize results based on user location, language, or locale. 

Meilisearch’s [sorting features](https://meilisearch.com.cn/docs/learn/filtering_and_sorting/sort_search_results) and [geospatial search capabilities](https://meilisearch.com.cn/docs/learn/filtering_and_sorting/geosearch) enable this.

For example, to sort correctly indexed restaurants based on their proximity to the Eiffel Tower, the following Python script for the `_geoPoint` sorting function may come in handy:


```python
client.index('restaurants').search('', {
  'sort': ['_geoPoint(48.8561446,2.2978204):asc', 'rating:desc']
})
```


For documents to be correctly sorted based on their geographic location, ensure they contain a valid `_geo` field.


### With recent searches

Perhaps the most widely used personalization criterion is the user’s past searches. Using the user’s recent activity in the search system, the application can suggest and provide the most relevant results. 


## Bringing it all together: personalized search for real impact

Personalized search is no longer a ‘nice-to-have’; it’s a competitive necessity.

It transforms users' interactions with and feelings about your platform by delivering natural, effortless, and uniquely relevant search results. 

The result? Higher engagement, better retention, and stronger conversion metrics.


Personalized search: Deliver ultra-relevant results that convert

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.cn/blog/choosing-the-best-model-for-semantic-search). These [embeddings](https://meilisearch.com.cn/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.cn/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.cn/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://meilisearch.com.cn/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 'https://: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 'https://: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 'https://: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 'https://: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 'https://: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.cn/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.cn/blog/full-text-search-vs-vector-search). Great for ecommerce, web apps, [enterprise search](https://meilisearch.com.cn/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://llamaindex.org.cn/) 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://meilisearch.com.cn/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.cn/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.cn/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.cn/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://meilisearch.com.cn/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.cn/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 recap of everything that happened this month!

## 🔔 Reminder to upgrade

[![Release notes Meilisearch 1.15](https://unable-actionable-car.media.strapiapp.com/meilisearch_1_15_e1b23d5c0c.png)](https://meilisearch.com.cn/blog/meilisearch-1-15)

Don't forget to upgrade to Meilisearch 1.15 to benefit from improved AI search with composite embedders and embedding cache. v1.15 is coming soon!

[Read the release notes](https://meilisearch.com.cn/blog/meilisearch-1-15)

## 📰 In the news

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

How Meilisearch's innovative scoring system revolutionizes hybrid search and delivers more relevant results than traditional rank fusion methods.

[Read the blog post](https://meilisearch.com.cn/blog/fixing-hybrid-search)

### 🔍 What 1,000 Contributors Taught Me About Open-Source

Our Head of Engineering, Clémentine, reflects on the lessons she’s learned from leading an open-source project—and what it takes to foster a strong, engaged community.

[Read the blog post](https://blog.curqui.com/what-1000-contributors-taught-me-about-open-source)

### 🗄️ Get early access to our new resource-based pricing

Previously reserved for Enterprise plans, our resource-based model is finally open to all.

[Get early access](https://eu1.hubs.ly/H0lf50s0#newsletter&utm_source=blog&utm_medium=june-25-updates)

### 🚀 Help us shape search personalisation — book a call!

We're exploring search personalization in Meilisearch and would love to hear about your needs and use case.

[Book a call](https://cal.com/team/meilisearch/search-personalization-discovery-call#blog&utm_medium=june-25-updates)

## 🤗 Made with Meilisearch

One of our community members has built [Meilisearch extension for Magento 2](https://github.com/walkwizus/magento2-module-meilisearch)!

This integration lets you replace Magento's default search engine with Meilisearch, bringing lightning-fast and relevant search results to your online store.

They’re looking for feedback on the integration—give it a try and let them know what you think!

You can also check out the [live demo](https://demo-meilisearch.walkwizus.com/) to see it in action.

[![meili-magento2.png](https://unable-actionable-car.media.strapiapp.com/meili_magento2_e38319eba7.png)](https://github.com/walkwizus/magento2-module-meilisearch)

_We’re always looking to promote new projects from the community. Post yours in the [#built-with-meilisearch](https://dub.sh/meili-discord#newsletter&utm_source=blog&utm_medium=june-25-updates) Discord channel!_

---

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

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

Meilisearch June updates

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.cn/blog/what-are-vector-embeddings) in a specialized [vector database](https://meilisearch.com.cn/blog/what-is-a-vector-database) designed for fast searches.
- Turning the user’s query into an embedding.
- [Searching the database](https://meilisearch.com.cn/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://meilisearch.com.cn/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

Firebase is a BaaS (Backend as a Service) platform. One of its backend services is the Cloud Firestore, which allows you to perform full-text search using a third-party extension.

Firebase users can query document collections in Cloud Firestore with a set of functions available in SDKs for several programming languages, including Swift, Kotlin, Python, Java, PHP, Ruby, and more.

Cloud Firestore does not provide native indexing, so users must use third-party services for document indexing and performing AI-powered searches.

This tutorial will guide you through the steps to index documents from Cloud Firestore using the [Meilisearch extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch).

## 1. Deploy Meilisearch

You first need to have Meilisearch running on a cloud service. You can either self-host it or use [Meilisearch Cloud](https://meilisearch.com.cn/cloud) for an easier setup.

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

This step is required because Meilisearch will provide the indexation of Firebase documents and search capabilities. Meilisearch utilizes machine learning (ML) models to convert documents (JSON files) into vector embeddings, which are stored in a vector space for fast and real-time database retrieval.

To install Meilisearch locally, you can run the following cURL command:


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


Then you need to run Meilisearch:


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


Let’s now see how to create a Firebase project connected to Meilisearch using the [Meilisearch extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch).

## 2. Create a Firebase project

Note: You can skip this step if you already have a Firebase Project with a Firebase database containing your documents.

Once you have Meilisearch up and running, you can create a Firebase project, configure it, and add a Firestore database.

There are several ways to configure a project on Firebase. You can do it directly on the [Firebase Console](https://console.firebase.google.com/) or use the [API](https://firebase.google.com/docs/projects/api/workflow_set-up-and-manage-project).

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

On the console, your project’s page looks like this:

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

On the left side, click ‘Build’ and choose ‘Firestore Database.’

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

From there, you can start adding documents to your new database.

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

Now let’s see how to connect [firestore-meilisearch](https://github.com/meilisearch/firestore-meilisearch) to Cloud Firestore.

## 3. Install Meilisearch’s Firebase extension

If you look at the extensions in your Firestore Cloud page, you won’t find Meilisearch as a default. Therefore, you need to install it from the [Firebase Extensions Hub](https://extensions.dev/extensions/meilisearch/firestore-meilisearch).

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

You need to activate the [Blaze pricing plan to add this and other extensions](https://firebase.google.com/pricing?authuser=0). You will be charged a small amount (typically around $0.01/month) for the Firebase resources required by this extension, even if it is not used.

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

If you don’t have a billing account, you can quickly create one in the [Google Cloud Console](https://cloud.google.com/billing/docs/how-to/manage-billing-account). Once done, you can activate the extension and set up a budget amount.

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

The billing account is successfully connected to the Blaze pricing plan with these steps.

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

The next step to activate the [firestore-meilisearch](https://github.com/meilisearch/firestore-meilisearch) extension is to review the APIs in your Firebase project. If you don’t have the required ones enabled, you’ll be asked to activate them.

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

After enabling the APIs, you’ll be granted a service account. Finally, you’ll be asked to configure the extension, which includes setting a location, a collection path, the fields to index, and the Meilisearch index name, host, and key (optionally). 

In the following example, we created a collection for movies:

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

You’re now ready to install the extension, which takes between three and five minutes.

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

Once installed, you can test Meilisearch, but first, you need to check if you have a collection in your Firebase project with the same name as the one configured in the extension.

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

If not, you can visit the [project’s dashboard](https://console.firebase.google.com/) and add your collection accordingly.

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

This is the data we are using in our example:

title: The Hobbit: An Unexpected Journey

poster &lt;[https://image.tmdb.org/t/p/w500/yHA9Fc37VmpUA5UncTxxo3rTGVA.jpg](https://image.tmdb.org/t/p/w500/yHA9Fc37VmpUA5UncTxxo3rTGVA.jpg)>

overview: Bilbo Baggins, a hobbit enjoying his quiet life, is swept into an epic quest by Gandalf the Grey and thirteen dwarves who seek to reclaim their mountain home from Smaug, the dragon.

release_date: 1353888000

Once you have added this movie, you should be able to see it when accessing Meilisearch’s search preview:

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

Well done! You have successfully installed the Meilisearch Firestore extension!

When you add, update, and delete documents from your Firestore collection, they will be mirrored in Meilisearch.


### Managing your extension

To access the overview panel of the extension, first click on the ‘Extensions’ tab on Firebase’s sidebar menu, then find the Meilisearch extension and click on ‘Manage.’ Finally, click on ‘Extension configuration’ and you can now change the collection, host, index, and so on.

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

Accessing your logs allows you to monitor your cloud functions and obtain different levels of information. You may access an extension’s logs via the ‘Extensions’ tab. Alternatively, you can also visit the ‘Functions’ tab and select ‘Logs,’ as indicated in the image below.

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

## 4. Set up a search interface

In the previous chapter, we successfully installed and configured the Meilisearch extension on Firestore. Now it’s time to query data using a simple search engine application. Here we will see how to create a search bar for your project using this [GitHub repository](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch).


### Populating your Firestore collection with data

The first step is to add more documents to our Firestore database. In our case, we will use this [collection of movies](https://meilisearch.com.cn/movies.json). Refer to the Firebase documentation for more information on adding and managing [data](https://github.com/meilisearch/firestore-meilisearch).

Once you have finished adding content to your Firestore database, visit your Meilisearch search preview to check that Meilisearch has successfully indexed your documents.

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

### Search in your document

Now let's create a great search experience. There are many ways to do this, but we’ll keep it simple this time and use [instant-meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch), our plugin for the instant-search JavaScript library.

Create an index.html file in your preferred development environment. This HTML page should contain a search bar and a box to contain the returned search results:


```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Meilisearch demo</title>
    <link rel="stylesheet" href="<https://cdn.jsdelivr.net.cn/npm/instantsearch.css/themes/algolia-min.css>" />
</head>
<body>
    <div>
        <div id="searchbox"></div>
        <div id="hits"></div>
      </div>
  
      <script src="<https://cdn.jsdelivr.net.cn/npm/@meilisearch/instant-meilisearch/dist/instant-meilisearch.umd.min.js>"></script>
      <script src="<https://cdn.jsdelivr.net.cn/npm/instantsearch.js@4>"></script>
      <script>
          const searchClient = instantMeiliSearch(
              'your Meilisearch url',
              'your Meilisearch API key'
            )
            const search = instantsearch({
              indexName: 'movies',
              searchClient
            })

            search.addWidgets([
              instantsearch.widgets.searchBox({
                container: '#searchbox',
              }),
              instantsearch.widgets.hits({
                container: '#hits',
                templates: {
                  item: `
                    <div style="text-align:center;">
                      <div class="hit-name">
                        {{#helpers.highlight}}{ "attribute": "title" }{{/helpers.highlight}}
                      </div>
                      </br>
                      <div>
                        <img src="{{poster}}" width="200px" />
                      </div>
                    </div>
                  `,
                },
              }),
            ])

            search.start()
      </script>
</body>
</html>

```


Remember to replace the example’s configuration with your own dataset. This might include the indexName if you named your index something other than ‘movies,’ your instance’s URL, and your API authentication token.

If everything went well, you should be able to access your index.html file and start searching right away:

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

Congrats! You have added full-text search capability to your Cloud Firestore. Your Firebase collection and your Meilisearch index will automatically stay in sync as long as the firestore-meilisearch extension is installed.


## How is Firebase search used?

Firebase offers full-text search capabilities on indexed fields through third-party solutions. Common use cases include:


* **User profiles**: Filtering users by name or email.
* **Product catalogs**: Searching items by category or price.
* **Blog posts**: Finding articles by title or tags.
* **Geolocation**: Querying places using geo data.


### Does Firebase have vector search?

No. Firebase lacks a built-in [vector search](https://meilisearch.com.cn/blog/introducing-vector-search) for semantic or AI-powered queries. However, the Meilisearch [extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch) enables vector search by indexing Firestore documents, allowing similarity-based searches.


### Does Firebase support full-text search?

No. Firebase only supports exact string matching. For features like typo-tolerance, synonyms, or ranked results, the Meilisearch [extension](https://extensions.dev/extensions/meilisearch/firestore-meilisearch) indexes Firestore data to deliver fast, flexible full-text search.


## Enable reliable search in your Firebase app with Meilisearch

Adding search to your Firebase app doesn’t have to be a complex process. In fact, you can give users fast, accurate results with the proper setup. 

The key is to start simple, scale smart, and use Meilisearch.

Meilisearch 最新消息和公司动态

什么是向量搜索？完整指南 [2025]

个性化搜索：提供高度相关且可转化的结果

如何使用LLM在数据库中搜索？

多模态RAG：简单指南

LlamaIndex RAG教程：逐步实现

Meilisearch 六月更新

微调 vs RAG：选择正确的方法

如何在 Firebase 中实现搜索

如何构建 RAG 流水线：分步指南