We’d like to share an important announcement: Meilisearch is moving to a dual licensing model to better serve both our community and enterprise users.

Meilisearch has been an open source project from the beginning, and it is thanks to our users and community that we have come this far, which is why it’s important to emphasize that **we’re not abandoning open source.**

Open source remains at the heart of Meilisearch. This licensing change simply allows us to grow sustainably while keeping core innovations free and accessible. Major developments in our search engine will continue to be part of the open source engine, and we will also continue to build and support our developer SDKs.

This new license is part of a broader strategic effort that enables us to enhance our enterprise and cloud offering. Being able to engage with large business willing to pay for our technology will enable us to continue building in the open and supporting the community.

## Why a new license?

Our vision for the enterprise license is to serve business needs while ensuring open source remains fully accessible for developers. 

**The enterprise license will be limited exclusively to features that are only relevant to large businesses with advanced security and observability needs.** 

In particular, these are features that:

- Target large-scale deployments with lots of data – such as sharding
- Dramatically increase ROI or boost conversion rates – such as analytics
- Provide new and enhanced security-related capabilities – such as fine-grained access controls

To be more transparent, the new license also allows us to delve deeper into experimental product features more freely and also aligns with our strategic roadmap. Here’s how we think it’s going to help our business:

- Open up opportunities in new verticals where customers need to self-host due to complex security concerns or regulations
- Provide a path for large enterprises already self-hosting at scale to gain more value. For example, there are massive companies with 200+ Meilisearch servers that we believe could benefit from enterprise-ready features and dedicated support – we want to better serve them with these new offerings.
- Create a clear separation: open source for developers, and the enterprise edition for larger businesses with specific security, scale, and ROI requirements

<Callout intent="tip">

Free EE licenses will be available for indie projects and non-profits upon request.

</Callout>

This new license comes as a part of version 1.19, and as we move forward, we’d like to highlight that we will continue to work closely with the community to iterate on this license and the pricing model that comes with it.

## In conclusion: What’s changing?

We’re now going to have two licenses:

- **Community Edition (CE)** → Remains fully open source (MIT). Everything developers need to build and experiment, available at no cost.
- **Enterprise Edition (EE)** → Enterprise-grade features under the Business Source License (BUSL), designed for scaling, advanced security, and observability.

**Our goal is simple**: Keep Meilisearch open source and free of charge, while also meeting the needs of enterprise customers who rely on Meilisearch at massive scale. We want to work towards a future where developers and businesses both thrive with Meilisearch.

<Callout>

