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

You can have the fastest search engine in the world, but if it doesn’t show the right results, users won’t stick around.

That’s where search relevance comes in. It connects user intent to real outcomes, such as clicks, conversions, and continued engagement.

In this guide to search relevance, we will cover:

* What search relevance means
* Why relevance affects user satisfaction, conversions, and engagement
* What factors and signals influence search engine ranking
* How to measure relevance using metrics like precision and recall
* Common challenges like noisy data, ranking issues, and limited resources
* Practical ways to improve search results relevance using ranking rules and algorithms
* How Meilisearch helps you build a fast, relevant, and scalable search experience

Want your users to find exactly what they’re looking for? Let’s get into it.

## What is search relevance?

Search relevance refers to how aligned a search result is with a user’s query intent. It measures how well the search result matched the user’s query and provided the information they were looking for. 

High relevance means the top results are timely, accurate, and context-aware.

Modern search engines use algorithms that factor in ranking signals, query intent, and language models to determine relevance. When relevance is high, users find what they need faster, leading to higher engagement and lower bounce rates.

## Why does search relevance matter?

Search relevance is the backbone of a good search experience. When users get results that match their intent, they stay longer, click more, and convert faster – pretty much everything a business wants. 

On the other hand, irrelevant results cause users to leave immediately, which rapidly increases bounce rates.

In e-commerce, relevant search helps customers find the right product quickly. On content-heavy platforms, it connects users to the exact article, tutorial, or documentation page they need. The greater the relevance, the higher the customer satisfaction and engagement.

Whether you're optimizing a blog, internal tool, or a product catalog, improving relevance directly impacts retention, conversions, and trust.

Let’s explore a real-world example to see how it works in practice.

## What is an example of search relevance?

Let’s take an example of a common e-commerce search query. 

Say someone types ‘wireless headphones’ into a store’s search bar. If the search relevance is good, the top results will bring up popular wireless headphone models like the Sony WH-1000XM5 or AirPods Pro. 

