Here's everything we shipped this month at Meilisearch.

## Horizontal scaling with sharding

[![Horizontal scaling with sharding](https://unable-actionable-car.media.strapiapp.com/horizontal_scaling_with_sharding_792a7928b3.jpg)](https://www.meilisearch.com/blog/horizontal-scaling-with-sharding)

We introduced experimental support for sharding, enabling horizontal scaling. [Read more](https://www.meilisearch.com/blog/horizontal-scaling-with-sharding).

## SOC2 compliance

[![SOC 2 Type II announcement.jpg](https://unable-actionable-car.media.strapiapp.com/SOC_2_Type_II_announcement_fc6def3aea.jpg)](https://www.meilisearch.com/blog/soc2-typeii-compliance)

Meilisearch is now SOC2 Type II compliant. [Read more](https://www.meilisearch.com/blog/soc2-typeii-compliance).

## Multi-modal search

[![Example payload for a multi-modal request](https://unable-actionable-car.media.strapiapp.com/multi_modal_request_120e32cdc9.jpg)](https://www.meilisearch.com/blog/meilisearch-1-16#new-multi-modal-search-and-embeddings)

Leverage the new fragments API to get out-of-the-box multi-modal embeddings and search. [Read more](https://www.meilisearch.com/blog/meilisearch-1-16#new-multi-modal-search-and-embeddings).

## Product updates

New search features
- Stabilize the `STARTS_WITH` [filter](https://www.meilisearch.com/docs/learn/filtering_and_sorting/filter_expression_reference#starts-with) with improved performance
- Allow using the `EXIST` filter on `_vectors` fields

DX improvements
- Allow sorting on the [documents API](https://www.meilisearch.com/docs/reference/api/documents)
- Allow renaming indexes via the [index update](https://www.meilisearch.com/docs/reference/api/indexes#update-an-index) and [index swap](https://www.meilisearch.com/docs/reference/api/indexes#swap-indexes) APIs
- Search API responses can now [include query and documents vectors](https://www.meilisearch.com/docs/reference/api/search#display-vectors-in-response)
- New [webhooks API](https://www.meilisearch.com/docs/reference/api/webhooks) to trigger workflows after task processing
- Transfer documents between instances with the [export API](https://www.meilisearch.com/docs/reference/api/export)
- Improved hybrid search performance when using filters

Dashboard improvements
- Login: multiple OAuth providers can now be linked to the same account
- Tasks: allow tasks cancellation from the UI

## In the news

- [Introducing Meilisearch Enterprise Edition](https://www.meilisearch.com/blog/enterprise-license) Meilisearch is moving to a dual licensing model to serve both our community and enterprise users better.

- [What is RAG and how does it work?](https://www.meilisearch.com/blog/what-is-rag) Our complete guide to Retrieval-Augmented Generation.

- [Meilisearch voice search demo](https://voice.meilisearch.com/) Search for electronic products using your voice.

- `_geoPolygon` [filter prototype](https://chantiers-paris.vercel.app/) Check out this map of Paris construction sites built using the upcoming geo filter.

- [Flexible infrastructure pricing](https://www.meilisearch.com/pricing/platform) Customize the infrastructure for your Meilisearch deployment.

---

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

---

## Contributors shout-out

Thanks to [@curquiza](https://github.com/curquiza), [@dureuill](https://github.com/dureuill), [@irevoire](https://github.com/irevoire), [@Kerollmops](https://github.com/Kerollmops) [@LeSuisse](https://github.com/LeSuisse), [@ManyTheFish](https://github.com/ManyTheFish), [@martin-g](https://github.com/martin-g), [@Mubelotix](https://github.com/Mubelotix), and [@qdequele](https://github.com/qdequele) for their contribution to [Meilisearch](https://git.new/meilisearch) 🙌

## We’re hiring

Check out our open position:
- [Senior Software Engineer](https://www.meilisearch.com/careers)

---

Receive this updates in your inbox by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=newsletter&utm_source=blog&utm_medium=august-25-updates). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-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?utm_campaign=newsletter&utm_source=blog&utm_medium=august-25-updates).

August Changelog

RAG (retrieval-augmented generation) represents a way for AI systems to retrieve and use relevant information from external knowledge sources to generate more accurate responses. 

Instead of relying only on training data, RAG uses real-time data (from documents or databases) before generating responses.

Different types of RAG architecture handle various tasks, depending on the level of complexity. 

Some RAG types are simple; they retrieve once and generate an answer. 

Other types require multiple steps (such as retrieving, refining, and re-generating) to improve the quality of their response. 

Here is a table that briefly describes the various RAG types along with their use cases.

![RAG types.png](https://unable-actionable-car.media.strapiapp.com/RAG_types_0be7d3e99b.png)

## 1. Simple RAG (original)

Simple RAG (original) refers to the most basic form of [retrieval-augmented generation](https://www.meilisearch.com/blog/what-is-rag), where the AI system retrieves relevant documents from a knowledge base in a single step and uses that information to generate a response. 

It is the most straightforward implementation.

![Simple RAG (Original).png](https://unable-actionable-car.media.strapiapp.com/Simple_RAG_Original_b58e096a23.png)

Simple RAG works by converting a user query into embeddings, searching a vector database for semantically similar content, retrieving the top matching documents, and then feeding your original question and the retrieved information to a large language model (LLM) for answer generation. The retrieval process is predictable.

Simple RAG is used in basic question answering systems, chatbots, or FAQ automation, where questions have relatively straightforward answers.

**Pros:**

* Fast response times
* Easy to set up and implement
* Low computational cost

**Cons:**

* Struggles with questions requiring multiple sources
* No feedback after generating a response
* Does not improve if the data retrieval is poor

## 2. Simple RAG with memory

RAG with memory refers to an enhanced version of simple RAG that can remember previous conversations. 

In the context of RAG, memory refers to the AI system's ability to keep track of past interactions (such as past questions, answers, or retrieved documents). It does not just remember what was said, but understands how previous context can influence new searches. 

![Simple RAG but With Memory.png](https://unable-actionable-car.media.strapiapp.com/Simple_RAG_but_With_Memory_2d48540c41.png)

Simple RAG with memory works by storing key parts of previous conversations and using them with new queries to generate better answers. 

For instance, if a user asks about the capital of France and later refers to ‘its population,’ the system recalls the context to determine that the user's query is still referring to Paris. 

RAG with memory is used in personal AI agents, conversational chatbots, customer support systems, or educational tutoring platforms.

**Pros:**

* Reduces repetitive explanations
* Encourages more human-like interactions
* Personalizes responses based on user conversation history

**Cons:**

* Higher processing cost than the original simple RAG
* Higher risk of retrieving outdated or incorrect information
* Raises questions about data privacy

## 3. Agentic RAG

[Agentic RAG](https://www.meilisearch.com/blog/agentic-rag) is a more dynamic RAG that acts like an experienced researcher. Instead of just retrieving the first relevant documents, it plans its approach, decides what to investigate, and then takes action using associated tools. 

Agentic RAG works by breaking down a task into smaller steps. It figures out what your question needs and then searches various data sources for valuable information. 

It does not stop at the first result. It checks whether what it found answers the question, and if not, it continues searching. 

![Agentic RAG.png](https://unable-actionable-car.media.strapiapp.com/Agentic_RAG_bc913668a1.png)

Agentic RAG can be used in legal research where lawyers conduct comprehensive case analysis, and in financial analysis that combines market data with regulatory information. Agentic RAG is useful when you require methodical planning.

**Pros:**

* Good for multi-step reasoning
* Intelligent decision-making about information gathering
* Can improve performance on complex queries

**Cons:**

* Costs more to run due to multiple searches
* Difficult to build and manage
* Takes longer to respond since it is doing actual research work


## 4. Graph RAG

[Graph RAG](https://www.meilisearch.com/blog/graph-rag) uses a knowledge graph to understand how different pieces of information are connected. It finds relationships and patterns between pieces of data rather than just searching for matching words.

![Graph RAG.png](https://unable-actionable-car.media.strapiapp.com/Graph_RAG_b6ffce03d4.png)

Graph RAG works by mapping out how different entities in your knowledge base are interconnected. It then uses these relationships to find relevant data. Even if a document does not have your exact search terms, it might still be helpful if it is conceptually related.

Graph RAG is used in fields where the relationships between concepts are crucial, such as investigative journalism, which uncovers hidden connections, or business intelligence, which requires understanding market relationships.

**Pros:**

* Great for complex questions requiring connecting multiple concepts
* Helps prevent scattered answers
* Can provide unexpected but relevant responses

**Cons:**

* Requires significant work to build the knowledge graph
* Slower than basic RAG systems
* Only as good as the connections you have taught it to recognize

## 5. Self-RAG

Self-RAG is a type of RAG that improves its search by rewriting your question before looking for answers. It behaves like a researcher who constantly questions their work. 

Self-RAG works by first providing an answer based on the retrieved data, then using specialized evaluation modules to check whether the answer is accurate and supported by the source material. It uses a language model to rewrite the original query, adding missing context and inferred intent from previous conversations.

![Self-RAG.png](https://unable-actionable-car.media.strapiapp.com/Self_RAG_44c6d5034a.png)

Self-RAG is used when questions are incomplete or there is insufficient detail to retrieve the proper documents. 

**Pros:**

* Catches and corrects its own mistakes before you see them
* Helps get better results from vague questions
* More reliable in scenarios where accuracy matters

**Cons:**

* Higher costs to run all those extra checks
* Slower since it is doing the work twice
* Can be too cautious and refuse to answer when uncertain


## 6. Branched RAG

Branched RAG is a type of RAG that explores multiple lines of thought simultaneously before deciding on the best answer. 

![Branched RAG.png](https://unable-actionable-car.media.strapiapp.com/Branched_RAG_a2d1bf0ffd.png)

Branched RAG works by generating responses for different interpretations of your question, retrieving answers for each one, and then comparing the answers to pick the most relevant response.

Branched RAG is used in comprehensive market research, where structured data such as technical specifications, competitor insights, and customer feedback are needed simultaneously.

**Pros:**

* Handles open-ended questions well
* Less likely to miss important aspects of complex questions
* Can provide more thoughtful final response

**Cons:**

* Complex to coordinate findings from different sources
* Can overwhelm users with information if not properly filtered

## 7. Multimodal RAG

Multimodal RAG is a version of RAG that simultaneously uses text, images, videos, audio files, charts, and documents to answer your questions. 

![Multimodal RAG.png](https://unable-actionable-car.media.strapiapp.com/Multimodal_RAG_2c097525a4.png)

[Multimodal RAG](https://www.meilisearch.com/blog/multimodal-rag) converts different types of content (a graph, a photo, a video clip, or a document) into a format it can search through and understand. When you ask a question, it looks through all these different media types to find relevant information and combines everything to provide an accurate response.

Multimodal RAG is used to analyze files that combine text and other forms of media.

**Pros:**

* Works with any type of content
* Provides complete answers using different sources
* Great for visual topics that need multiple perspectives

**Cons:**

* More complex to build and train
* Requires more storage and processing power
* Quality depends on how well it interprets various data formats

## 8. Adaptive RAG

[Adaptive RAG](https://www.meilisearch.com/blog/adaptive-rag) is a RAG model that learns from experience. It pays attention to what works and what doesn’t, and gradually improves its ability to respond to different kinds of questions. 

![Adaptive RAG.png](https://unable-actionable-car.media.strapiapp.com/Adaptive_RAG_60242702c1.png)

Adaptive RAG works by first recognizing the type of question (simple, complex, broad, or narrow) it received, then adjusting its retrieval process and generation style based on the question to provide an accurate answer.

Adaptive RAG is used in systems that deal with all kinds of queries, such as customer support bots, research tools, and digital assistants.

**Pros:**

* Gets better at helping you over time by learning your preferences
* Improves relevance by adjusting to the query type
* Can balance speed and depth when required

**Cons:**

* It takes time to learn and improve, so early results might be inconsistent
* More complex to build and maintain than static RAG architectures
* Can get stuck in bad habits if it learns from poor examples


## 9. Speculative RAG

[Speculative RAG](https://www.meilisearch.com/blog/speculative-rag) does not wait for you to finish asking your question. Instead, it anticipates what you might want to know next and pre-fetches that information in the background.

![A graph showing how speculative RAG works. ](https://unable-actionable-car.media.strapiapp.com/Speculative_RAG_4c1f083ea9.png)

Speculative RAG works by analyzing your current question and conversation history to predict likely follow-up queries. It then retrieves relevant documents for those anticipated questions while still working on your actual question, so when you do ask that follow-up, it already has the relevant data available.

Speculative RAG is used when speed matters, such as real-time chatbots, autocomplete suggestions, or customer service systems.

**Pros:**

* Faster response time
* Creates a more natural conversation flow
* Reduces waiting time when exploring complex topics

**Cons:**

* Risk of retrieving the wrong information if the guess is inaccurate
* Wastes computational resources on predictions that turn out wrong

## 10. Corrective RAG

[Corrective RAG](https://www.meilisearch.com/blog/corrective-rag) is designed to double-check its answers and correct them if something is wrong. 

![Corrective RAG.png](https://unable-actionable-car.media.strapiapp.com/Corrective_RAG_fa0994f373.png)

Corrective RAG works by doing the usual search and generating an answer, but then it steps back and asks, ‘Does this fully answer the question?’ 

If the answer feels off, it drops the weaker sources and tries a new search to find more relevant information before updating the response.

Corrective RAG is used when accuracy is important, such as in legal research, academic writing, or policy analysis.

**Pros:**

* Catches and fixes poor search results before you see them
*  Improves the reliability and accuracy of generated responses
* Adds an extra layer of quality control

**Cons:**

* Takes longer since it might need multiple search attempts
* Can get stuck in loops if it is never satisfied with what it finds
* Uses more computational resources performing extra searches


## 11. Modular RAG

[Modular RAG](https://www.meilisearch.com/blog/modular-rag) is like a toolkit: different modules handle different parts of the process, and you can combine them however you want, depending on the use case. 

The system is flexible, so you can swap in a new retriever, a better reranker, or a different generator. 

![Modular RAG.png](https://unable-actionable-car.media.strapiapp.com/Modular_RAG_f45a20e140.png)

Modular RAG works by breaking the system into separate components, allowing you to customize each part without rebuilding the entire system. 

Modular RAG is used across multiple domain-specific research environments and production AI applications.

**Pros:**

* Can easily optimize each component
* Easy to upgrade or replace components without starting afresh
* Great for customizing workflows

**Cons:**

* More complex to coordinate all the different components
* Takes planning ahead to figure out how all the parts will fit together

## 12. Naive RAG

Naive RAG is the simplest form of RAG. It pulls documents based on your question and passes them straight to the model without making any adjustments.

![Naive RAG.png](https://unable-actionable-car.media.strapiapp.com/Naive_RAG_2535319547.png)

Naive RAG works by converting your question into basic search terms, pulling the top documents that match those terms, and then passing them straight to the language model to generate a response. There is no filtering or reranking; it is just a simple matching algorithm.

Naive RAG is used in simple chatbots with a limited scope and basic FAQ systems where questions are predictable.

**Pros:**

* Very simple to build and understand
* Fast, since there is no complex processing involved
* Low computational costs

**Cons:**

* Struggles with complex questions
* No verification of search results
* Often retrieves irrelevant documents that affect the final answer


## 13. Advanced RAG

[Advanced RAG](https://www.meilisearch.com/blog/rag-techniques) is a more refined version of RAG that combines multiple steps (such as reranking, memory, feedback loops, branching, improved data retrieval, etc.) to get more accurate results.

![Advanced RAG.png](https://unable-actionable-car.media.strapiapp.com/Advanced_RAG_9b806ab383.png)

Advanced RAG works by layering various RAG techniques: it can rewrite the query to make it more straightforward, rank the results, check if the answer makes sense, and even review it if required, all to ensure that the generated response is the most relevant and accurate.

Advanced RAG is used in systems when making mistakes is not an option, such as in research tools or enterprise applications.

**Pros:**

* Handles complex questions better
* Smart enough to know which approach works best for different situations
* Offers more control over how results are generated

**Cons:**

* Requires expertise to build and keep running properly
* Requires careful fine-tuning to ensure all parts work together effectively
* Expensive to run due to its background work

## 14. HyDE (hypothetical document embedding)

HyDE is a unique approach in RAG in which the AI model starts by generating a guess as to what a good answer might look like and then uses that guess to search for real documents that match it.

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

HyDE works by generating a hypothetical answer first, converting it into a search query, and then retrieving real documents similar to the imagined one. This is the opposite of how you expect searches to work.

HyDE is used when traditional keyword searches struggle. It is helpful in academic research systems, legal databases, or medical information systems.

**Pros:**

* Focuses on semantic meaning, not just matching terms
* Useful in technical domains that are hard to search
* Helpful when the original query is missing key details

**Cons:**

* Harder to explain how it got its result
* Slow because of the added steps
* The hypothetical answer might lead the searcher down completely wrong paths


## Why are there different types of RAG architecture?

Different types of RAG architecture exist because no single setup works well in every situation. You choose what works best for you based on your intended use case.

Some tasks require speed and simplicity, while others call for deeper analysis, multiple sources, or even different types of input, such as images or graphs. 

For example, simple RAG can handle quick and straightforward queries. But if you are working on complex research or handling messy data, you might consider something smarter, such as agentic or self-RAG.

Now, let’s see the importance of RAG.


## What is the importance of RAG?

[RAG is a technique](https://www.meilisearch.com/blog/rag-techniques) that combines information retrieval with generative AI. It retrieves documents from a knowledge base and uses them to generate a more relevant and accurate answer.

It is important because it helps language models stay grounded in true information rather than hallucinations. 

RAGs are widely used for various real-world use cases. 

Tech companies, for instance, use RAG to help support agents quickly find answers to technical issues without going through pages of documentation. 

Law firms use it to scan thousands of legal documents in seconds. 

Hospitals also use RAG to enable doctors to match patient symptoms with findings from medical literature, thereby improving their diagnosis and treatment decisions.


## What tools are used for RAG?

RAG tools are the building blocks that connect your data to powerful language models to deliver accurate results.

Here are some [retrieval-augmented generation tools](https://www.meilisearch.com/blog/rag-tools) that are used in different RAG applications:


* **Meilisearch:** A super-fast search engine that supports both keyword and vector search. It is excellent for balancing keyword and semantic search and works smoothly with embedding models through a simple API. 
* **LangChain:** An open-source orchestration framework that connects retrievers, embedding models, and generators. It helps manage your entire RAG pipeline and handles the process of integrating with APIs, databases, and file formats.
* **Weaviate:** A vector database built for production. It supports hybrid search, filtering, and fast, scalable queries. 
* **Faiss:** A vector search library developed by Meta. It allows you to index and search embeddings efficiently, ensuring that the AI system focuses on meaning instead of just keywords.
* **Haystack:** A complete RAG framework that combines retrieval, question answering, and generation. It is useful when you want all RAG components to work together seamlessly.

RAG tools are categorized based on the part of the pipeline they support (retrieval, generation process, orchestration, or storage). Choosing the right tool depends on what stage you are working on and what you are trying to build.


## Build efficient RAG systems with Meilisearch

Choosing the right RAG approach comes down to matching the architecture to the problem you’re solving. 

As the technology evolves, RAG will continue to play a central role in building AI systems that stay grounded in relevant data. 

Combining strong retrieval with effective generative models helps reduce errors, improve reliability, and make AI more useful in real-world scenarios – whether for quick lookups, complex research, or anything in between.

14 types of RAG (Retrieval-Augmented Generation)

At Meilisearch, our main goal is simple: give developers and businesses a super-fast, really helpful, and easy-to-use search experience. While making our search engine awesome is what we do, keeping your data safe and private is just as important. 

This has been our focus since Day 1 of Meilisearch, but we didn’t have an official way to attest it. Today, we're excited to share some big news that shows how serious we are about this:

**Meilisearch has successfully passed its SOC2 Type II compliance check!**

This isn't just a fancy attestation – it shows how much we care about keeping your data secure and running things smoothly. For you, our users, this means you can feel even more confident that your important data is safe with us, thanks to our strong and regularly checked systems.

Also, we have to mention that this wouldn’t have been possible without the help of our partners from [Prescient Security](https://prescientsecurity.com/) and [Vanta](https://www.vanta.com/), who greatly helped us throughout the audit process.

## Understanding SOC2 Type II compliance

So, what exactly is SOC2 Type II? 

It's basically an audit standard from the [AICPA](https://www.aicpa-cima.com/home) (that's the American Institute of Certified Public Accountants). It checks how well a service company handles things like security, making sure stuff is available, keeping data accurate, and protecting private info. 

Getting Type II compliant means an independent auditor didn't just look at our systems once: they actually tested how well they worked over a prolonged period of over six months.

This tough audit process digs deep into how we manage customer data, focusing on five key areas:

- **Security**: This is all about protecting our systems from people who shouldn't have access. Think network safety, who can get in, and spotting any intruders. (Officially, this was the focus of the audit. Nevertheless, we made improvements to all 5 areas as a result of it!)
- **Availability**: This means our systems, products, and services are there when you need them, just like we promise. It covers how we keep things running, recover from problems, and handle unexpected issues.
- **Processing integrity**: This checks if our data handling is complete, correct, on time, and approved. It's about making sure your data is accurate and doesn't get messed up.
- **Confidentiality**: This is about keeping sensitive information private and safe from being seen or shared without permission. It includes things like encryption and limiting who can see what.
- **Privacy**: This looks at how we collect, use, keep, share, and get rid of personal information, making sure we follow our own privacy rules and general privacy guidelines. It's all about how we handle your personal data.

SOC2 Type II is the 'gold standard' for security because it gives you a clear, independent stamp of approval that a company is serious about protecting data. It's not just about having rules, it's about proving those rules actually work *all the time*.

## Meilisearch’s commitment to security

Our journey to SOC2 Type II compliance was a natural step for Meilisearch because we’ve always been about keeping your data safe. 

From the very beginning, we’ve focused on building a product and a company that truly cares about your data’s safety and privacy. This focus is built into everything we do – how we develop our products, how we run our operations, and even our company culture and processes.

To meet the tough requirements, we put in place and thoroughly tested a bunch of controls and measures for all the important areas:

- **Security**: We have strong controls to make sure only authorized people can get into our systems and access sensitive data. Our setup is protected by advanced tools that spot and stop threats, and we have a solid plan to quickly deal with any security issues. We also regularly check for weaknesses and fix them before they become problems.
- **Availability**: Meilisearch is built to be always on and reliable. We constantly watch our systems to make sure they’re running and available when you need them. We’ve also got comprehensive backup and recovery plans that we test regularly, so we can get things back up and running fast if something unexpected happens.
- **Processing integrity**: We have strict rules for how we handle data to make sure it’s accurate, complete, and done the right way. Our development and release processes include automated checks to prevent errors and keep your data in good shape throughout its journey with us.
- **Confidentiality**: Keeping your sensitive information private is super important to us. We encrypt your data when it’s stored and when it’s moving around. We also have clear rules about what data is confidential and limit who can see it, only giving access to those who absolutely need it. Everyone on our team gets regular training on how to handle sensitive information the right way.
- **Privacy**: Meilisearch is all about handling personal information properly, following global privacy rules. Our privacy program makes sure we’re open about how we collect and use data, gives you control over your own data, and sticks to relevant privacy laws. We have clear steps for how long we keep data, how we make it anonymous, and how we securely get rid of it.

We don't just do security to tick boxes. We keep investing in the best security tech, do regular internal checks, and make sure everyone on our team thinks security first. This proactive approach helps make sure Meilisearch stays a reliable and secure platform for all your search needs.

## What This Means for You: Our Users and Customers

Meilisearch getting SOC2 Type II compliant ensures you don’t just have to trust our word (although you can totally do 😉) and that the following perks are indecently verified for you, our awesome users and customers:

- **More trust and confidence**: This audit is like an independent stamp of approval that Meilisearch has solid systems in place to protect your data. You can feel even better about our security and know your information is in good hands.
- **Better data protection**: Because we stick to SOC2 Type II standards, you can be sure that your data – whether it’s product lists, user details, or anything else important – is handled with super care and kept safe from anyone who shouldn’t see it.
- **Easier for your own compliance**: For many companies, working with vendors who are SOC2 compliant is a must for their own rules and regulations. Our attestation makes it simpler for you to get internal approval and helps you keep up with your own compliance needs.
- **Less risk for you**: When you use a search solution that’s SOC2 Type II compliant, you greatly lower the chances of data breaches or security hiccups. This proactive way of handling security means fewer potential problems and helps keep your business looking good.
- **A leg up on the competition**: In today’s world, where data safety is a big deal, choosing a search provider with proven security credentials gives you an edge. It shows your own customers that you care about security and helps build their trust.

## The road ahead: always getting better

Achieving SOC2 Type II compliance is a huge win, but for us at Meilisearch, it's not the finish line – it's a major milestone on an ongoing journey. 

(It’s not the beginning either, as security is deeply ingrained in the architecture of the product and the company.) 

Security isn't a one-and-done thing, it's a continuous process of learning, adapting, and improving.

We're always looking for ways to make Meilisearch even more secure and reliable. You can expect us to keep investing in top-notch security practices and exploring new certifications that further strengthen our commitment to your data. We're passionate about building a search solution you can truly trust, and that means constantly pushing ourselves to be better.

Got questions about our security? Want to dive deeper into our audit report (under NDA, of course)? Don't hesitate to reach out to our team. We're always happy to chat about how we keep your data safe.

## Conclusion: your trust, our priority

So, there you have it! Meilisearch is officially SOC2 Type II compliant. This is a big deal for us, and we hope it’s an even bigger deal for you. It means we’re serious about protecting your data and providing a search experience that’s not just fast and relevant, but also incredibly secure.

We really value your trust. We promise to be open, dependable, and always put your data security first. If you haven’t already, we invite you to experience the power and peace of mind that comes with Meilisearch. Try it out, and see how easy and secure search can be!

Meilisearch is now SOC2 Type II compliant: A big step for trust and security

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.

Meilisearch latest news and company updates