If you have any thoughts or questions, we encourage you to open a discussion on [Discord](https://discord.com/invite/hTD5hU2yWV).

</Callout>

Introducing the Meilisearch Enterprise Edition license

Meilisearch uses sharding to distribute a single index across multiple server instances, thereby going beyond the limits of a single machine. This enables you to handle massive datasets and high-traffic loads by scaling your search infrastructure horizontally.

This guide will walk you through what sharding is, how it benefits you, and how to implement it step-by-step.

## How Meilisearch sharding works

Meilisearch sharding is designed for simplicity and robustness. Instead of you manually splitting data, Meilisearch handles the distribution automatically.

When you send a batch of documents to any node in your sharded cluster, the receiving node instantly forwards the *entire payload* to every other node. Each node then independently decides which documents it's responsible for and only indexes its assigned subset.

This design was chosen for its reliability. It avoids a single point of failure for data distribution and simplifies the logic, ensuring that every node has the opportunity to process the data without complex coordination. 

<Callout intent="tip">
This also means you can send your indexing tasks to any node, making it easy to load balance your writes.
</Callout>

### Distribution algorithm

To ensure a document is always stored on the same shard, Meilisearch uses a consistent hashing algorithm (**Rendezvous Hashing** using `twox-hash`) on each document's **primary key**.

For this algorithm to work,  **you must set a `primaryKey` for your index before adding documents.** The `primaryKey` is the unique identifier used as the input for the hash function. Without it, Meilisearch cannot guarantee that a specific document will consistently land on the same shard, which would lead to data duplication and inconsistencies.

### Important: Enterprise Edition and licensing

Sharding is an advanced feature available exclusively in [Meilisearch Enterprise Edition](https://www.meilisearch.com/blog/horizontal-scaling-with-sharding) (EE). All [Meilisearch Cloud](https://meilisearch.com/cloud) users get access to Enterprise Edition features.

**A note on self-hosting**: The EE features are governed by the **Business Source License 1.1**, which allows you to use, test, and develop with sharding for free in non-production environments. A commercial license agreement with Meilisearch is required to use sharding in a production environment.

<Callout intent="tip">
To get started with Meilisearch Enterprise Edition, [get in touch](mailto:sales@meilisearch.com).
</Callout>

## How to set up sharding

### Prerequisites

1.  **Meilisearch Enterprise Edition**: Ensure you are running a version of Meilisearch that includes this feature (v1.19+).
2.  **Identical Setup**: All Meilisearch instances in your cluster must run the exact same version and share the same `MEILI_MASTER_KEY`.
3.  **Primary Key**: The index you intend to shard **must** have a `primaryKey` configured before you begin adding documents.

<Callout intent="tip">
As of Meilisearch 1.19, network and sharding are experimental features. See how to [enable experimental features](https://www.meilisearch.com/docs/learn/resources/experimental_features_overview#activating-experimental-features).
</Callout>

### Step 1: Configure the network on each node

The sharding feature is enabled and configured by using the network API. First, you must [update the network](https://www.meilisearch.com/docs/reference/api/network#update-the-network-object) of **all nodes** in your cluster to enable sharding.

**On all nodes:**

```json
{
  "sharding": true
}
```

Then, you need to configure each node to make it aware of the network topology: give it a name and list the other nodes it will communicate with. For a 3-node cluster, [update the network](https://www.meilisearch.com/docs/reference/api/network#update-the-network-object) as follows:

**On `node-1`:**

```json
{
  "self": "node-1",
  "remotes": {
    "node-2": { 
      "url": "http://node-2-address:7700", 
      "searchApiKey": "your-search-api-key",
      "writeApiKey": "your-write-api-key"
    },
    "node-3": { 
      "url": "http://node-3-address:7700", 
      "searchApiKey": "your-search-api-key",
      "writeApiKey": "your-write-api-key"
    }
  }
}
```

*(Repeat this for `node-2` and `node-3`, updating the `self` value and `remotes` accordingly.)*

*   `self`: A unique name for the current node. 
*   `remotes`: A map of all other nodes in the network.
*   `writeApiKey`: This API key must have the `documents.add` permission and is used to securely authorize the forwarding of documents between nodes.
* `searchApiKey`: This API key must have permission to search in the relevant indexes.

#### Step 2: Add documents as usual

You add documents the same way you always have, by sending a request to `/indexes/{index_uid}/documents`. You can send this request to **any node** in the cluster. Meilisearch handles the rest under the hood.

```bash
curl -X POST 'http://node-1:7700/indexes/movies/documents' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  --data-binary @movies.json
```

#### Step 3: Monitor the distributed task

The task response has been enhanced to give you visibility into the distributed operation. The task object now includes a root-level `network` field.

When you query the task on the original node, you will see the status of the operation on the other shards:

```json
{
  "uid": 123,
  "status": "processing",
  // ... other task fields
  "network": {
    "remoteTasks": {
      "node-2": { "taskUid": 56 },
      "node-3": { "taskUid": 89 }
    }
  }
}
```

#### Step 4: Search your distributed index

To search against a distributed index, you need to use [federated search](https://www.meilisearch.com/docs/learn/multi_search/performing_federated_search) to make queries against multiple indexes and consolidate results in a single response. 

In practice, this can be done by making a multi-search request against multiple nodes. The request parameters need to be similar, except for the network configuration. In our example, the [multi search request](https://www.meilisearch.com/docs/reference/api/multi_search) would look like this:

```json
{ 
  // enables federated search
  "federation": {},
  "queries": [ 
    { 
      "indexUid": "movies", 
      "q": "star wars",
      "federationOptions": { 
        "remote": "node-1" 
      }
    }, 
    { 
      "indexUid": "movies", 
      "q": "star wars",
      "federationOptions": { 
        "remote": "node-2" 
      }
    }, 
    { 
      "indexUid": "movies", 
      "q": "star wars",
      "federationOptions": { 
        "remote": "node-3" 
      }
    }
  ] 
}
```

## Moving forward

Sharding is a powerful feature that enables horizontal scaling and high availability for your search infrastructure. By distributing your index across multiple nodes, you can handle larger datasets and higher query loads with ease. 

We’re looking forward to seeing sharding evolve thanks to early adopters’ feedback. Our roadmap includes supporting dynamic network topology changes, automatic settings propagation, and improving multi-search on sharded nodes.

Meilisearch Cloud users can get started by asking the support to enable sharding for their projects. For companies interested in self-hosting Meilisearch Enterprise Edition, [get in touch with our sales team](mailto:sales@meilisearch.com).

Horizontal scaling with sharding

RAG techniques help optimize the accuracy and flexibility of RAG pipelines. From smarter chunking to hybrid search and context distillation, these methods are key to delivering faster, more accurate responses in real-world AI applications.

Why do we need them?

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

When the retrieval system cannot surface relevant information, users lose trust, and your LLM wastes time processing the wrong context.

This guide breaks down nine advanced RAG techniques worth knowing:

* Text chunking
* Reranking
* Leveraging metadata
* Hybrid search
* Query rewriting
* Autocut
* Context distillation
* Fine-tuning the large language model (LLM)
* Fine-tuning the embedding models

You’ll also learn how to implement these strategies using tools like Meilisearch, LangChain, and vector databases, plus how to evaluate which ones actually move the needle. 

Let’s get into it.

![A table listing the most important advanced RAG techniques.](https://unable-actionable-car.media.strapiapp.com/Advanced_RAG_techniques_9ce2dce000.png)

## 1. Text chunking

Text chunking breaks long documents into smaller pieces (‘chunks’) that are easier to index and retrieve. 

Instead of pulling in whole documents, RAG pipelines work with these chunks, and the quality of the chunks directly affects retrieval accuracy and answer clarity.

If your chunks are too long, the artificial intelligence model will get distracted. On the other hand, if they’re too short, context will be lost. The right balance helps deliver the best results.

Here are a few types of chunking:

* **Simple chunking:** Splits documents into fixed-size blocks with a bit of overlap (e.g., 35 characters with a five-character overlap). Easy to implement, ignores semantic structure, and may split key ideas across chunks.
* **Semantic chunking:** Groups sentences by similarity using embeddings and cosine thresholds. Keeps related ideas together and improves retrieval precision, but requires embedding models like BERT and higher-performance computing.
* **Language model–based chunking:** Uses an LLM to segment text into self-contained propositions. Produces highly coherent results but is computationally expensive and may require fine-tuning.

Not to anyone’s surprise, each method has its trade-offs. Semantic or LLM-based chunking will likely pay off if you work with product manuals or technical docs. For simpler content, fixed-size chunks will do the job just fine.

## 2. Reranking

In RAG systems, the initial retriever pulls in a wide net of retrieved information, some good and some not so good. Reranking is the process of reordering results so that the most relevant information rises to the top before being passed to the LLM.

Here are a few common approaches to reranking:

* **Cross-encoder reranking:** Feeds the user query and each candidate chunk into a transformer model (like BERT) that scores how well they match. Very accurate but slow and resource-intensive. Best when quality matters more than latency.
* **Score-based reranking:** Adjusts order using heuristics or relevance scores (e.g., BM25 boosts, keyword search matches). Fast and lightweight, but less nuanced.

Both techniques are valid, but your choice depends on how much latency you can afford. 

## 3. Leveraging metadata

Leveraging metadata means using structured tags, like date, author, domain, or document type, to filter and boost the right results. 

Metadata filtering is a low-lift, high-impact technique since it doesn’t require any heavy computing.

Here are its key sub-types:

* **Date filtering** removes outdated data and only focuses on recent documents. This is useful in fast-changing fields like finance. However, this focus on recency can sometimes exclude essential documents. 
* **Author/source filtering** boosts retrieved documents from trusted individuals or sources. There’s a very low chance of hallucinations, but you might also miss out on less well-known but highly relevant data.
* **Document type filtering** includes filters based on format (e.g., guide vs. blog vs. policy doc). While it can help match user intent, there’s an added risk of over-filtering if metadata is inconsistent.


## 4. Hybrid search

[Hybrid search](https://www.meilisearch.com/blog/hybrid-search) combines keyword-based (sparse) and vector-based (dense) retrieval methods to improve result quality. 

This dramatically increases relevance, especially in edge cases or ambiguous user queries.

Here are the two main approaches to hybrid search:

* **Score fusion:** Combines results from sparse and dense methods using weighted scores. Balanced accuracy. Needs careful tuning to avoid noisy results.
* **Result merging:** Retrieves top results from both methods, then merges and reranks them. Simple to implement. Risk of duplication or inconsistent ranking logic.


## 5. Query rewriting

Query rewriting refines user input before the retrieval process. It reformulates vague or underspecified queries so the retrieval system can better understand intent and return more relevant results. This is especially helpful when dealing with short or typo-heavy queries.

Most modern generative AI systems use various algorithms to upgrade queries behind the scenes. Here are a few types:

* **Synonym expansion:** This technique automatically adds equivalent terms to cover more variations. While this may improve recall, it can also introduce some irrelevant matches.
* **Spelling correction:** Any typos or misspellings are automatically fixed. It boosts success for casual users, but there’s a chance it might ‘correct’ niche or valid jargon.
* **Intent clarification:** This process transforms a broad query into a clearer one using rules or machine learning. It improves relevance but requires training data and adds complexity.


## 6. Autocut

Autocut trims text dynamically based on token limits or model constraints, without cutting into semantic meaning. There’s a method for removing the less relevant context without displacing the critical info. 

This matters because many LLMs have strict token limits. If you overload the context window, the AI model may hallucinate, skip over key info, or underperform. 

Here are two common strategies for autocutting:

* **Scored trimming** helps rank content by importance and cuts the lowest-scoring sections. While the prioritization is smart, it needs a scoring mechanism in place.
* **Rule-based trimming** applies fixed rules (e.g., drop intro paragraphs or footnotes). It’s easy to implement, but it lacks adaptability to nuanced content.

## 7. Context distillation

Parsing large documents at every instance isn’t optimal for high-level RAG systems. Context distillation helps condense large documents into high-value, meaningful summaries. 

As you know, LLMs only require the *right* information, not *all* the information. More context doesn’t necessarily mean better results; it might even dilute the final output. Context distillation helps the model stay focused and accurate when it comes to response generation.

Two ways to approach this:

* **Summarization-based distillation** uses extractive or abstractive summarization to retain key points. Produces concise context but may miss details.
* **Question-driven distillation** tailors context based on the specific question being asked. Highly relevant, but depends on accurate query understanding.

## 8. Fine-tuning the LLM

Fine-tuning the LLM involves retraining a pre-trained [language model](https://www.meilisearch.com/blog/mastering-rag) on your specific datasets to understand better the type of generated responses you want. 

It’s useful when prompt engineering alone can’t guide the model well enough, especially in regulated industries or domain-specific contexts.

* **Supervised fine-tuning:** Retrains with labeled Q&A, code, or instructions. Offers precision and control but requires curated data and resources.
* **Reinforcement learning from human feedback:** Humans rate outputs, and the model learns to favor preferred responses. Aligns with values or brand tone but is resource-intensive.

## 9. Fine-tuning the embedding models

Embedding models turn documents into vectors for document retrieval. Fine-tuning them means reshaping how the retrieval model ‘understands’ similarity, which is essential if off-the-shelf embeddings underperform in your field.

* **Contrastive learning:** Trains embeddings to pull semantically similar text closer and push dissimilar text apart. Improves retrieval accuracy but requires labeled positives and negatives.
* **Domain adaptation:** Continues training on your corpus to align embeddings with your field. Easier to set up, especially with unlabeled data, but risks overfitting.

Fine-tuning the LLM and embedding models gives you complete control over both retrieval and generating responses, setting the foundation for a high-performing, domain-aware RAG model.

## What are advanced RAG techniques?

Advanced RAG techniques go beyond the basics of retrieval-augmented generation. They are more detailed and nuanced when it comes to chunking, retrieval, and ranking content. The end goal, however, is the same: to generate better and more relevant search results. 

Whether you're optimizing hybrid search, rewriting queries, or tweaking metadata, these approaches build on the core principles of[ retrieval-augmented generation](https://www.meilisearch.com/blog/what-is-rag) to scale both accuracy and efficiency.

## Why are advanced RAG techniques needed?

The problem with basic RAG setups is that they often struggle with complex queries. Also, they aren’t enough when scaling across diverse datasets or maintaining relevance in high-stakes situations. 

As user expectations grow and LLMs become more central to production-grade workflows, brute-force retrieval is no longer enough. We need smart AI applications to understand nuance and prioritize recent data from trusted sources. 

Advanced techniques help you move from ‘retrieve and hope’ to ‘retrieve with intent.’ They address key pain points like hallucination, latency, and content mismatch, while unlocking improved precision and performance.


## How can you implement advanced techniques in RAG?

You can implement advanced retrieval techniques using different tools, libraries, and frameworks.

Some of the [RAG tools](https://www.meilisearch.com/blog/rag-tools) you can use to implement advanced retrieval-augmented generation techniques are the following:

* Meilisearch
* Weaviate
* LangChain
* Pinecone

Let’s learn a little more about them:


### 1. Meilisearch

Developed with user experience in mind, Meilisearch is an open-source tool that is perfect for implementing advanced RAG pipelines. It supports customizable ranking rules and handles large document collections easily. 

You can implement hybrid search (combining keyword-based and vector search relevance) using Meilisearch’s [hybrid search plugin](https://www.meilisearch.com/solutions/hybrid-search). This balances semantic search understanding with traditional precision.


```json
POST /indexes/products/search
{
  "q": "secure laptop",
  "vector": [0.128, 0.98, 0.45, …],
  "attributesToRetrieve": ["title", "description"],
  "limit": 10
}
```


When dealing with large documents, you can boost [search quality](https://www.meilisearch.com/docs/guides/improve_relevancy_large_documents) by indexing them as structured chunks:


```json
{
  "title": "AI Compliance Guide",
  "content_chunk": "RAG systems rely on fast indexing and retrieval...",
  "chunk_id": 12
}
```


Meilisearch’s performance and easy integration make it a go-to solution for building smart RAG pipelines without overcomplicating things.


### 2. Weaviate

Weaviate is a vector-native search engine built for high-performance semantic search. It integrates with transformers and embedding models directly, making it a good fit for RAG implementations.


### 3. LangChain

LangChain is a Python/JavaScript framework that chains together LLMs, retrieval components, and tools. It makes RAG workflows modular and configurable.

You can plug in reranking models, write your own query rewriters, and manage chunking pipelines all within one orchestrated flow.


### 4. Pinecone

Pinecone is a managed vector database built for high-scale similarity search. It’s useful for projects that need lightning-fast, scalable vector retrieval, reranking, and time-filtered queries.

Combined with Meilisearch or LangChain, Pinecone adds scalability and production-readiness to your RAG setup.


## How can you evaluate advanced techniques in RAG systems?

To evaluate advanced RAG techniques, you need to test how each one impacts retrieval quality. The aim is to achieve high precision, context, low latency, and solid real-world usability. 

To assess effectiveness, focus on metrics like:


* **Retrieval accuracy:** Are the most contextually relevant chunks returned? This affects everything downstream, including hallucination rate and answer quality.
* **Latency:** Do techniques like reranking or hybrid search slow down your system? Evaluate end-to-end response time.
* **Precision vs. recall:** Are you returning too few (or too many) relevant documents? You want the sweet spot that balances coverage with focus.
* **User satisfaction:** How often do end users get exactly what they need? Consider running A/B tests or manual evals.

When you’re optimizing for speed without sacrificing quality, Meilisearch’s fast and accurate hybrid engine stands out.


## Why smarter RAG matters in practice

Advanced RAG techniques are ultimately about making information retrieval smarter, not just faster. They help systems move beyond brute-force search toward context-aware retrieval that scales across domains. 

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


9 advanced RAG techniques to know & how to implement them

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

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

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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/), 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://www.meilisearch.com/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://www.meilisearch.com/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 'http://localhost: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: 'http://localhost: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://www.meilisearch.com/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://www.meilisearch.com/solutions/digital-commerce) to find products by describing them.

<Callout intent="tip">

Multi-modality is currently experimental. Learn how to [enable experimental features](https://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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/cloud) project and minimize deployment overhead.

Consult the documentation for more information about using the [exports API](https://www.meilisearch.com/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://www.meilisearch.com/docs/reference/api/documents).

## ICYMI: Conversational search

In Meilisearch 1.15.1, we introduced [conversational search](https://www.meilisearch.com/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://www.meilisearch.com/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?utm_campaign=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?utm_campaign=release-v1-16&utm_source=blog).

Meilisearch latest news and company updates