![Example of good search relevance.png](https://unable-actionable-car.media.strapiapp.com/Example_of_good_search_relevance_a1d20f131e.png)

Source: [amazon.com](http://amazon.com) 

If the search relevance is poor, it will bring up headphones with wires as well as other accessories. 

Let’s take another example, of a recipe blog. If you look up ‘vegan pasta’ and get any result besides pasta without meat, dairy, and eggs, then the search relevance is poor. 

![Example of poor search relevance.png](https://unable-actionable-car.media.strapiapp.com/Example_of_poor_search_relevance_e04168322a.png)

Source: [recipesmadeeasy.co.uk](http://recipesmadeeasy.co.uk) 

These examples happen every day, and the difference between a relevant and irrelevant result directly affects user trust, conversions, and retention. 

Businesses that prioritize search relevance improve UX and drive measurable results, such as reduced bounce rates, faster time-to-product, and higher customer satisfaction.

Let’s now look at what affects search relevance behind the scenes.

## What factors influence search relevance?

Here are the factors influencing whether search engines bring up relevant content.

* **Keyword frequency:** This refers to how often the search term appears in a page, which affects the page's ranking. 
* **Natural language processing (NLP) features:** NLP features help search engines understand synonyms, context, and the intent behind a query. For example, it recognizes that ‘cheap laptop’ and ‘budget notebook’ are similar.
* **Personalization:** Search engines can adjust results [based on past user behavior](https://meilisearch.com.cn/blog/personalized-search). Two users with the same query might receive different responses based on location or preference. 
* **Freshness:** Newer content can rank higher, especially for time-sensitive queries. For example, a user searching for a phone with a good camera expects recent results, not results from 10 years ago. 

These are the most common elements that work together to form the foundation of how search systems evaluate and deliver results. 

Next, let’s explore how a search engine calculates and applies relevance in real time.

## How does a search engine determine relevance?

Modern search engines are incredibly clever. 

Thanks to signals such as keyword matches, content structure, document freshness, and link authority, they use ranking algorithms to filter for the best results.

Search engines also apply natural language processing (NLP) and [semantic search](https://meilisearch.com.cn/blog/semantic-search) to understand the intent behind a query rather than just the literal words used.

In more advanced systems, machine learning models refine relevance over time by learning from user behavior, such as clicks, dwell time, and query reformulations. 

These systems don’t just react to input; they also adapt, improving result quality with every interaction. This creates a feedback loop where relevance gets sharper the more the engine is used, helping search systems stay aligned with evolving user intent.

## How is search relevance measured?

Metrics help you evaluate if your search engine provides relevant and useful results to the right users. 

The goal is to quantify whether users are finding what they’re looking for and whether results are being ranked in the correct order.

Here are some of the most commonly used search relevance metrics:

* **Precision** measures how many of the results shown are helpful. Higher precision means fewer off-target results. It keeps things focused so users don’t waste time on the wrong stuff.
* **Recall** checks if your engine found all the good matches. A [high recall score](https://meilisearch.com.cn/blog/mastering-rag) means you're not missing anything important. It's about covering your bases and giving users the whole picture.

![Example of recall and precision.png](https://unable-actionable-car.media.strapiapp.com/Example_of_recall_and_precision_1c6f0efe97.png)

* **Click-through rate (CTR)** tells you how often people click a result after searching. If clicks are low, your top results might not be hitting the mark. It’s a simple way to see if users like what they see.
* **Normalized Discounted Cumulative Gain (nDCG)** is a metric that determines whether relevant results appear high in the results list. A perfect answer won’t help if it’s buried at the bottom. 
* **The F1 score** is a mix of precision and recall. It’s useful when you want to avoid both wrong and missed matches.

Other metrics to consider include the Mean Reciprocal Rank (MRR), Mean Average Precision (MAP), and user satisfaction scores from feedback or surveys.

## What is a relevance score?

A relevance score is a number assigned to each search result that reflects how well the result matches the user’s query. The higher the score, the more relevant the engine considers the result.

Relevance score is calculated during search time – the time it takes to find the relevant search results – by taking into account factors such as keyword frequency, document fields, query intent, and metadata. 

## What are some common challenges in achieving search relevance?

Search relevance isn’t universal: what’s helpful to one user can be completely irrelevant to another. That’s why building a search experience that consistently delivers the right results is both complex and context-dependent.

![What are the common challenges in achieving search relevance.png](https://unable-actionable-car.media.strapiapp.com/What_are_the_common_challenges_in_achieving_search_relevance_374f78bb09.png)

Below are some of the most persistent issues.

### 1. Ambiguous queries

Users often enter short or vague queries like ‘apple’ or ‘terminal,’ leaving the search engine to guess what they really mean. Is it the tech brand or the fruit? An airport terminal or a computer?

Without additional context, such as user history, location, or intent, these queries can return irrelevant or overly broad results. 

Handling ambiguity requires special disambiguation strategies, like query suggestions, autocomplete, or personalized ranking, to guide users toward better results.

### 2. Synonym and variant handling

If someone searches for ‘laptop’ but your site uses ‘notebook’ instead, the match will be lost. The same happens with spelling variants like ‘organization’ and ‘organisation.’ 

Without synonym dictionaries, stemming, and typo handling, users can miss out on content that exists but can’t be found. Good relevance depends on catching those variations every single time.

### 3. Data quality issues

If your data is messy, your search results will be too. Inconsistent tags, missing fields, or duplicate entries confuse the system. 

For example, using the terms ‘color’ and ‘shade’ interchangeably splits the index. 

Clean data, clear fields, and smart indexing rules are the foundation of accurate and relevant search.


### 4. Evolving user behavior

Fast results are one thing, sensible answers are another. The audience wants both. 

[AI-powered search](https://meilisearch.com.cn/blog/ai-powered-search) helps understand what users mean, not just what they type. It looks at intent, learns from behavior, and ranks results more naturally. This creates a smoother experience, especially for platforms with a lot of content or technical depth.

## How can you improve search relevance?

How can we actually improve search relevance? 

We can count on several factors for help. 

For instance, Meilisearch can directly contribute to this by boosting the precision, speed, and usefulness of your search results without all the complex algorithm shenanigans. 

Let’s look at some best practices for optimizing your search engine. We’ll use an example of a Golang-based e-commerce search engine to illustrate.


### 1. Customize Meilisearch ranking rules

Meilisearch relies on ranking rules to bring back the best results. 

How do these work? 

They basically define how your results are prioritized using various parameters, such as word match count, typo count, and field importance. 

You can easily update or reorder these rules to suit your business logic.


```go
client.Index("movies").UpdateRankingRules(&[]string{
  "typo",
  "words",
  "proximity",
  "attribute",
  "exactness",
})
```


This allows you to prioritize matches of specific fields (like `title `over `description`) or emphasize typo tolerance. 

The flexibility to customize these rules means you can fine-tune your relevance algorithm without complex backend engineering. 

Remember, order matters: rules applied earlier have more impact. So, choose wisely!


### 2. Configure synonyms for inclusive matching

You’re most likely wondering what happens if users don’t search for the exact product names. Well, there’s a solution for that as well. 

Meilisearch has a built-in synonym handling feature. It allows you to customize and map similar terms together so ‘product A’ can mean ‘product B’ and vice versa.


```go
client.Index("products").UpdateSynonyms(&map[string][]string{
  "jacket": {"coat", "outerwear"},
  "laptop": {"notebook", "computer"},
})
```


Whether users search for a ‘coat’ or a ‘jacket,’ they’ll see the same results. 


### 3. Tune typo tolerance for better UX

Meilisearch has built-in [typo tolerance](https://meilisearch.com.cn/docs/learn/relevancy/typo_tolerance_calculations), which suits fast typers. By adjusting the typo tolerance level, you can control how forgiving (or unforgiving) the search engine is. 


```go
client.Index("books").UpdateSettings(&meilisearch.Settings{
  TypoTolerance: &meilisearch.TypoTolerance{
    Enabled: meilisearch.Bool(true),
    MinWordSizeForTypos: map[string]int{
      "oneTypo": 5,
      "twoTypos": 9,
    },
  },
})
```


This setting is critical for improving UX. It helps retain users who might otherwise bounce due to zero results caused by simple typing errors.


### 4. Use tokenization and normalization

Meilisearch breaks your text into smaller parts and cleans it up for search. It turns ‘résumé’ into ‘resume’ and ‘Color’ into ‘color.’ Users will still find what they’re looking for, even with slight differences. 

If you’re using Go, this happens in the background. That means better results without extra effort.


### 5. Apply stop words and filtering

Words like ‘the’ or ‘of’ don’t help search. Meilisearch skips them by default, so your engine focuses on the important stuff. 

You can tweak this too:


```go
client.Index("articles").UpdateStopWords(&[]string{"the", "a", "of", "in"})
```


Pair this with [faceted filtering](https://meilisearch.com.cn/blog/nested-hierarchical-facets-guide) for even sharper control. For example, in a product catalog, let users filter by brand, price, or rating. This adds structure to your search and improves user engagement by narrowing results down to exactly what they need.


### 6. Leverage custom ranking for business goals

The default ranking is a good start, but real value comes when your results reflect what matters most to your business. 

Want to show in-stock items first or boost high-rated products? Meilisearch lets you rank results by fields like sales, ratings, or popularity:


```go
client.Index("products").UpdateRankingRules(&[]string{
  "desc(popularity)",
  "typo",
  "words",
})
```


This level of control improves query relevance and links user intent with business metrics. Whether a SaaS site surfaces popular docs or a [marketplace search engine](https://meilisearch.com.cn/blog/marketplace-search-engine) prioritizes trending items, custom ranking ensures your search engine works for you as well as for the user.

Now that you know how to improve search relevance, let’s explore how to test and validate those changes to make sure they work in real-world scenarios.

## How to test search relevance

You can have the smartest ranking rules in the world, but if your search results don’t help users find what they need, it doesn’t matter. 

That’s why testing matters. It shows you whether your search logic aligns with what users expect to see.

Here are a few ways to test how well your relevance holds up.


### 1. A/B testing different configurations

This is a simple way to compare two versions of your search. Maybe one uses more typo tolerance. Maybe the other favors exact matches or gives a boost to specific keywords. 

Run both versions and examine the click-throughs, bounce rates, and conversions. You’ll quickly see which one is more useful to real users.


### 2. Manual relevance grading

This one takes a bit more effort, but it works. Pick a few common queries and review the top results by hand. Are they relevant? Do they make sense? Does the top result actually match what someone is searching for? 

This type of reviewing helps you set a baseline and catch issues that automated testing might miss.


### 3. Collecting user feedback and behavioral data

Don’t be shy. Ask users what they think. Add a quick thumbs up or down. Toss in a ‘Did you find what you were looking for?’ at the end of a search. 

Pair that with user behavior signals like how far people scroll or which results they click. If users always ignore the top result and click the third one instead, it could be a sign that something needs fixing.


### 4. Analyzing search metrics

Metrics like MRR, Precision at K, and nDCG give you a clear picture of how often the right results appear at the top. They help you spot what’s working and what’s falling short. Over time, these numbers guide you toward better performance without guesswork.

Whether you’re building product search, docs lookup, or [site search](https://meilisearch.com.cn/solutions/site-search), testing helps you move from ‘just okay’ to results that make sense to the user. 

## Enhancing search relevance with precision and control

Relevance is what makes search feel intuitive, fast, and useful. Whether you're powering product discovery, technical documentation, or in-app search, delivering relevant results drives user trust, engagement, and conversion, turning search from a utility into a competitive advantage.

What is search relevance: Everything you need to know

On-site search: Definition, implementation, best practices & more

Employees across industries spend countless hours online searching for documents, policies, and answers, only to end up staring at pages and pages of irrelevant search results. 

When internal search doesn’t work, productivity suffers, information is siloed, and morale takes a hit. 

A smart intranet search engine changes that. It delivers fast, relevant answers and helps teams get work done without the digital scavenger hunt.

In this guide, you’ll learn everything you need to know before choosing or building an intranet search system for your organization, including:

* What an intranet search engine does and how it’s different from a typical internal search tool.
* How search engines for intranets work under the hood.
* Key benefits of better intranet search in an organization.
* Common reasons why most intranet searches fall short.
* Features that matter most, including AI-driven personalization and security.
* Top ready-to-use and open-source tools worth exploring.
* Steps to build a custom solution from scratch.
* Optimization tips to improve accuracy, speed, and satisfaction.

## What is an intranet search engine?

An intranet search engine is a tool that helps employees quickly find internal information – whether documents, messages, files, or tools – across a company’s internal systems. Unlike a search engine like Google, which crawls the entire web, intranet search engines focus exclusively on one organization's private data.

In essence, an intranet search engine delivers fast and relevant search results from internal sources. When done right, it transforms how employees access knowledge, saving time and reducing frustration.

Now, let’s see how exactly these systems work.

## How does an intranet search engine work?

At its core, an intranet search engine finds and ranks content stored across a company’s internal systems. 

It does this through a multi-step process:

1. **Crawling:** The search engine scans internal sources – files, folders, wikis, databases, and communication tools – to discover and collect content.
2. **Indexing:** It organizes and stores this content in a searchable index, tagging it with relevant keywords and metadata. Like it’s building a detailed internal map of an organization’s knowledge.
3. **Querying:** When a user enters a search term, the engine checks the query against the index, looking for matching content.
4. **Ranking:** The engine ranks the results based on relevance, using factors like keyword frequency, location, freshness, and context. The goal is to show the most useful results first.
5. **Enhancements (optional):** More advanced systems use Natural Language Processing (NLP) to understand user intent beyond exact keywords. Some also support [federated search](https://meilisearch.com.cn/blog/what-is-federated-search), which pulls results from multiple internal systems into one unified view.

Next, let’s look at how intranet search differs from other types of internal search.

## What is the difference between internal and intranet search engines?

Although the terms intranet and [internal search](https://meilisearch.com.cn/blog/internal-search) are often used interchangeably, their purposes in an organization are very different. 

An intranet search engine provides employees with all the important information from the entire internal digital environment. It helps them access the data they need, no matter where it lives. 

On the other hand, an internal search engine operates within a single platform. Think of the search bar inside your CRM or helpdesk. It works well, but only within that one tool.

Here’s how they compare.

![What is the difference between internal and intranet search engines.png](https://unable-actionable-car.media.strapiapp.com/What_is_the_difference_between_internal_and_intranet_search_engines_d1a1569d3e.png)

Intranet search connects your whole ecosystem. Internal search zooms in on one piece of it.

Let’s break down why that matters for your business.

## Why is intranet search important for organizations?

When employees can’t find what they need, work slows down. Time is wasted, frustration builds, and productivity takes a hit.

An effective intranet search engine flips that script. It makes internal content easily accessible, no matter where it lives, so people can focus on their work, not the hunt.

Here’s what a strong intranet search unlocks:

* **Higher productivity:** Employees stop digging through folders or pinging coworkers for links.
* **Faster decision-making:** Quick access to relevant data leads to smarter, faster choices.
* **Better collaboration:** Teams stay well coordinated when content is easy to find and up to date.
* **Fewer repeated tasks:** Past work is searchable, so employees aren’t constantly starting from scratch.
* **Happier teams:** Less friction means smoother workflows and more time for meaningful work.

When the intranet search works well, everything else becomes easier. 

But building a reliable system starts with understanding its limitations.

## What are the common challenges with intranet search engines?

Sometimes, intranet engines fail. This can be for a number of reasons, including poor implementation, technical limits, or a lack of structure. 

Here are common issues organizations face with intranet search and how to fix them.

### 1. Incomplete indexing

When a search engine fails to index all relevant files, employees miss out on information that could’ve been essential to their role or projects. This usually happens due to improper configuration, limited permissions, or outdated systems. 

A smart search engine, such as [Meilisearch](https://meilisearch.com.cn/), can tackle this by crawling and surfacing content based on real-time changes.

### 2. Irrelevant results

Few things are more frustrating than searching for something specific and getting a wall of noise in return. When search results feel random or off-topic, it’s usually due to poor ranking logic, keyword matching without context, or an engine that doesn't understand user intent.

To fix this, you can use a relevance-focused engine that supports [semantic search](https://meilisearch.com.cn/blog/semantic-search) and contextual ranking.

### 3. Inconsistent tagging and metadata

If your teams aren’t aligned on how they name or tag content, your search engine won’t be either. Imagine one team saving a file as ‘Revenue-Q3-Final’, another calling it ‘Quarterly_Income_July-Sept’, and a third just naming it ‘report123’.

Without a consistent taxonomy and metadata, even a good search engine struggles. The solution is to handle this with customizable filters and flexible schema indexing, so teams can surface the right content even when naming conventions vary.

### 4. Security and permission conflicts

In the case of intranet search engines, there needs to be a balance between access control and usability. An improper setup can expose sensitive organizational data to the wrong individuals. 

Meilisearch supports fine-grained access control and works well with authentication layers, so every employee sees only what they’re supposed to. This keeps both compliance and productivity in check.

Let’s now explore what features truly matter when picking the right intranet search engine.

## What features should you look for in an intranet search engine?

We’ve explained the basic premise of an intranet search engine. But what is the core requirement you must focus on while choosing or building one? 

Let’s have a look below.

![What features should you look for in an  intranet search engine_.png](https://unable-actionable-car.media.strapiapp.com/What_features_should_you_look_for_in_an_intranet_search_engine_5142217683.png)

* **Filters and faceted search:** Helps users narrow down results by department, document type, or date.
* **Natural language support:** Makes search feel intuitive by interpreting everyday phrases rather than just keywords.
* **Typo tolerance:** Users make typing mistakes. Your search tool should still deliver helpful results even with misspellings.
* **Synonym recognition:** Makes sure terms like ‘benefits’ and ‘compensation' or ‘HR’ and ‘People Ops’ lead to the same results.
* **Ranking rules:** Prioritizes high-value content so important information always comes first.
* **Personalization:** Delivers context-aware results by tailoring what’s shown based on department, role, or search history.
* **Access controls:** Ensures users only see content they’re authorized to access, which is key for security and compliance.
* **Speed and scalability:** Results should appear instantly, even with large document volumes or high query traffic.
* **Multi-language support:** Useful for global teams or multilingual workforces needing consistent search experiences across languages.

Now it’s time to look at some of the best out-of-the-box intranet search engine options.


## What are the best out-of-the-box intranet search engines? 

Organizations looking for ready-made intranet search tools have strong options that offer speed, easy integration, and thoroughness. 

**1. Guru**

Guru is a knowledge management platform with an AI-powered intranet search. It connects with Slack, Teams, and internal wikis to give employees fast, verified answers without switching tools.

**2. Coveo**

Coveo delivers smart enterprise search with AI recommendations and analytics. It’s widely used in customer service and knowledge management, with built-in connectors for CRMs and content systems.

**3. Apache Solr**

Apache Solr is a reliable, open-source engine used in many enterprise intranet setups. Its real-time indexing and faceted search capabilities make it ideal for scaling and customizing internal search experiences.

Now, let’s look at the best open-source intranet search engines.

## What are the best open-source intranet search engines? 

When choosing an open-source search engine for your intranet, you want speed and scalability (and maybe customization for advanced users). It should be flexible enough to integrate with your internal systems without requiring a massive DevOps setup.

Here are three of the top picks:

**1. Meilisearch**

Meilisearch wouldn’t be Meilisearch without its lightning-fast performance and developer-friendly setup. Its key features, such as [typo tolerance](https://meilisearch.com.cn/blog/typo-tolerance), semantic search, and ranking rules, make it a prime option in this context, even though it is not specifically built for intranets. 

**2. Typesense**

Typesense is a developer-first alternative that prioritizes simplicity and speed. Its easy-to-deploy architecture and support for real-time updates make it great for teams that want control without the headache of a heavy infrastructure.

**3. OpenSearch**

Forked initially from Elasticsearch, OpenSearch offers top-tier scalability and strong analytics. It’s a fit for enterprises that require a full-text search to go with advanced monitoring, logging, and role-based access. 

Are you looking to build your own intranet search stack? 

Let’s walk through that next.

## How do you create a custom intranet search engine? 

Building your own intranet search engine with Meilisearch gives you complete control and flexibility. You can customize ranking, typo tolerance, and data schema based on your company’s needs. 

Below are clear steps with Go code to get you started:

### 1. Set up Meilisearch and Go client

First things first, let’s start a Meilisearch instance either locally or in a secure cloud environment. 

Then connect from your Go backend using the official SDK:


```go
import "github.com/meilisearch/meilisearch-go"

client := meilisearch.NewClient(meilisearch.ClientConfig{
  Host:   "http://127.0.0.1:7700",
  APIKey: "masterKey",
})
```


This establishes a fast, secure connection for indexing and querying your intranet content.


### 2. Create an index and upload documents

Next, define an index and push your internal documents like PDFs, wiki pages, and support files into Meilisearch:


```go
index := client.Index("intranet_docs")

docs := []map[string]interface{}{
  {"id": "1", "title": "Employee Handbook", "content": "Policies..."},
  {"id": "2", "title": "IT Guide", "content": "Setup instructions..."},
}

task, err := index.AddDocuments(docs)
```


This builds a structured map of your content for typo-tolerant search.


### 3. Configure relevance and search features

Finally, fine-tune the ranking and user experience:


```go
index.UpdateRankingRules(&[]string{
  "typo",
  "words",
  "proximity",
  "attribute",
  "exactness",
})

index.UpdateSynonyms(&map[string][]string{
  "hr": {"human resources"},
})

index.UpdateSettings(&meilisearch.Settings{
  TypoTolerance: &meilisearch.TypoTolerance{Enabled: meilisearch.Bool(true)},
})
```


With these three steps, you’ve built a search engine powered by Meilisearch that’s fast and specific for your intranet.

## How do you choose the right intranet search engine for your needs?

Not all intranet search engines are built the same. Some are plug-and-play. Others give you complete control. The right choice depends on your team’s technical skill, budget, and internal complexity. 

Here’s a quick look at the differences across the three main types: out-of-the-box, open-source, and custom-built intranet search engines.

![How do you choose the right intranet search engine for your needs_.png](https://unable-actionable-car.media.strapiapp.com/How_do_you_choose_the_right_intranet_search_engine_for_your_needs_aeb63c5ee9.png)

Next, we’ll look at how to get the most out of your intranet search engine performance.


## How do you optimize intranet search engine performance?

Even the best intranet search engine needs regular tuning to stay on point. As your organization evolves, so do its data, tools, and user behavior, making room for some much-needed optimization.

Let’s explore some of the most impactful ways to optimize performance:


### 1. Add rich metadata to your content

Metadata helps search engines understand each document's content. It adds context like document type, department, author, or publication date to improve indexing and ranking. When metadata is structured and consistent, users find what they need faster.

Example:


```json
{
  "title": "Employee Benefits 2025",
  "type": "HR Document",
  "author": "Jane Smith",
  "tags": ["benefits", "healthcare", "HR"],
  "department": "Human Resources"
}
```


In Meilisearch, you can include metadata as part of the searchable attributes and use ranking rules to boost results based on priority fields like department or publication date.


### 2. Enable typo tolerance and synonym matching

Employees make mistakes when typing, especially on internal acronyms or jargon-heavy terms. Typo tolerance helps capture near matches, while synonym support enables users to get hits for terms like ‘vacation’ and ‘PTO.’

Meilisearch example:


```bash
curl -X POST 'https://:7700/indexes/docs/settings/synonyms' \
--data '{
  "pto": ["paid time off", "vacation"],
  "hr": ["human resources"]
}'
```


This creates a smoother, more forgiving search experience without requiring perfect spelling or phrasing.


### 3. Keep your content regularly indexed

Outdated or missing records frustrate users. To avoid this, you need to make sure your search engine updates its index frequently to reflect new or edited content. For fast-changing data, set up an automated schedule or trigger-based indexing.

Example script for Meilisearch using Node.js:


```javascript
const { MeiliSearch } = require('meilisearch')

const client = new MeiliSearch({ host: 'https://:7700' })
const index = client.index('documents')

// Assuming newDocuments is your latest content
await index.addDocuments(newDocuments)
```


This keeps search results fresh and relevant as your organization grows.


### 4. Use user behavior to refine results

Analytics can tell you what users are searching for, what they’re clicking on, and where they’re dropping off. That data can help identify gaps in relevance and update synonyms, filters, or ranking rules accordingly.

Insightful metrics to track include:

* Click-through rates on search results
* Queries with no results
* Most common terms per department

Over time, this feedback loop and strategic refinement will significantly improve performance.


### 5. Fine-tune ranking rules

In Meilisearch, ranking rules control how search results are ordered. You can prioritize by freshness, department, popularity, or even metadata tags to guarantee that internal resources always rise to the top.

Sample ranking rule order:


```json
[
  "words",
  "typo",
  "proximity",
  "attribute",
  "exactness",
  "desc(date_published)"
]
```


You can adjust this to reflect how your team searches and what matters most.

## Building a smarter intranet search experience

A powerful intranet search engine unlocks your team’s full potential. When information is buried, scattered, or outdated, frustration sets in and productivity suffers.

The right solution brings clarity to the chaos. It helps employees find the knowledge they need quickly, accurately, and securely so they can focus on meaningful work.

Whether upgrading your current system or building one from scratch, investing in smarter search is one of the most effective ways to boost efficiency across your organization.

Intranet search engines: What you need to know in 2025

We’re thrilled to announce the release of Meilisearch 1.16. In this article, we’ll highlight the key new features: multi-modal embeddings, exporting to other instances, and improvements to the documents API.

For an exhaustive listing of the changes, please consult the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.16.0) on GitHub.


<Callout intent="tip">

Meilisearch 1.16 is coming to [Meilisearch Cloud](https://meilisearch.com.cn/cloud) on August 19th. Reach out if your team needs early access!

</Callout>

## New: Multi-modal search and embeddings

Meilisearch 1.16 introduces the new **fragments API**. This allows you to deconstruct documents and search queries into distinct semantic parts, or “fragments.“

Leveraging fragments, you can now create embeddings based on semantically different parts of the document and build multimodal search. For example, this allows users on [ecommerce sites and marketplaces](https://meilisearch.com.cn/solutions/digital-commerce) to find products by describing them.

<Callout intent="tip">

Multi-modality is currently experimental. Learn how to [enable experimental features](https://meilisearch.com.cn/docs/learn/resources/experimental_features_overview).

</Callout>

Let’s take the example of a movie document with the following structure:

```json
{
  "title": "Star Wars",
  "description": "A long time ago, in a galaxy...",
  "image_url": "https://images.com/star-wars.jpg"
}
```

We want to use [Voyage AI](https://meilisearch.com.cn/docs/guides/embedders/voyage) to generate embeddings at indexing time as follows:
- At indexing time — Create a `text` embedding based on title and description as text, and create an `image` embedding based on the image URL
- At search time — Allow matching `text` based on a text query and `image` based on an inlined image

The payload below allows [updating embedder settings](https://meilisearch.com.cn/docs/reference/api/settings#update-embedder-settings) accordingly:

```json
{
	"voyage": {
		"source": "rest",
		"url": "https://api.voyageai.com/v1/multimodalembeddings",
		"apiKey": "$VOYAGE_API_KEY",
		// describes how we index documents
		"indexingFragments": {
			"text": {
				"value": {
					"content": [
						{
							"type": "text",
							"text": "A movie titled {{doc.title}} whose description starts with {{doc.overview|truncateWords:20}}."
						}
					]
				}
			},
			"image": {
				"value": {
					"content": [
						{
							"type": "image_url",
							"image_url": "{{doc.poster}}"
						}
					]
				}
			}
		},
		// describes how to search in the index
		"searchFragments": {
			"image": {
				"value": {
					"content": [
						{
							"type": "image_base64",
							"image_base64": "data:{{media.image.mime}};base64,{{media.image.data}}"
						}
					]
				}
			},
			"text": {
				"value": {
					"content": [
						{
							"type": "text",
							// uses the `q` field from search queries
							"text": "{{q}}"
						}
					]
				}
			}
		},
		"request": {
			"inputs": [
				"{{fragment}}",
				"{{..}}"
			],
			"model": "voyage-multimodal-3"
		},
		"response": {
			"data": [
				{
					"embedding": "{{embedding}}"
				},
				"{{..}}"
			]
		}
	}
}
```

In the indexing fragments, the `value` object depends on the embedding API. In this example, it adheres to the [Voyage AI API](https://docs.voyageai.com/reference/multimodal-embeddings-api).

With these settings in effect, you can [make a search request](https://meilisearch.com.cn/docs/reference/api/search) using image data as follows:

```json
{
  "media": {
    "image": {
      "mime": "image/jpeg",
      "data": "/9j/4AAQSkZJRgABAQAAAQABAAD/2w... images bytes encoded as base64"
    },
  "hybrid": {
    "embedder": "voyage"
  }
}
```

You can also perform a [hybrid search](https://meilisearch.com.cn/docs/reference/api/search#hybrid-search) using a text query. Note that since the Voyage model we’re using here is multi-modal, Meilisearch will also compare the generated embeddings with the movie image. This means that describing the image could allow finding the movie.

```json
{
  "q": "A movie with lightsabers in space",
  "hybrid": {
    "embedder": "voyage",
    "semanticRatio": 0.5
  }
}
```

## New: Transferring documents between Meilisearch instances 

Meilisearch 1.16 introduces a new **exports API** to transfer documents from one instance to another. This new API does not require creating a dump or a snapshot. The goal is to ease the migration from a local environment to a production [Meilisearch Cloud](https://meilisearch.com.cn/cloud) project and minimize deployment overhead.

Consult the documentation for more information about using the [exports API](https://meilisearch.com.cn/docs/reference/api/export).

## New: Sorting on the documents API

Meilisearch 1.16 brings sorting to the documents API. The sorting behaves exactly like the sorting with the search API. This improves the administrative toolkit to manage your Meilisearch instance. Consult the documentation for more information about using the [documents API](https://meilisearch.com.cn/docs/reference/api/documents).

## ICYMI: Conversational search

In Meilisearch 1.15.1, we introduced [conversational search](https://meilisearch.com.cn/docs/learn/chat/getting_started_with_chat). This new feature allows you to get a functioning RAG pipeline by chatting with your Meilisearch instance via the [Chats API](https://meilisearch.com.cn/docs/reference/api/chats). Check it out!

## Contributors shout-out

We want to give a massive thank you to the contributors who made this release possible. Special thanks [@martin-g](https://github.com/martin-g), [@lblack00](https://github.com/lblack00), [@mcmah309](https://github.com/mcmah309), [@nnethercott](https://github.com/nnethercott), [@arthurgousset](https://github.com/arthurgousset), [@Mubelotix](https://github.com/Mubelotix), [@diksipav](https://github.com/diksipav), [@Nymuxyzo](https://github.com/Nymuxyzo), [@kametsun](https://github.com/kametsun) for their contributions to [Meilisearch](https://github.com/meilisearch/meilisearch) and to [@nnethercott](nnethercott) for their contribution to [Arroy](https://github.com/meilisearch/arroy).

---

And that’s a wrap for v1.16! These release notes only highlight the most significant updates. For an exhaustive listing, refer to the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.16.0) on GitHub.

---

For more information, subscribe to our [monthly newsletter](https://dub.sh/meili-newsletter#release-v1-16&utm_source=blog), or join our [Product Discussions](https://github.com/orgs/meilisearch/discussions).

For anything else, join our developers community on [Discord](https://dub.sh/meili-discord#release-v1-16&utm_source=blog).

Meilisearch 1.16

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

## 💬 Introducing conversational search

[![Conversational search](https://unable-actionable-car.media.strapiapp.com/conversational_search_cb1af6a9e5.jpg)](https://meilisearch.com.cn/docs/guides/ai/getting_started_with_chat)

Learn to build conversational search using Meilisearch's chat completions. 

[Read the guide](https://meilisearch.com.cn/docs/guides/ai/getting_started_with_chat)

## 📰 In the news

### 🫣 Meilisearch 1.16 preview

Get a sneak peek at what's coming in v1.16—releasing August 4th.

[Read the changelog](https://github.com/meilisearch/meilisearch/releases)

### 💳 Same Meilisearch, new pricing

ICYMI, you can get early access to our resource-based model. Check it out!

[Discover new pricing](https://meilisearch.com.cn/pricing/platform)

### 💥 Most personalized search experiences are a lie

How to implement search personalization the simple, effective way.

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

### 🔍 Mastering RAG: unleashing precision and recall

Enhance LLM accuracy using RAG with Meilisearch's hybrid search capabilities.

[Read the blog post](https://meilisearch.com.cn/blog/mastering-rag)

### 🔥 How to implement search in Firebase

A short step-by-step tutorial to get you started with Firebase and Meilisearch.

[Read the tutorial](https://meilisearch.com.cn/blog/firebase-search)

---

_We’re always looking to promote new projects from our [Discord community](https://dub.sh/meili-discord#newsletter&utm_source=blog&utm_medium=july-25-updates). Share yours!_

---

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

Meilisearch July updates

Semantic search vs Vector search: Key differences, uses, & more

Elasticsearch vs Typesense (vs Meilisearch): Which search engine actually fits your needs in 2025?

We’ve been handed an exciting dream—and it hasn't quite lived up to expectations. 

With the rapid growth of AI, big names like Google promised a revolution in how we discover information. 

Search was meant to become faster, smarter, and more tailored to us. 

Yet, here we are, still wading through unrelated suggestions and one-size-fits-all recommendations. 

Personalized search? Perhaps more like personalized guesswork. 

So, what went wrong? Let’s explore it together. 

## What most "personalized" search experiences actually do

Every rose has its thorn. And so do personalized search engines. 

What’s sold under the sweet sauce of “customization” is often just a simple data retrieval. 

And even then, chances are you won’t get what you’re looking for. 

Why does this happen?

Here are a few reasons:

### Reason #1: Words set in stone

Personalized search engines often follow a hard-coded word order, preconditioning the final results. 

The [Prozis e-commerce company](https://www.prozis.com/) search engine relies on this rule to search for products. 

For instance, if we search for “nut butter for keto diet,” the results are ordered as “hazelnut butter,” “pistachio butter,” and “almond butter.” 

![Prozis e-commerce company search engine.png](https://unable-actionable-car.media.strapiapp.com/Prozis_e_commerce_company_search_engine_b24a69f8dd.png)

Image Source: [Prozis](https://www.prozis.com/)

But here’s the problem.

Hazelnut and pistachio butters, listed as first and second, are not keto-friendly, while almond butter, which actually is ketogenic, comes in third. 

What you see here is relevance ranking. 

The order of words predetermines and prioritizes the search results that closely match the query. 

Yet, something crucial is missing in this case: user intent. 

The next point on our list is about the same issue. 

### Reason #2: All eggs in one basket 

Oftentimes, it’s not the word order that creates stumbling blocks in personalized search. 

It’s an oversimplified user segmentation. 

Personalized search engines often group users into broad categories (e.g., “tech shoppers”, “outdoors enthusiasts”). 

And let’s be honest, it’s easier that way. 

However, the outputs we get are inaccurate and irrelevant recommendations. 

After all, there are nuances in everything. Let’s say two people are outdoor enthusiasts; one loves hiking, but the other hates getting on the trail and prefers luxurious glamping. 

Both belong to the same group. But are they really the same?

Streaming services are guilty of this, and [Netflix](https://www.netflix.com/) is a good example. 

Upon registration, you must choose three movies/TV shows you like. 

![Netflix collecting user preferences.png](https://unable-actionable-car.media.strapiapp.com/Netflix_collecting_user_preferences_3e0362f5b3.png)

Image Source: [Netflix](https://www.netflix.com/)

If you go for a selection of medical shows and series about law and law enforcement, guess what you’ll get. 

![Netflix top pics for you.png](https://unable-actionable-car.media.strapiapp.com/Netflix_top_pics_for_you_ec86072c2b.png)

Image Source: [Netflix](https://www.netflix.com/)

But do these three picks truly reflect *all *of your viewing preferences?

Hardly. 

Yes, you might like some shows about law enforcement, but you might also hate watching *Dexter*—a crime show—because it’s too gruesome. 

That’s not all, though. 

If you look closer at the shows suggested in the image above, you’ll see that some of them have been around for a while (like *House, Prison Break, *or* Suits)*, and you may have seen them already.  

Thus, the Netflix algorithm is also guilty of the filter-bubble effect, meaning you won’t be exposed to anything except what you already engage with.

### Reason #3: Money talks

Personalization implies prioritization. 

In our case, the prioritization of the user’s search intent and their interests. 

Most search engines claim they honor this priority. 

But not before they honor their obligations to the advertisers. 

Many online marketplaces follow this logic, and [AliExpress](https://www.aliexpress.us) is a good example. 

When you search for a product, the platform gives you various options, but not until it shows you two rows worth of paid ads. 

![AliExpress product search.png](https://unable-actionable-car.media.strapiapp.com/Ali_Express_product_search_fef4e07fee.png)

Image Source: [AliExpress](https://www.aliexpress.us)

To be fair, marketplaces like AliExpress need to work with advertisers to sustain their business. 

However, overrunning the search results with ads contradicts AliExpress’s claim about curating “a selection of products tailored specifically to you,” as they claim at the bottom of their homepage. 

You can’t expect a user to be satisfied with product recommendations after scrolling through several rows of ads. 

That’s just not what personalization is about. 

## What is true personalization?

The answer seems simple: personalization is about deeply understanding the user's needs. 

The actual matter is, of course, more complex. 

The biggest obstacle to personalized search is analyzing massive amounts of user data to deliver the most relevant search results. 

Brands and marketplaces heavily rely on AI for this task, but it’s not always the answer. 

After all, AliExpress [uses AI to personalize search results](https://www.alibabacloud.com/blog/alibaba-cloud-ai-search-solution-explained-intelligent-search-driven-by-large-language-models-helping-enterprises-in-digital_601971), but its system is far from perfect. 

AI can be a solid foundation for personalizing search results, but this foundation only maintains its integrity if it stands on the following five pillars. 

### Pillar #1: Intent-based personalization

Personalization happens when the user and the service provider have a complete rapport. 

In our case, the key to building this rapport (since a search engine is a machine) lies in Natural Language Processing, or NLP. 

NLP algorithms use [semantic network models](https://meilisearch.com.cn/blog/semantic-search) to understand user intent, which makes personalization possible.

How does it work?

Essentially, semantic search targets the context behind words and analyzes structured data to understand the semantic meaning of the query. 

Amazon’s A9 search engine is probably the best example of this model in action.

Let’s take the key phrase *book emotional intelligence toddler. *

The keyword here is *toddler*, meaning we are not searching for an emotional intelligence guide for adults. 

The search engine picks up on that and shares exactly what we need: several book options for kids to read. 

![Amazon book search.png](https://unable-actionable-car.media.strapiapp.com/Amazon_book_search_d9ec09968e.png)

Image Source: [Amazon](https://www.amazon.com/)

We also tested our previous peanut butter example, and Amazon’s search engine gave only keto-friendly products as top results. 

![Amazon peanut butter search.png](https://unable-actionable-car.media.strapiapp.com/Amazon_peanut_butter_search_9969618bac.png)

Image Source: [Amazon](https://www.amazon.com/)

But do you still get [personalized recommendations](https://meilisearch.com.cn/blog/personalization-recommendations) if there’s a typo in your query?

Let’s talk about it next. 

### Pillar #2: Typo tolerance

It’s hardly a pleasant experience to have to retype your query simply because you made a typo and got the wrong results. 

Search engines use the [latent semantic indexing method](https://meilisearch.com.cn/blog/latent-semantic-indexing) of information retrieval to minimize such occurrences. 

LSI is robust against typos because it relies on semantic meaning to understand hidden concepts. 

And that’s precisely what you need, especially if you have a wide-range product offering. 

[Minipouce](https://www.minipouce.fr/) is a good example. 

Below, we intentionally made a typo in the word *ring *but still got relevant results. 

![Minipounce typo in search.png](https://unable-actionable-car.media.strapiapp.com/Minipounce_typo_in_search_9add534c79.png)

Image Source: [Minipouce](https://www.minipouce.fr)

Many products in the company’s catalog have similar names, which only increases the chance of making a typo. So Minipouce [used Meilisearch’s open-source version](https://meilisearch.com.cn/blog/minipouce-top-grade-customer-experience) to optimize the product search for relevant results every time. 

### Pillar #3: Real-time adaptive learning

The results for a query should change dynamically during the interaction between the user and the search engine rather than simply relying on static filters. 

Why?

Interaction of any kind is never static.

A user’s preferences and behavior may change while searching for the right product or information, and true personalization must take this into account. 

That’s why it’s essential for a search engine to employ real-time adaptive learning. See how it works in a Meilisearch-powered search engine below.

![dynamic search with AI.gif](https://unable-actionable-car.media.strapiapp.com/dynamic_search_with_AI_b553f2e7b8.gif)

How does it work?

It’s a complex process, but we can break it down to three main steps:

* **Collecting and analyzing user data.** A search engine first collects information on user searches and related interactions to lay the ground for future personalization. 
* **Adjusting the algorithm.** The collected data and its analysis impact the ranking, related searches, and other search algorithm elements to provide the results based on particular intent. 
* **Adapting the results.** As a user further interacts with a search engine, it adapts its behavior to generate and prioritize relevant results to suit the user’s changing preferences. 

Of course, user behavior is not the only factor impacting the relevance of search results. 

The content a search engine is working with also matters. 

Consequently, so does the information retrieval method it uses. 

Let’s talk about it next. 

### Pillar #4: Correct information retrieval method

Information retrieval (IR) refers to the process of finding and retrieving relevant data. 

This process consists of three steps, which you can see below. 

* **Step #1:** Analyzing unstructured data, such as web pages and text documents. 
* **Step #2:** Indexing the data to make it structured, then processing the query to match the index. 
* **Step #3:** Ranking the query results based on relevance. 

![Process behind information retrieval methods.png](https://unable-actionable-car.media.strapiapp.com/Process_behind_information_retrieval_methods_3bdeb3ac9b.png)

You are already familiar with some IR methods, such as LSI mentioned above. 

And, as you may have noticed, they interpret the content a bit differently. 

[Semantic search](https://meilisearch.com.cn/blog/choosing-the-best-model-for-semantic-search) focuses on a query’s intent and contextual meaning, which makes it particularly great for web search. 

LSI is a variation of semantic search that finds hidden concepts in words and documents. Thus, it’s ideal for tasks such as document clustering.  

There’s also [neural search](https://meilisearch.com.cn/blog/neural-search) that employs deep neural networks (DNNs) to understand the context behind a search query. 

Neural search differs from the above methods in its complexity. It explores contextual relations on a more nuanced level, which makes it better for search engines involving conversational queries. 

There is also [hybrid search](https://meilisearch.com.cn/blog/hybrid-search), a blend of all aforementioned models, which is often used in enhanced information retrieval systems. 

What about more real-life uses for each of these IR methods?

Here are some suggestions. 

![Use cases for information retrieval systems.png](https://unable-actionable-car.media.strapiapp.com/Use_cases_for_information_retrieval_systems_df58d9c62f.png)

These are, of course, just a few examples, as IRs can have way more applications. 

But there’s one thing that unites all of them. 

No matter what IR a search engine uses, it deals with personal user data. 

And that calls for privacy concerns. 

Let’s talk about that next. 


### Pillar #5: Respect for privacy

It’s no secret that AI-powered search engines rely on machine learning to provide the most accurate results. 

This, of course, implies that they analyze data from millions of searches and have to examine user data.

But how can you ensure privacy while maintaining the search engine’s ability to provide top-tier personalization?

The following strategies help get this job done. 

* **Data encryption:** protecting the data from third parties by encrypting it at rest and in transit. 
* **Access controls:** introducing multi-factor authentication and role-based permissions. 
* **Limited data sharing:** regulating data sharing with third parties. 
* **Federated learning:** training AI to learn from new system updates instead of raw user data.
* **Effective anonymization:** preventing user de-anonymization by hiding personally identifiable information. 

The key point, of course, is to ask for user permission to use any data they share and, if they change their mind later, to give them complete control over how their information is processed. 

## Build a strong foundation for personalized search

True personalization isn’t just about serving the results that *seem* tailored. 

Most so-called personalized searches fall short because they prioritize static logic, broad segmentation, and advertiser interests instead of user intent. 

But not all is lost. 

Grounding personalization in NLP, using correct information retrieval methods, and, most importantly, respecting privacy are the keys to delivering search experiences that truly matter.

Most personalized search experiences are a lie

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://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/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.

Meilisearch 最新消息和公司动态

什么是 RAG（检索增强生成）及其工作原理？

什么是搜索相关性：你需要了解的一切

站内搜索：定义、实现、最佳实践及更多

内网搜索引擎：2025年你需要了解的一切

Meilisearch 1.16

Meilisearch 七月更新

语义搜索与向量搜索：主要区别、用途及更多

Elasticsearch vs Typesense（vs Meilisearch）：2025年哪款搜索引擎最适合你的需求？

大多数个性化搜索体验都是谎言

掌握 RAG：使用 Meilisearch 的混合搜索释放精确度和召回率