**[MotionElements](https://www.motionelements.com/) is an AI-powered one-stop marketplace for video creators to access and customize creative assets. Time is money for MotionElements’ users, and search is essential in helping them quickly find what they need.** 

With a global user base speaking multiple languages, MotionElements relies on powerful multilingual search capabilities to deliver fast, accurate, and relevant results across diverse creative content.

![MotionElements_search.gif](https://unable-actionable-car.media.strapiapp.com/Motion_Elements_search_50cb3914a5.gif)
>“MotionElements’ federated hybrid search empowers creators to seamlessly explore diverse creative assets across our one-stop marketplace—all in their own language. By combining keyword search with zero-shot video search, visual & music similarity search, we deliver an intuitive, AI-enhanced discovery experience that fuels creative workflows.” - **Mark Sun, CTO at MotionElements**


**Challenge: Scaling search**
-------------------------------------------------------------------------------

Previously, MotionElements relied on Solr, which became increasingly difficult to maintain. With millions of new content pieces added each month, Solr consumed excessive RAM and struggled with scalability. MotionElements' search needs have also evolved, requiring support for keyword search, visual and music similarity vectors, and image embeddings—capabilities that are difficult to implement efficiently with Solr.


>_As our content grows, we need a search solution that can handle both traditional and AI-enhanced discovery while remaining scalable and performant,_ said Mark Sun, CTO of MotionElements.

![MotionElements_multimodal.gif](https://unable-actionable-car.media.strapiapp.com/Motion_Elements_multimodal_6cfa386d8d.gif)

**Solution: Choosing a superior price‑to‑performance ratio, scalability, and multilingual federated**
-------------------------------------------------------------------------------

- **Price‑to‑performance ratio:** MotionElements explored Elasticsearch, Algolia, and Typesense, and ultimately chose Meilisearch because of its price‑to‑performance ratio when handling large catalogs with millions of products.

- **Feature fit:** Meilisearch’s federated search capabilities and multilingual support were also key factors in MotionElements’ decision.

- **Addressing migration concerns**,  Mark Sun said:

>“Initially, we had concerns about migrating its image similarity vectors, but Quentin, the CEO of Meilisearch, provided invaluable support through a Proof of Concept (PoC), resolving all MotionElements’ migration challenges. Meilisearch offered the scalability, speed, and flexibility we needed while keeping infrastructure management minimal. Its federated search and hybrid search capabilities make it a powerful tool in MotionElements’ AI‑enhanced workflows. Federated search lets us retrieve results across multiple product types, making search in MotionElements’ one‑stop marketplace seamless. Hybrid search combines keyword search with external AI‑powered vector search, allowing us to enhance discovery across images and audio."

These features significantly improve search relevance, speed, and user experience, making it easier for the MotionElements team to deliver fast and intuitive search results.

**Implementation**
-------------------------------------------------------------------------------

Implementing Meilisearch was straightforward, thanks to its user‑friendly API. MotionElements wrote code to set up indexes based on its needs and pre‑generated NDJSON files of its products, which are stored in an S3 bucket. Meilisearch makes it easy to ingest data from NDJSON, dramatically improving MotionElements’ indexing workflow. 

Mark Sun said: _“Previously, re‑indexing on Solr took weeks, but with Meilisearch, it now takes just hours—saving us countless hours of engineering time. Since MotionElements uses the enterprise cloud version, the MotionElements developer team focuses on search optimization while Meilisearch handles the infrastructure.”_

**Results**
-------------------------------------------------------------------------------
The biggest impact has been faster search performance, improved accuracy, and higher engagement:

- **No more worrying about Solr and Zookeeper crashes**. _"Meilisearch is stable and scalable. Now, we can focus our efforts where they’re needed most, knowing our search infrastructure is stable and dependable._” — said Mark Sun.
- **Re-indexing time drastically reduced** – "what used to take weeks in Solr now takes just hours."_

- **Increased search-based conversions.** Faster, more relevant results lead to better engagement and retention.

**Conclusion: vision**
-------------------------------------------------------------------------------

Going forward, MotionElements expects further improvements in personalization, more efficient AI-powered product recommendations, and continued optimization of multilingual search, all of which are key drivers of its business growth.

As MotionElements continues investing in AI-powered search enhancements, Meilisearch remains a core search infrastructure component for the MotionElements platform. 
MotionElements’ vision includes:
- **Advancing hybrid search** – enabling seamless queries across keywords, text embeddings, image embeddings, and music similarity to deliver the best results across multiple vectors.
- **Enhancing language‑specific optimizations** – for example, in Japanese, when searching in kanji, results should also include matches in hiragana and katakana, while properly handling stop words for better accuracy.
- **Optimizing performance at scale** – indexing, updating, and searching must remain fast and efficient as MotionElements’ content library grows.
Meilisearch should continue to augment vector‑based search, rather than replace dedicated vector databases—providing a fast, flexible, and cost‑effective search infrastructure that evolves alongside MotionElements’ AI‑powered features.



AI-Powered discovery: how MotionElements elevates creators

Hybrid search combines keyword and semantic search, giving users the best of both worlds and control over the level of contextual depth they need. 

This type of information retrieval (IR) is especially critical in enterprise search, e-commerce, and knowledge management systems, where some inputs require deep contextual understanding while others demand precise keyword matching.

A clear advantage of hybrid search is its ability to handle data with less computational costs. 

This is thanks to the lexical matching system, which uses considerably less power than semantic algorithms that may rely on Large Language Models (LLMs), Convolutional Neural Networks (CNNs), and other energy-consuming models. 

Therefore, these systems can be tweaked for higher performance while being a cost-effective alternative to pure semantic search systems.

However, implementing hybrid search requires strategic planning. Users unfamiliar with semantic weighting may find it confusing, leading to frustration or disengagement. 

In the following piece, we will take a deep look into the importance of hybrid search, how to implement it, and in which situations it is the preferred solution.

## What is hybrid search?

Hybrid search systems combine keyword-based retrieval (sparse vector methodology) with semantic search systems ([dense vector embeddings](https://www.meilisearch.com/blog/what-are-vector-embeddings)) to optimize precision and contextual relevance.

For a visual explanation of the terms and technologies used in the hybrid search, let’s take a look at the schema below:

![What is hybrid search.png](https://unable-actionable-car.media.strapiapp.com/What_is_hybrid_search_111362249c.png)

Semantic search relies on dense vectors, requiring both the search query and target data to be embedded using Machine Learning (ML) models. Some methods, like neural search, leverage Deep Neural Networks (DNNs) to generate rich contextual insights for embedding, retrieval, and ranking. Vector search is another type of semantic search that uses embedding models to create dense vectors, ML algorithms such as Approximate Nearest Neighbors (ANN) for information retrieval, and cosine similarity search for ranking.

On the other hand, keyword search relies on sparse vectors generated through algorithms. For instance, our full-text search relies on a vector of documents associated with each word in the dataset. When a search query is entered, the system preprocesses the input by extracting individual words and matching them against the sparse vector values of the documents. These are then ranked based on keyword relevance.

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

### Dense vectors

The dense vectors are extensive and can have hundreds or thousands of floats (numerical representations) to identify a single document. They represent the similarity of objects in a vector space and can have the following shape:

```json
dense_vector = [0.8, 0.4, 0.2, 0.7, 0.9, 0.1, … ]
```

Dense vectors are usually multidimensional and don’t have zero values because they are created continuously to capture the complete information of the document or query.

### Sparse vectors

In full-text search, sparse vectors come in the form of documents associated with each word in a dataset. This vector representation forms the foundation for ranking and retrieving relevant and accurate results. 

Hybrid search combines the strengths of dense and sparse vector retrieval to enhance search scores. It first gathers matches from both methods and then refines the final output by globally ordering the results based on relevance. 

In the next chapter, we’ll explore each step of the hybrid search process.

## How does hybrid search work?

Hybrid search works by leveraging the semantic capabilities of dense vectors and the exact matching and accuracy of sparse vectors. The outputs retrieved from both methods are then blended to deliver more relevant search outcomes. 

![How does hybrid search work.png](https://unable-actionable-car.media.strapiapp.com/How_does_hybrid_search_work_3224ecf2f4.png)

By looking at the schematic above,  we can structure the hybrid search workflow into distinct steps, allowing both semantic and keyword searches to operate in parallel:

### Data cleansing & preprocessing

- **Keyword Search**: Requires robust data cleaning (e.g., Meilisearch includes native support for stop words, though manual configuration is required for full-text seatch) to ensure accurate term matching.
- **Semantic Search**: Benefits from noise reduction and strategic text segmentation (chunking) to improve the quality of document embeddings.

### Embedding: dense and sparse representations

- **Semantic**: Models like Bidirectional Encoder Representations from Transformers (BERT) and Global Vectors (GloVe) transform documents into dense vectors, capturing nuanced contextual meanings.
- **Keywords**: Some algorithms use frequency-based scoring, while others use neural networks to generate sparse embeddings. 

### Retrieval mechanisms of dense and sparse vectors

- **Semantic Retrieval**: Utilizes algorithms like Approximate Nearest Neighbor (ANN) and K-Nearest Neighbor (KNN) to search within the dense vector space efficiently.
- **Keyword Retrieval**: Directly matches query terms with document vectors.

### Ensemble retrieval

- **Hybrid search**: The final step involves combining results from both retrieval methods to determine the most relevant ones. 

The hybrid search process can be tweaked to assign importance to one type of result over another. If contextual meaning outweighs lexical matching, the system prioritizes outputs from the semantic search. Otherwise, it prioritizes keyword matching. This feature is available and easily controlled in Meilisearch’s [hybrid search setup](https://www.meilisearch.com/solutions/hybrid-search).

## What is a hybrid search engine example?

Companies have adopted hybrid search engines to improve the accuracy and relevance of search results. One of the most advanced hybrid search systems is Google Search, which combines multiple search techniques and algorithms to deliver precise and contextually relevant results.

Google integrates both keyword-based search and machine learning models to interpret user queries, rank web pages, and present the most relevant information. Currently, they utilize [Vertex AI Embedding](https://cloud.google.com/vertex-ai/docs/start/install-sdk) models to generate dense vectors that capture semantic meaning while simultaneously creating sparse vectors for keyword-based retrieval.

To configure search results, Google merges output from semantic and keyword-based searches using Reciprocal Rank Fusion (RRF), as detailed in their official [notebook](https://github.com/GoogleCloudPlatform/generative-ai/blob/main/embeddings/hybrid-search.ipynb).

As of January 2025, Google Search maintains an [89.79% market share](https://gs.statcounter.com/search-engine-market-share), continuing to dominate the search landscape. While AI-driven chatbot search features have begun gaining traction, they still fall short of Google's accuracy and real-time information retrieval capabilities.

## What are the benefits of hybrid search?

Hybrid search provides several advantages over standalone keyword-based or semantic search methods. Some of these benefits include:

1. **Enhanced search accuracy and relevance**: Hybrid search provides high-quality results by combining exact matches with semantic understanding. This level of accuracy ultimately retains users and reduces the bounce rate.
2. **Improved user experience**: The system can deliver meaningful content even if users enter inaccurate terms or vague keywords. This ease of retrieving information allows designers to create engaging search elements. Just ask [CarbonGraph](https://www.meilisearch.com/customers?usecase=Hybrid+search): "_We migrated to Meilisearch from Pinecone to consolidate our search service [...] The setup of the OpenAI embedder was very straightforward, and we love that embeddings are created automatically using the contents of a search document_."
3. **Cost-effective implementation**: Lexical matching in hybrid search reduces memory usage compared to pure semantic search engines. This is crucial for lowering cloud costs related to storage and computational demand, especially since keyword search algorithms do not depend on GPUs.
4. **Increased search speed**: Opinly, a company that allows you to monitor your competitors' websites, adopted hybrid search technologies to enhance the quality and contextual accuracy of its search results.
5. **Personalization and adaptability**: Hybrid search systems can be configured to dynamically adjust the weight of keywords and semantic relevance or provide the user with control over it. The [NFSA collection](https://www.collection.nfsa.gov.au/) has this option available in their search engine, very similar to Meilisearch's hybrid search.

Hybrid search provides significant advantages across various business domains, offering speed, robustness, and efficiency. However, it is not always the optimal solution for every search application. The next chapter will explore its limitations and when alternative approaches may be more suitable.

## What are the drawbacks of hybrid search?

While hybrid search offers the best of both keyword-based and semantic search, it also comes with challenges that can impact implementation, performance, and user experience. Below are some key drawbacks to consider when adopting a hybrid search approach:

1. **Increased complexity in implementation**: Hybrid search requires integrating multiple search algorithms (e.g., semantic search using dense embeddings). This integration can be technically complex and requires deep technical understanding.
2. **Difficulty in balancing keyword precision and context**: Over-relying on one method may diminish the benefits of the other (ex., more semantic power than keyword precision). If a good balance is not achieved, this could lead to a bad user experience and increased bounce rates.
3. **Bad user experience**: If users can adjust semantic weight, the interface should be intuitive or designed for an audience familiar with the terminology. Otherwise, it may lead to confusion and increase the risk of user drop-off. According to this [Toptotal report](https://www.collection.nfsa.gov.au/), 88% of users are less likely to return after a bad user experience.

Despite these challenges, hybrid search remains a powerful tool when applied correctly.

## When should you use hybrid search?

Hybrid search isn't the optimal solution in all scenarios. In cases where data is highly structured — such as product inventories or specific academic research — precision is key, and similar-sounding terms with distinct meanings must be strictly differentiated. Hybrid search truly excels in the following examples:

1. **E-commerce platforms**: Online retailers like Amazon implement hybrid search to enhance product discovery. When customers input vague queries, the system leverages keyword matching and semantic analysis to present relevant products. You can see it in action below; the user searched for “bottle that keeps drinks cold” and received results about thermoses.
 
![image9.png](https://unable-actionable-car.media.strapiapp.com/image9_3b6346806d.png)

2. **Enterprise knowledge bases**: Organizations often maintain extensive repositories of documents, manuals, and communications. Hybrid search enables employees to retrieve pertinent information efficiently and increase productivity.
3. **Streaming services**: Platforms such as Netflix utilize hybrid search to help users find content, whether they search by specific titles or describe themes.
4. **Marketplaces**: Hybrid search in e-commerce can improve search accuracy, handle complex queries, and increase product discovery, leading to increased sales. 

Now let’s see how you can seamlessly introduce hybrid search systems in your project or workflow with [Meilisearch](https://cloud.meilisearch.com/login?ref=navbar).

## How can you implement hybrid search?

Implementing a hybrid search requires a vector store solution. Several languages and AI frameworks can be used for implementation, but Python with Langchain is often a good stack to start building efficiently.

The AI-enhanced hybrid search from [Meilisearch](https://www.meilisearch.com/blog/introducing-hybrid-search) allows third-party embedding models and control over the semantic weight of the outputs, allowing a deeper semantic understanding of the user inputs.

To start using Meilisearch's hybrid search features, you must create an account and gain access to the API keys and [cloud platform](https://www.meilisearch.com/cloud). You can register for free and enjoy a 14-day trial.

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

After registering, you can create a new project and use the vector store to add and index documents, run queries, monitor analytics, and more.

In the settings tab, you'll find an option called Embedders, where you can enhance your hybrid search capabilities by integrating any embedding model of your choice. Below is an example of the OpenAI embedding model added to the list of embedders.

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

After adding a model, you can jump to the search preview tab and control the semantic weight directly there — you’re using hybrid search!

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

To integrate the search engine into your workflow, use Meilisearch’s API, available on the main page of the cloud dashboard. Here’s a Python script to query and retrieve results:

```json
import meilisearch


client = meilisearch.Client(
    '<meilisearch_server_url>',
    '<master_token>')
query = "Give me a book about a post-apocalyptic world"
results = client.index('books').search(query, opt_params={
  'hybrid': {
    'semanticRatio': 0.7,
    'embedder': 'openai'
  },
  'limit':4
})


for result in results['hits']:
    print(result['metadata']['text'])
```
To be able to run the code without issues, you first need to have the Meilisearch package installed:

```json
pip install meilisearch
```
Next, you need an index — a collection of documents you've added to Meilisearch Cloud ( 'books' in this example). Additionally, you’ll need an embedding model.

The results of the Python script are the following:

```json
{"id": 15, "title": "The Road", "description": "A father and his young son journey through post-apocalyptic America, fighting for survival while holding onto their humanity.", "genre": "Post-Apocalyptic"}
{"id": 6, "title": "1984", "description": "A dystopian social science fiction novel that follows Winston Smith and his rebellion against the totalitarian government that controls their society.", "genre": "Dystopian Fiction"}
{"id": 18, "title": "The Handmaid's Tale", "description": "In a dystopian future, a woman is forced to live as a concubine under a fundamentalist theocratic dictatorship.", "genre": "Dystopian Fiction"}
{"id": 19, "title": "Snow Crash", "description": "A pizza delivery driver and hacker investigates a dangerous computer virus that can affect human minds in both virtual and real worlds.", "genre": "Cyberpunk"}

```
Start building today by effortlessly uploading your documents to [Meilisearch Cloud](https://www.meilisearch.com/cloud). Seamlessly integrate the hybrid search capabilities into your infrastructure using [Python](https://www.meilisearch.com/docs/reference/api/search#example-22) and other supported languages, ensuring scalability and fast results.

## How does hybrid search compare to other search types?

Hybrid search combines two key approaches: semantic search and keyword search. However, semantic search is a broader term for methods that retrieve contextual or semantic meaning, including vector search and neural search. Let's explore the differences between all these search types:

| **Hybrid search** | **Vector search** | **Semantic search** | **Keyword search** | **Neural search** |
| --- | --- | --- | --- | --- |
| Combines dense and sparse vector representations to enhance search accuracy and contextual relevance. | Uses dense vector embeddings and algorithms like ANN to retrieve semantically relevant results. | A broader term for search technologies that use dense vectors to obtain contextual or semantic outputs. | Uses technologies that create sparse vectors for accurate lexical matching. | This technology uses Deep Neural Networks (DNNs) for making dense vectors and supports different data types. |

Now, let's examine how hybrid search differs from each of the other search methods individually.

### What is the difference between hybrid search and vector search?

Hybrid search enhances vector search by incorporating keyword matching for improved accuracy. As a form of semantic search, vector search relies on an embedder to generate dense vectors and retrieval algorithms like ANN and KNN to identify relevant results. By merging these with sparse vector outputs, hybrid search optimizes retrieval using techniques such as RFF.

### What is the difference between semantic search and hybrid search?

Hybrid search is a combination of semantic and keyword searches. The quality of the hybrid search system response highly depends on the embedder used for the semantic search. The better the embedder and the retrieval algorithm applied on the dense vectors, the better the semantical or contextual response of the hybrid search. In addition, the hybrid search uses keyword matching for lexical accuracy.

### What is the difference between keyword search and hybrid search?

Hybrid search utilizes keyword search to deliver precise lexical results. Keyword search relies on algorithms to generate sparse vectors from queries and documents, enabling fast and accurate retrieval. However, it lacks semantic understanding, so hybrid search integrates semantic search technologies to enhance search relevance and context.

### What is the difference between hybrid search and neural search?

Neural search, a type of semantic search, can be integrated into a hybrid search system. It leverages deep neural networks (DNNs) to deliver highly contextual results and supports various data input types. In a hybrid setup, neural search enhances typo tolerance while maintaining accuracy through lexical matching when users enter precise terms.

## Hybrid search gives you the best of both worlds

Hybrid search delivers exceptional accuracy and contextual relevance, but implementing it can be complex. It involves selecting the right vector database, choosing optimal embedding models, and fine-tuning outputs from both dense and sparse vectors.

[Meilisearch](https://www.meilisearch.com/cloud) simplifies this process by providing an intuitive platform backed by insightful tutorials. On this platform, you can effortlessly upload datasets, experiment with embeddings, fine-tune semantic relevance, and access advanced metrics like analytics and monetization.





Hybrid Search 101: how it works and why It's important

Neural search is redefining the future of information retrieval, pushing beyond traditional keyword and vector search approaches. While vector search applies machine learning (ML) to map semantic relationships between user queries and data embeddings, neural search leverages deep neural networks (DNNs) to optimize the entire search pipeline, from indexing and semantic analysis to ranking mechanisms.

This advancement enables neural search systems to continuously learn and refine results, outperforming conventional search methods in accuracy and adaptability. More importantly, they support multimodal data retrieval, allowing seamless search across text, images, audio, and even complex 3D datasets, critical for AI-driven applications and next-gen user experiences.

However, adoption comes with challenges. Neural search models often function as ‘black boxes,’ raising concerns about interpretability, and their high computational requirements can drive up infrastructure costs.

This guide explains the fundamentals of neural search, how it differs from existing search systems, and its strategic advantages. It also explores practical applications and potential trade-offs, helping you assess whether neural search aligns with your company’s AI roadmap.

## What is neural search?

Neural search, or neural information retrieval, leverages DNNs to interpret the contextual meaning behind search queries, enabling more accurate results than traditional keyword-matching systems and vector search. Instead of relying on exact terms, it transforms the user’s input and data into dense vector embeddings—numerical representations that capture semantic relationships. This process is similar to vector search systems, but instead of using ML models like approximate nearest neighbor (ANN) and a ranking algorithm, the neural search relies entirely on DNNs for the complete process.

A practical example involves querying a film database. A search like ‘Recommend a drama exploring modern parenting challenges’ would return a ranked list of movies aligned with the query’s intent, prioritizing contextual relevance over isolated keywords. The ranking is refined by the DNN itself, which needs to understand concepts like family dynamics and contemporary parenting struggles.

Here’s an example from Meilisearch: 

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

You can also try this for yourself by [checking out our demo](https://wheretowatch.meilisearch.com/). 

A commonly misunderstood term is often confused with neural search. In the next chapter, we’ll look into the key distinctions between neural search and neural architecture search (NAS).

## How does neural search differ from neural architecture search?

Neural search and NAS are often confused but serve different purposes. Neural search enhances information retrieval by understanding semantic meaning, while NAS focuses on automating the design of neural network architecture to optimize model performance for specific tasks.

NAS leverages techniques like recurrent neural networks and reinforcement learning (RL) to generate new language models, visual models, and overall neural architecture, eliminating manual experimentation and accelerating model development. In contrast, neural search applies deep learning to improve search relevance across text, images, sound, and other structured data types, transforming how systems retrieve and rank results.

Despite their differences, these technologies can intersect. For instance, you could use NAS to create a highly specialized artificial neural network tailored to your neural search. Let’s get a deeper understanding of how the latter works in the next chapter.

## How does neural search work?

Neural search enhances the search experience with DNNs using two main mechanisms: indexing and embedding. These are integrated in the following steps:

- **Data encoding and indexing**: The DNN analyzes documents (e.g., movie descriptions) to generate vector embeddings. These dense numerical representations capture semantic contexts, such as themes, relationships, and emotions, and are properly indexed in a vector database.
- **Query Encoding**: The user’s input (e.g., ‘Recommend a drama about modern parenting’) is converted into an embedding using the same DNN. This ensures the query and data share a unified semantic framework.
- **Semantic matching & ranking**: Unlike vector search systems that rely on external algorithms (ANN, cosine similarity) the DNN directly compares query and document embeddings. It evaluates learned relationships (e.g., linking ‘parenting challenges’ to films about complex family dynamics) to rank results by contextual alignment.

Neural searches can process various data inputs, depending on their types and activation functions, including text, images, audio, and 3D information. The embedding model adapts based on the input type. For instance, a convolutional neural network (CNN) is used for images, while large language models like BERT, are employed for text.

## What are some examples of neural search use?

Neural search can be applied to a wide range of use cases that require the processing of different types of data inputs and constant learning and optimization. Here are two simple examples of its potential applications:

1. **Optimize ranking results**: Jina AI offers a superior ranking solution based on neural search. It takes the initial outputs from a search query and reevaluates them to ensure they align more closely with the user's intent. [Jina’s AI Reranker](https://jina.ai/reranker) natural language processing model is available as open-source and can be accessed through Jina’s API.
2. **Search tools with images**: The German company [PROFISHOP](https://www.profishop.de/) uses a search engine powered by CNNs, allowing users to submit an image as input and fetch related content from a large industrial, durable, and consumer goods database.
3. **Retrieve ML models**: [Hugging Face](https://huggingface.co/chat/) has a large repository of models, including image-to-image, image-to-text, text-to-text, and more. Finding the appropriate model was initially challenging. However, the platform has since implemented a [hybrid search system](https://www.meilisearch.com/blog/hugging-face-democratizes-ai) that combines keyword matching with contextual understanding to enhance model discovery.
48. **Improve e-commerce**: [Google Shopping](https://shopping.google.com/) has integrated artificial intelligence (AI) to enhance its search capabilities, providing users with more relevant and personalized product recommendations. In addition, Google uses generative AI to summarize key factors during the search.

The neural search's ability to integrate RL for constant learning, accept different data types, and allow GenAI integration makes this technology extremely versatile and applicable to countless applications while ensuring accurate, personalized, and evolving results.

## What are the benefits of neural search?

Neural search systems offer several key benefits. Let’s take a look at some of them:

- **Increased engagement & reduced bounce rates**: Users expect almost real-time, precise, and relevant search results. When they don’t find what they need, [bounce rates surge](https://www.allaboutai.com/ai-seo/average-bounce-rate-guide/), and potential customers may never return. An optimal bounce rate is usually below 50%.
- **Enhanced productivity & efficiency**: Instead of manually searching through vast documentation or using inefficient keyword searches, neural search enables employees to find exact information instantly.
- **Multimodal search capabilities**: Neural search processes various data formats, including text, images, and audio. This versatility allows new use cases, particularly in e-commerce. According to [Think With Google](https://www.thinkwithgoogle.com/marketing-strategies/search/online-shopping-image-statistics/), 50% of online shoppers say images directly influence purchasing decisions.
- **Revenue growth**: Search is an important yet undervalued feature in e-commerce. [Bloomreach](https://www.bloomreach.com/) reports that while only 15% of B2C customers use site search, this small group drives 45% of online revenue.
- **Personalization & continuous learning**: Neural search systems can adapt by learning from user interactions and refining results based on behavior, clicks, and historical preferences. This dynamic personalization enhances user experience, improves retention, and drives long-term customer loyalty.

While the applications and benefits seem tempting, this is still a new field, so there is plenty of room for optimization. In the next section, we’ll explore some of this technology's challenges and limitations.

## What are the drawbacks of neural search?

The key drawbacks of neural search are listed below:

- **High computational cost and complexity**: DNNs require substantial computational resources for training and operation. This led to the development of GPUs with enhanced parallel processing power, which can be expensive. For instance, the newest model from NVIDIA (which has a [90% share](https://www.ft.com/content/03f66c13-3531-4ff2-b348-f17dac588c93) of the GPU market) is currently priced at [$2,529](https://www.tomshardware.com/news/lowest-gpu-prices).
- **Data dependency**: Neural search systems use high-quality, labeled training data to function properly. Without it, the system risks producing biased or skewed results. Designing the required metrics for the system before data ingestion is key to delivering better search functionality.
- **Lack of interpretability**: DNNs often function as 'black boxes,' learning complex patterns that can be difficult to understand. Due to this lack of transparency, debugging unexpected or odd results is challenging. This is why logs and [monitoring tools](https://www.meilisearch.com/blog/monitoring-metrics-release) are important once the search system is deployed. 
- **Model maintenance and engineering**: To stay effective, DNNs require frequent retraining to adapt to language and user behavior changes, increasing operational overhead. Additionally, the infrastructure and expertise required to maintain neural systems can be too expensive for smaller organizations. AI engineers are among the most in-demand jobs according to [LinkedIn’s 2025 report](https://www.linkedin.com/pulse/linkedin-jobs-rise-2025-25-fastest-growing-us-linkedin-news-gryie/) with an average annual salary of [$120,000 globally](https://artsmart.ai/blog/how-much-do-ai-engineers-make/), which is 30% higher than other engineering roles.

While technological advances are gradually reducing the computational demands of these models, these challenges must still be carefully considered when deciding whether to implement a neural search system.

## How does neural search compare to other types of search?

Neural search is a form of semantic search, similar to vector search, but it uses DNNs to handle indexing, encoding, and ranking. Other search types include keyword search and hybrid search. Here’s how they differ:

| **Neural search** | **Vector search** | **Keyword search** | **Hybrid search** |
| --- | --- | --- | --- |
| Leverages DNNs to embed and get the most relevant results based on semantic relationships. | Uses ML algorithms such as ANN to find semantic relationships. | Outputs content based on the keywords used in the query and doesn’t understand the context. | Combines both keyword search and neural search. |

### Neural search vs. vector search

Both [vector search](https://www.meilisearch.com/solutions/vector-search) and neural search retrieve data by matching query vectors to embeddings, making them forms of semantic search. Although neural search might be interpreted as a type of vector search, the latter typically refers to a method that leverages ML models like ANN for contextual retrieval and uses cosine similarity for ranking. In contrast, neural search bypasses these steps, relying entirely on DNNs throughout the search process.

### Neural search vs. keyword search

Keyword search relies solely on matching literal terms in search queries to those in a dataset, ignoring context or meaning. For example, a keyword search for 'best smartphone' won’t return results mentioning 'top mobile devices' unless those exact words are present, whereas neural search recognizes their semantic equivalence.

### Neural search vs. hybrid search

[Hybrid search](https://www.meilisearch.com/solutions/hybrid-search) combines the contextual intelligence of DNNs with the speed and simplicity of keyword matching, optimizing for precision and efficiency. It uses keyword search to rapidly filter exact term matches while leveraging neural techniques for semantic understanding, ensuring relevance even when queries or data require deeper interpretation. [Meilisearch](https://www.meilisearch.com/) gives you control over your hybrid search engine, enabling you to adjust the semantic context as needed.

## What is the future of neural search?

The fast evolution of AI, specifically in DNNs and NAS, will bring tremendous advances to neural search and its use-case scenarios. NAS, which automates the design of DNN architecture, enables the creation of highly specialized models that optimize accuracy, speed, and resource efficiency for specific tasks. These new and more powerful models have transformative applications in different industries:

- **Reshaping e-commerce**: Neural search engines can retrieve the most relevant products based on the context provided by the customer’s query. Already, giants like Google are using this technology to enhance searches — [Google Shopping](https://www.voguebusiness.com/story/technology/google-shakes-up-shopping-with-generative-ai) now includes an AI-generated brief containing what it thinks are the top three choices and why. The AI brief also includes tips on what to look for when shopping for a particular product, which is sourced from the web and summarized by AI. 
- **Education & skill development**: Learning platforms can use neural search to deliver materials tailored to an individual’s progress, learning style, and career goals. Imagine an AI tutor that dynamically assembles courses from videos, papers, and exercises. [Three in five](https://www.aiprm.com/ai-in-education-statistics/) (60%) teachers claim to have integrated AI into their teaching habits.
- **Healthcare transformation**: Neural search engines can potentially analyze patient histories, symptoms, and genomic data to identify personalized treatment options or clinical trials. This could significantly reduce the time patients wait for an accurate diagnosis and treatment. [Deep6 AI](https://deep6.ai/) is an example of this, as it uses neural search techniques to sift through massive amounts of data to match patients to clinical trials. 

Another emerging technology is Generative AI, which can go hand-in-hand with neural searches and be applied in different formats (text, image, sound, video):

- **Design & creativity**: Architects, for example, could use search engines by providing sketches and verbal descriptions (e.g., 'sustainable office building with natural light'), prompting the system to generate 3D models that integrate principles from existing designs and environmental data.
- **Dynamic content creation**: Media platforms could leverage generative AI to auto-generate videos, articles, or music playlists by retrieving and delivering content aligned with the user’s preferences, location, or mood.

These technologies will enhance information retrieval and actively influence human decision-making, creativity, and problem-solving as they evolve.

## Unlock next-generation neural search with Meilisearch

Neural search systems are state-of-the-art in delivering contextual results, but they may not be the ideal choice for every situation. This is why a hybrid search system can be handy, especially when it offers control over the semantic ratio and ranking outcomes. 



Neural search: Definition, how it works, benefits and more

What is semantic search? How it works, use cases & more

10 of the best Algolia alternatives [With features, pricing & more]

When you're handling millions of documents in a search engine, every millisecond counts. That's why we've completely reimagined how Meilisearch processes data with our new indexer in v1.12. We've rewritten our indexer—the core component that processes your documents and builds search structures—from the ground up. The result? A faster, more efficient, and more scalable system.

This complete redesign fundamentally changes how our search engine handles data. In this article, we'll show you how we've achieved up to 4x faster document updates and 30% smaller database sizes, and what this means for your applications.

## A foundation for the future

We've named this release `Indexer edition 2024`, reflecting our vision to build a foundation that will power Meilisearch's performance for years to come. Inspired by [Rust's edition model](https://doc.rust-lang.org/edition-guide/editions/index.html), this isn't just an update—it's a new chapter in Meilisearch's evolution, setting the stage for future innovations in search technology.

(Also like Rust editions, we took the year it was developed rather than the year it was released 😁)

## Why would you write a new indexer?

![the-doctor-meme.jpg](https://unable-actionable-car.media.strapiapp.com/the_doctor_meme_1f1323b0c6.jpg "The Doctor would not rewrite an indexer")

_The Doctor would not rewrite an indexer_

You need a _very_ strong reason to re-write an indexer. And we had one.

As our CTO Kero put it bluntly in his blog post: [Meilisearch is too slow](https://blog.kerollmops.com/meilisearch-is-too-slow). The new indexer is our answer to that challenge—a ground-up rewrite to dramatically improve speed.

The main goal of the new indexer is to improve the indexing speed of larger indexes with dozens of millions of documents, to relieve some of the stress on our infrastructure, to better exploit the resources of the machine, and to address some long-running pain points in a structured way.

## The crux of the matter: performance improvements

![Meme from the Jurassic Park movie with a t-rex (10m document updates) chasing a Jeep (Meilisearch)](https://unable-actionable-car.media.strapiapp.com/sometimes_more_speed_e32b6e5390.jpg "Sometimes you really gotta go faster")

_Sometimes you really gotta go faster_

In various scenarios, the new indexer is faster, sometimes multiple times faster, than the already optimized v1.11 indexer.

On machines with multiple cores, good IO and a lot of RAM, performance is vastly increased. Inserting new documents is twice as fast, while incrementally updating documents in a large database is x4 faster!

While the goal was to improve performance on bigger machines, we were successful in keeping similar or better performance for more modest machines with fewer cores and humble RAM (good IO remains vital to a database, though).

Additionally, for Cloud customers, we’re exploring optimizing our build by using native CPU instruction and [link-time-optimization (LTO),](https://llvm.org/docs/LinkTimeOptimization.html) yielding up to 12% improvements. We’re also considering advanced techniques like [profile-guided optimization (PGO)](https://doc.rust-lang.org/rustc/profile-guided-optimization.html), which so far has yielded an additional 12% improvement over native instructions and LTO.

## How it’s done: more parallelism, fewer I/O operations, pipelining writes

Meilisearch used to split a payload of documents into multiple chunks (roughly one per indexing thread), and would then work each chunk throughout the entire extraction process. Once a chunk was finished, it would then be persisted in the database.

This approach had a couple of drawbacks, performance-wise:

- As a lot of temporary data was extracted at the same time, it had to be written to disk and then read back to be persisted in the database, causing a lot of I/O operations.

- As the chunks were built independently of each other, they could result in us writing the same key to the database for each chunk, again causing unnecessary writes.

- As the chunks would finish computing at the same time on average, the indexing process would intensively use all the CPUs while computing the chunks, but then be solely single-threaded while writing everything to the database.

![old-process.png](https://unable-actionable-car.media.strapiapp.com/old_process_75e046f6ab.png "Simplified representation of the previous indexing process")

_Simplified representation of the previous indexing process_

In the new indexer, Meilisearch iterates in parallel over documents, performing a single extraction operation at a time. The result of that extraction is then merged in parallel, to compute the list of keys and values to send to the database. These keys and values are sent to the writer thread in a channel that acts as a pipeline, reducing the time where the merger threads wait for the writer thread.

![waits-faster.jpg](https://unable-actionable-car.media.strapiapp.com/waits_faster_36160c6cfb.jpg "The merger threads wait less thanks to pipelining")

_The merger threads wait less thanks to pipelining_

We successfully made the merger step parallel thanks to a key insight: while the extraction steps split documents between multiple threads, the merger step has to split database keys between multiple threads. For instance, to build the reverse index that matches a word with the list of documents that contain that word, each thread reads some of the documents to extract the words it contain, then all the documents containing a word are merged into a single list.

To make this possible, all threads during the extraction step deterministically hashes each word it encounters. Then during the merger step, words to handle are partitioned between threads depending on their hash value.

![new-process.png](https://unable-actionable-car.media.strapiapp.com/new_process_a34768ffec.png "Simplified representation of indexing process edition 2024")

_Simplified representation of indexing process edition 2024_

The drawback to this new approach is that some CPU-intensive operations, such as document tokenization, have to be duplicated across all steps. Still, merging in parallel utilizes a machine's multiple cores much more, reducing the time Meilisearch spends single-threaded.

Furthermore, by not duplicating key writes, the database size has been reduced by more than 30%.

## Better RAM control and usage

Meilisearch uses [bumpalo](https://docs.rs/bumpalo/latest/bumpalo/) to improve RAM control. Bumpalo is an arena allocator that allows to bulk deallocate memory and to query how much memory was allocated in an arena.

Arena allocators are often used in video games for objects that have to be recreated on each game frame, because allocating in an arena is very cheap (just a pointer bump), and deallocating can happen in bulk (yet another pointer bump) as long as no destructor has to be run.

In some regards, indexing documents with Meilisearch also has “frames”. In the new indexing approach, we can even detect two kinds of such frames: A very short-lived frame that corresponds to the work done on each document. And a longer-lived frame that starts at the beginning of each extraction step, and ends right after the merger is done sending everything to the writer. The “document” arena contains all allocations related to reading and tokenizing that document, while the “extraction” arena contains all allocations related to the data being extracted that will then be merged and written to the database.

![new-process(1).png](https://unable-actionable-car.media.strapiapp.com/new_process_1_ffaf674cd9.png)

During this process, Meilisearch queries the size of the “extraction” arena to detect when its RAM usage is above the threshold. When this happens, Meilisearch spills excess data to disk, so that the RAM usage stays in control.

If the extracted data fits in RAM, it never hits the disk, yielding fewer I/O operations.

## Faster and more reliable task cancellation

Historically, in the previous indexer, chunks of documents used to be very small, so it made sense to allow cancellation only after a chunk was done processing. Unfortunately, small chunks were inefficient when writing temporary data to disk, so we decided to switch to a “one chunk per core” model a few versions ago. This had an adverse effect on cancellation, as it would be processed almost at the end of the indexing process after all threads finished processing their chunk.

As the new Meilisearch iterates on documents, and further split the process by each extraction step, task cancellation is faster than ever, routinely being processed under 1s!

![cancel-all-the-tasks.jpg](https://unable-actionable-car.media.strapiapp.com/cancel_all_the_tasks_16b21cbbec.jpg "For all of you who regret sending all these documents at once")

_For all of you who regret sending all these documents at once_

## Better error messages

The new architecture exposes the document id to all extractors. This means that error messages can be enriched with this information as was done in [this PR](https://github.com/meilisearch/meilisearch/pull/5153): knowing which document caused the error allows for more effective troubleshooting.

## Better observability with progress

Lastly, the new indexer brings better observability to the table: because we know both which step we’re at and how many documents have been handled for this step, we can expose this information in the newly added `batches` [](https://www.notion.so/Enhance-visibility-on-batched-tasks-1194b06b651f810b8fe0fab5d72846a8?pvs=21)[route](https://www.notion.so/Enhance-visibility-on-batched-tasks-1194b06b651f810b8fe0fab5d72846a8?pvs=21) as a `progress` object.

```
{
  "uid": 160,
  "progress": {
    "steps": [
      {
        "currentStep": "processing tasks",
        "finished": 0,
        "total": 2
      },
      {
        "currentStep": "indexing",
        "finished": 2,
        "total": 3
      },
      {
        "currentStep": "extracting words",
        "finished": 3,
        "total": 13
      },
      {
        "currentStep": "document",
        "finished": 12300,
        "total": 19546
      }
    ],
    "percentage": 37.986263
  },
  "details": {
    "receivedDocuments": 19547,
    "indexedDocuments": null
  },
  "stats": {
    "totalNbTasks": 1,
    "status": {
      "processing": 1
    },
    "types": {
      "documentAdditionOrUpdate": 1
    },
    "indexUids": {
      "mieli": 1
    }
  },
  "duration": null,
  "startedAt": "2024-12-12T09:44:34.124726733Z",
  "finishedAt": null
}
```

In the above, we know that we finished extracting the words of 12300 out of 19546 documents. There are a total of 13 indexing steps, and we finished 3 of them already, for a global completion of 37.986263%.

Note that the `progress` object should only be used for display purposes, we do not guarantee that the step names or number remain the same from one version to the next.

Adding the `progress` object is a boon for the engine's observability, which already scored us concrete wins. We identified the bottleneck in a customer’s workload just by repeatedly calling the `batches` route and looking at which step was frequently seen.

## The best is yet to come!

The new indexer reaches new heights in maintainability with its structure that decouples the “business” extractors from its support functions (cancel, progress, reading a document), allowing us to quickly iterate on features, such as new settings to fine-tune the indexing behavior and the [AI stabilization](https://www.meilisearch.com/blog/meilisearch-1-13). In the future, we plan on adding progress to the settings tasks, enriching finished batches with the timing of each step. Feel free to share your ideas about what you’d like to see in Meilisearch on the [product discussion](https://github.com/orgs/meilisearch/discussions). If you’re new to Meilisearch, you can also try it for free on our Cloud.

Introducing Meilisearch's next-generation indexer: 4x faster updates, 30% less storage

What is latent semantic indexing (LSI) and how does it work?

You know what's amazing about search? It's at the heart of how people interact with your application. But let's be honest: building and managing search infrastructure can feel like you're spending more time wrestling with configuration than creating value for your users. That's why we're excited to share something that changes this completely: the Meilisearch MCP server.

## Why MCP? Building bridges between search and AI

Before we dive in, let's talk about what MCP (Model Context Protocol) is and why we're excited about it. [MCP](https://www.anthropic.com/news/model-context-protocol) is an emerging open protocol that standardizes how applications provide context to Large Language Models (LLMs). Think of it as a universal translator between your tools and AI models.

Even though MCP isn't yet fully standardized, we believe it represents the future of how developers will interact with their tools. Here's why:
- It creates a consistent way for AI models to interact with different tools and services
- It puts security and user control at the forefront
- It enables natural language interactions while maintaining precise control
- It's being built in the open, with input from the developer community

## From complex commands to natural conversations

Remember the last time you needed to update your search settings? It probably involved looking up API documentation, crafting the perfect JSON payload, and triple-checking your syntax. We've all been there. But what if you could just tell your search engine what you want, in plain English?

That's exactly what we've built. By implementing MCP, we've enabled natural conversations with Meilisearch through AI assistants like Claude. Here's what this means in practice using [our movies database](https://where2watch.meilisearch.com/) as an example:

### Before:
```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/settings' \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer MASTER_KEY' \
  --data-binary '{
    "rankingRules": [
      "words",
      "typo",
      "proximity",
      "attribute",
      "sort",
      "exactness"
    ]
  }'
```

### After:
> "Update the ranking rules for the movies index to prioritize word matches and handle typos."

That's it. When paired with advanced LLMs like Claude Sonnet, the AI understands your intent and handles all the technical details behind the scenes. No more context-switching between documentation tabs.

## What can you do with it today?

Thanks to the capabilities of modern LLMs, our MCP integration already enables natural language control over your Meilisearch instance. Here's what you can do right now:

1. **Index management made simple**
```"Create a new index for our product catalog and optimize it for e-commerce search"```
The AI will guide you through setting up your index with appropriate configurations for e-commerce.

2. **Search optimization**
```"Our users are having trouble finding products when they make typos. How can we fix this?"```
Get instant guidance on configuring typo tolerance and seeing real-time results.

3. **Performance insights**
```"How is our search performance looking? Any areas we should optimize?"```
Understand your search analytics and get actionable recommendations.

## How does it work?

Our current MCP implementation exposes Meilisearch's capabilities through a set of carefully designed tools that AI assistants can use to manage your search infrastructure. When paired with advanced LLMs like [Claude Sonnet](https://www.anthropic.com/news/claude-3-5-sonnet), these tools enable natural conversations about complex search operations.

The best part? It works seamlessly with Claude Desktop and other MCP-compatible clients, giving you:
- Natural language control over your search infrastructure
- Instant access to best practices and optimization tips
- Real-time insights and analytics

## Getting started in 2 minutes

1. Install [Claude Desktop](https://claude.ai/download) (it's free!)
2. Add our MCP server to your configuration:

```json
{
  "mcpServers": {
    "meilisearch": {
      "command": "uvx",
      "args": ["-n", "meilisearch-mcp"]
    }
  }
}
```
3. Start managing your search like you're chatting with a colleague!

## Building the future of search

This is just the beginning of our mission to make search infrastructure more accessible. Here's what we're working on next:

### Smart prompts
We're developing pre-built templates for common scenarios like:
- Optimizing index settings for specific use cases (e-commerce, documentation, etc.)
- Debugging search behavior and performance issues
- Understanding and improving search analytics
- Implementing industry-specific best practices

### Enhanced capabilities
- More sophisticated analytics and monitoring tools
- Expanded AI assistant integrations
- Advanced collaborative features for teams
- Deeper integration with Meilisearch Cloud

## Open source and open for contributions

True to our values, the Meilisearch MCP server is completely open source. We believe in building in public and learning from our community. Check out our implementation, contribute, or adapt it for your needs:

[GitHub repository](https://github.com/meilisearch/meilisearch-mcp)

## Join us in simplifying search

- ⭐ Star [our repository](https://github.com/meilisearch/meilisearch)
- 💬 Join our [Discord community](https://discord.meilisearch.com/) & share your use cases (or do it on social media and tag us)
- 🛠️ Contribute to development on [GitHub](https://github.com/meilisearch/meilisearch-mcp)

We're excited to see how you'll use this to build better search experiences. Try it out and let us know what you think!

How we made Meilisearch talk to AI: introducing our MCP server

We're excited to introduce Meilisearch v1.13. In this article, we'll cover the most significant changes. For a full list of updates, visit the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.13.0) on GitHub.

<Callout intent="tip">
Meilisearch 1.13 is available on [Meilisearch Cloud](https://cloud.meilisearch.com/?utm_campaign=release-v1-13&utm_source=blog), too—upgrade now!
</Callout>

## AI-powered search

We are thrilled to announce that AI-powered search is now fully stable! 

First released in v1.3, our vector store has evolved to auto-embedding from common providers, semantic and hybrid search, always based on our community's invaluable feedback. This feature is now ready to leave the experimental phase. 

Therefore, you no longer need to activate it using the `/experimental-features` route.

v1.13 introduces the last breaking changes to the AI-powered search feature.

### Breaking: accepted Ollama URLs

Ollama URLs will only be accepted if they end with `/api/embed` and `/api/embeddings`, passing an unsupported endpoint will now trigger an error on Meilisearch

### Breaking: error code modifications
Prior to 1.13, if the embedder configuration was missing or wasn't a string, Meilisearch would return an `invalid_embedder`error for both search and similarity requests.

It has been split into:
    - `invalid_search_embedder`: for search requests
    - `invalid_similar_embedder`: for similar requests
    
When the `hybrid` search parameter is invalid, the error `invalid_search_hybrid_query` is now returned instead of `invalid_hybrid_search`.


## Experimental: remote federated search 

The new [network route](https://www.meilisearch.com/docs/reference/api/network) enables distributed search across multiple Meilisearch instances. Combined with federated search, this simplifies implementing horizontal database partitioning strategies like sharding.

[Activate](https://www.meilisearch.com/docs/reference/api/experimental_features) this feature via the `/experimental-features` route. If you are using Meilisearch Cloud, contact support to enable this feature in your projects.

Use the `remotes` object to define the Meilisearch instances that should participate in the search. 



```json
PATCH /network
{
  "remotes": {
    "ms-01": {
      "url": "http://ms-1.example.meilisearch.io",
      "searchApiKey": "SEARCH_KEY_1"
    },
    "ms-02": {
      "url": "http://ms-2.example.meilisearch.io",
      "searchApiKey": "SEARCH_KEY_2"
    }
  }
}
```

Set the same remotes on all set of Meilisearch instances, then configure each instance with its own identifier using `self`. The value of `self` must match the corresponding key in remotes:

```json
PATCH /network
{
  "self": "ms-01"
}
```

You can now perform a remote federated search:

```json
POST /multi-search
{
  "federation": { // enable federated mode
    "limit": 5
  },
  "queries": [
    { // #0
      "q": "Batman",
      "indexUid": "movies",
      "federationOptions": {
        "remote": "ms-01"
      }
    },
    { // #1
      "q": "Batman",
	    "indexUid": "movies",
	    "federationOptions": {
        "remote": "ms-02"
      }
    }
  ]
}
```

## Experimental: new dumpless upgrade

You can now upgrade from Meilisearch >=v1.12 to Meilisearch >=v1.13 without using a [dump](https://www.meilisearch.com/docs/reference/api/dump).

Simply install the latest version of Meilisearch and relaunch it with either [instance option](https://www.meilisearch.com/docs/learn/self_hosted/configure_meilisearch_at_launch#dumpless-upgrade):
- the `--experimental-dumpless-upgrade` flag
- or the `MEILI_EXPERIMENTAL_DUMPLESS_UPGRADE` environment variable

⚠️ As this is an experimental feature, please use [snapshots](https://www.meilisearch.com/docs/learn/advanced/snapshots) to back up all important data first.

## New stats 

Meilisearch 1.3 introduces 3 new fields to the [stats object](https://www.meilisearch.com/docs/reference/api/stats#stats-object):

- `numberOfEmbeddedDocuments`: total number of documents with at least one embedding
- `numberOfEmbeddings`: total number of embeddings in an index 
- `usedDatabaseSize`: storage space used by the database in bytes, excluding unused space claimed by LMDB.  Unlike `databaseSize`, this value decreases when documents are removed.

Here is an example stats object returned (as of Meilisearch 1.13):

```json
GET /stats

{
  "databaseSize": 447819776,
  "usedDatabaseSize": 196608,
  "lastUpdate": "2019-11-15T11:15:22.092896Z",
  "indexes": {
    "movies": {
      "numberOfDocuments": 19654,
      "numberOfEmbeddedDocuments": 1,
      "numberOfEmbeddings": 1,
      "isIndexing": false,
      "fieldDistribution": {
        "poster": 19654,
        "overview": 19654,
        "title": 19654,
        "id": 19654,
        "release_date": 19654
      }
    },
    "books": {
      "numberOfDocuments": 5,
      "numberOfEmbeddedDocuments": 5,
      "numberOfEmbeddings": 10,
      "isIndexing": false,
      "fieldDistribution": {
        "id": 5,
        "title": 5,
        "author": 5,
        "price": 5, 
        "genres": 5
      }
    }
  }
}
```

## Contributors shout-out

We're incredibly grateful to the external contributors who helped make this release possible. Thanks to [@takaebato](https://github.com/takaebato), [@Sherlouk](https://github.com/Sherlouk), [@jameshiew](https://github.com/jameshiew), [@K-Kumar-01](https://github.com/K-Kumar-01), [@mhmoudr](https://github.com/mhmoudr), [@eltociear](https://github.com/eltociear), [@Gnosnay](https://github.com/Gnosnay), [@DerTimonius](https://github.com/DerTimonius), [@manojks1999](https://github.com/manojks1999), [@ellnix](https://github.com/ellnix), [@Guikingone](https://github.com/Guikingone), [@migueltarga](https://github.com/migueltarga) for their contributions to [Meilisearch](https://github.com/meilisearch/meilisearch).

---

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

---

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

For anything else, join our developers community on [Discord](https://discord.meilisearch.com/?utm_campaign=release-v1-13&utm_source=blog).


Meilisearch latest news and company updates