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

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


<Callout intent="tip">

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

</Callout>

## New: Multi-modal search and embeddings

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

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

<Callout intent="tip">

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

</Callout>

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

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

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

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

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

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

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

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

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

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

## New: Transferring documents between Meilisearch instances 

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

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

## New: Sorting on the documents API

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

## ICYMI: Conversational search

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

## Contributors shout-out

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

---

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

---

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

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

Meilisearch 1.16

We're happy to announce the release of Meilisearch v1.15. In this article, we'll highlight the key changes and improvements in this release.

For a complete list of all updates and fixes, please visit the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.15.0) on GitHub.


<Callout intent="tip">

These powerful new features are available in [Meilisearch Cloud](https://meilisearch.com.cn/cloud). Sign up now to be among the first to experience the latest improvements!

</Callout>

## New in 1.15.1: Conversational search 

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

## New: Disable typo tolerance for numbers

With Meilisearch v1.15, you can turn off [typo tolerance](https://meilisearch.com.cn/docs/learn/relevancy/typo_tolerance_settings) for numeric values—just like you already do for words and attributes.

A search for `2024` will match only `2024`, not `2025` or `2004`. This is especially helpful when searching for postal addresses or phone numbers.

Skipping number fuzziness can also speed up your indexing, especially for datasets that contain many unique numbers.

## New: Lexicographic string filters

You can now compare any string with `<`, `<=`, `>`, `>=` or an open range `TO`—just like numbers—using [lexicographic order](https://en.wikipedia.org/wiki/Lexicographic_order).

This is ideal for scenarios where you need to filter by human-readable values—such as dates (e.g., “2025-05-28”) instead of numeric timestamps.

The following filter finds every record released before July 17, 2023:

```
release_date < "2023-07-17" 
```

## Improvement: better support for Chinese

We’ve enhanced the Charabia tokenizer to provide more precise segmentation of Chinese text. **If your dataset contains Chinese-language content, you must reindex your database**—otherwise, Chinese queries and documents will not be processed correctly and may be ignored during search.

To reindex, you can use a [dump](https://meilisearch.com.cn/docs/reference/api/dump) or—if you are using the [dumpless upgrade](https://meilisearch.com.cn/docs/learn/update_and_migration/updating#dumpless-upgrade)—trigger a reindexing with one of the following methods:

1. **Add Chinese to your localized attributes**
Include the Chinese locale (e.g., cmn) in your [localizedAttributes](https://meilisearch.com.cn/docs/reference/api/settings#localized-attributes).

2. **Update your stop-word list or dictionary**
Make any change to your [stop words](https://meilisearch.com.cn/docs/reference/api/settings#update-stop-words) or custom [dictionary](https://meilisearch.com.cn/docs/reference/api/settings#update-dictionary) entries. 

3. **Refresh the searchable attribute**
Temporarily remove an attribute from [searchable attributes](https://meilisearch.com.cn/docs/reference/api/settings#update-searchable-attributes) list, then re-add it once the removal task has completed.

## Contributors shout-out

We want to give a massive thank you to the contributors who made this release possible. Special thanks to [CodeMan62](https://github.com/CodeMan62), [shaokeyibb](https://github.com/shaokeyibb), [HDT3213](https://github.com/HDT3213), [shu-kitamura](https://github.com/shu-kitamura), [DanasFi](https://github.com/DanasFi), [vuthanhtung2412](https://github.com/vuthanhtung2412), and [ZeroZ-lab](https://github.com/ZeroZ-lab) for their contributions to [Meilisearch](https://github.com/meilisearch/meilisearch); to [luflow](https://github.com/luflow), [mosuka](https://github.com/mosuka), and [HDT3213](https://github.com/HDT3213) for their work on [Charabia](https://github.com/meilisearch/charabia); and to [lucascool12](https://github.com/lucascool12) and [Dr-Emann](https://github.com/Dr-Emann) for their efforts on [RoaringBitmap](https://github.com/RoaringBitmap/roaring-rs).

---

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

---

For more information, subscribe to our [monthly newsletter](https://dub.sh/meili-newsletter#release-v1-15&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/#release-v1-15&utm_source=blog).

Meilisearch 1.15

We're excited to announce the release of Meilisearch v1.14.  In this article, we'll highlight the key changes and improvements in this release.

For a complete list of all updates and fixes, please visit the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.14.0) on GitHub.


<Callout intent="tip">

These powerful new features are coming soon to [Meilisearch Cloud](https://cloud.meilisearch.com/#release-v1-14&utm_source=blog). Sign up now to be among the first to experience the latest improvements!

</Callout>


## New: granular filterable attributes settings

With Meilisearch v1.14, you can configure filterable attributes using an [advanced object format](https://meilisearch.com.cn/docs/reference/api/settings#filterable-attribute-object) that lets you specify exactly which filtering features to enable for each attribute pattern:

```json
{
	"filterableAttributes": [
	  {
	    "attributePatterns": ["genre", "artist"], 
	    "features": { "facetSearch": true, "filter": {"equality": true, "comparison": false } }
	  },
	  {
	    "attributePatterns": ["*rank"],
	    "features": { "facetSearch": false, "filter": {"equality": true, "comparison": true } }
	  },
	  {
	    "attributePatterns": ["albumId"],
	    "features": { "facetSearch": false, "filter": {"equality": true, "comparison": false } }
	  },
	]
}
```

* **String attributes** (e.g., `genre`, `artist`): enable facet search and equality operators (`=` / `!=`) for categorical filtering, while disabling comparison operators (`>`, `<`, `>=`, `<=`), which are unnecessary for string values.
* **Numeric attributes** (e.g., `*rank`): enable comparison operators (`>`, `<`, `>=`, `<=`) for range filtering, while disabling facet search, as it's not relevant for numerical data.
* **Unique identifiers** (e.g., `albumId`): enable equality operators for exact matching, while disabling unused features such as comparison operators and facet search.

This targeted configuration can notably boost indexing performance. 

## Experimental: composite embedders

Meilisearch 1.14 introduces a new experimental feature that lets you use [different embedders at search and indexing time](https://meilisearch.com.cn/docs/reference/api/settings#indexingembedder-and-searchembedder), allowing you to optimize for both throughput and latency.
* Use a remote embedder for indexing in bulk, as remote embedders provide the highest bandwidth (embeddings/s)
* Use a local embedder for answering search queries, as local embedders provide the lowest latency (time to first embedding)

Configure your embedders using the new `composite` [source type](https://meilisearch.com.cn/docs/reference/api/settings#source). For instance, you can combine a local Hugging Face model for fast search with a remote inference endpoint for efficient indexing:

```json
{
    "embedders": {
        "text": {
            "source": "composite",
            "searchEmbedder": {
                "source": "huggingFace", // locally computed embeddings using a model from the Hugging Face Hub
                "model": "baai/bge-base-en-v1.5",
                "revision": "a5beb1e3e68b9ab74eb54cfd186867f64f240e1a"
            },
            "indexingEmbedder": {
                "source": "rest", // remotely computed embeddings using Hugging Face inference endpoints
                "url": "https://URL.endpoints.huggingface.cloud",
                "apiKey": "hf_XXXXXXX",
                "documentTemplate": "Your {{doc.template}}",
                "request": {
                    "inputs": [
                        "{{text}}",
                        "{{..}}"
                    ]
                },
                "response": [
                    "{{embedding}}",
                    "{{..}}"
                ]
            }
        }
    }
}
```

Meilisearch automatically selects the appropriate embedder based on the current operation.

Activate this feature in your project overview by checking the "Composite embedders" box under "Experimental features". If you are self-hosting Meilisearch, [enable it](https://meilisearch.com.cn/docs/reference/api/experimental_features) via the `/experimental-features` route. 

## Experimental: cache embeddings

Meilisearch 1.14 brings a new experimental feature that allows you to [cache search query embeddings](https://meilisearch.com.cn/docs/learn/self_hosted/configure_meilisearch_at_launch#search-query-embedding-cache), significantly improving performance when the same query is run multiple times.

To enable the search query embedding cache, launch Meilisearch with either instance option specifying the maximum number of entries to store in the cache:
* the `--experimental-embedding-cache-entries=150` flag
* the `MEILI_EXPERIMENTAL_EMBEDDING_CACHE_ENTRIES=150` environment variable

When enabled, Meilisearch stores the embedding vectors for search queries, eliminating the need to repeatedly generate embeddings for identical queries. This is particularly valuable in scenarios where:

* The same queries are frequently repeated
* You're using multi-search across multiple indexes
* You've implemented local sharding where identical queries are sent to different indexes

## New: get documents by id

You can now [get a set of documents by their primary keys](https://meilisearch.com.cn/docs/reference/api/documents#get-documents-with-post):

```json
// POST /indexes/INDEX_UID/documents/fetch
{
    "ids": [785084, 44214, 473],
}
```

The above query will return the corresponding documents:

```json
{
    "results": [
        {
            "id": 44214,
            "title": "Black Swan"
        },
        {
            "id": 473,
            "title": "Pi"
        },
        {
            "id": 785084,
            "title": "The Whale"
        }
    ],
    "offset": 0,
    "limit": 20,
    "total": 3
}
```

## Contributors shout-out

We want to give a massive thank you to the contributors who made this release possible. Special thanks to [@MichaScant](https://github.com/MichaScant) for their work on [Meilisearch](https://github.com/meilisearch/meilisearch), [@oXtxNt9U](https://github.com/oXtxNt9U) for contributions to [Heed](https://github.com/meilisearch/heed), [@ptondereau](https://github.com/ptondereau) for efforts on [Arroy](https://github.com/meilisearch/arroy), and both [@NarHakobyan](https://github.com/NarHakobyan) and [@mosuka](https://github.com/mosuka) for their contributions to [Charabia](https://github.com/meilisearch/charabia). We’re deeply grateful for your support and collaboration.

---

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

---

For more information, subscribe to our [monthly newsletter](https://dub.sh/meili-newsletter#release-v1-14&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/#release-v1-14&utm_source=blog).

Meilisearch 1.14

# Meilisearch AI launch week recap

As the first quarter of 2025 closes, we've completed our first [Meilisearch launch week](https://meilisearch.com.cn/launch-week), marking our most significant product evolution since introducing Meilisearch Cloud. This update brings comprehensive AI-powered search capabilities to all users.

Traditional keyword search has limits. It matches characters, not intent—often returning results that miss the mark. [AI-powered search changes that](https://meilisearch.com.cn/blog/introducing-meilisearch-ai). By understanding meaning, not just words, it delivers smarter, more intuitive results.

## What we announced: Day by day

#### Day 1: Semantic and hybrid search now GA

We kicked off the week by announcing that our AI capabilities, including semantic search and hybrid search, are now generally available:

- **Semantic search**: AI-powered understanding delivers more relevant results beyond simple keyword matching
- **Hybrid search**: Combines traditional full-text reliability with semantic intelligence
- **Performance optimization**: All this intelligence with sub-50ms response time

We launched semantic and hybrid search as generally available on the Meilisearch platform. Now your search results understand context, personalize experiences, and power better recommendations, whether you're building an e-commerce site, a knowledge base, a media and news archive, or a SaaS app.

These capabilities significantly reduce failed searches and "no results" responses. [E-commerce platforms report higher conversion rates](https://meilisearch.com.cn/blog/Agora) as shoppers find products using natural language, while [app builders](https://meilisearch.com.cn/blog) see increased engagement as users discover precisely what they need, even with imprecise queries.

**📹 [Watch our Head of Product, Guillaume, explain the release](https://www.youtube.com/watch?v=3JaDBEQNLZc&t).**


#### Day 2: Multiple embedder options and vector storage

On day two, we made vector search more flexible with multiple embedder choices—eliminating the need for separate vector database infrastructure:

- **Choose your embedder**: OpenAI, Hugging Face, Ollama, or bring your own
- **documentTemplate feature**: Better prompting for improved results
- **Binary quantization**: Optimize large databases for speed while maintaining result quality

Our flexible embedder options address critical infrastructure and cost concerns. Organizations can choose solutions that balance budget constraints, performance requirements, and proprietary needs. This approach eliminates the expense of maintaining separate vector databases and reduces operational complexity.

**📹 [Watch the walkthrough – Our Sr. Product Manager, María, explains embedders and best practices.](https://youtu.be/0tPsBrmtf3o?si=6KAyuREv0DYVfCZD).**


#### Day 3: Multi-modal search capabilities

The middle of the week brought multi-modal search, allowing searches beyond just text. This opens new possibilities for industries with diverse content types:

- **Flexible input types**: Search across text, images, and more
- **AI-powered semantics**: Smarter results across content types
- **Real-world implementations**: learn more about how early adopters like [Agora](https://meilisearch.com.cn/blog/Agora) and [MotionElements](https://meilisearch.com.cn/blog/motionelements) already using these capabilities
    
    ![MotionElements_multimodal.gif](https://unable-actionable-car.media.strapiapp.com/Motion_Elements_multimodal_6cfa386d8d.gif)

#### Day 4: Personalized recommendations

Thursday's focus was on helping users discover relevant content faster:

- **/SIMILAR documents**: Find content similar to what you're viewing
- **Engagement improvements**: Smart, similarity-based product and document recommendations
- **Seamless user experience**: Help users find what they need (and didn't know about)
    
    ![day 4_recommendations.gif](https://unable-actionable-car.media.strapiapp.com/day_4_recommendations_e67bc9c528.gif)

#### Day 5: Wrapping up and looking ahead

https://youtu.be/I42NbytO0hQ

We closed the week with a recap and vision for the future with our CEO, Quentin.

At Meilisearch, our mission is to make the best search experience accessible to everyone. We want to deliver the best technologies and combine them with an amazing user experience. This week, we’ve taken a big step forward and are closer to this vision, helping search results understand context, offer personalized experiences, and enable smarter recommendations.

In the coming months and quarters, you'll see exciting new features—from better search analytics and more insights for taking action on your business, to more customization capabilities for tailored experiences, but also we’ll continue advancing on exclusive capabilities like [built-in RAG](https://meilisearch.com.cn/blog/how-to-build-rag#dailydev) or [image search](https://meilisearch.com.cn/docs/learn/ai_powered_search/image_search_with_user_provided_embeddings) to make them work out of the box, with little to no configuration required.

**📹 [Watch Meilisearch AI launch week wrap up with CEO](https://youtu.be/0tPsBrmtf3o?si=6KAyuREv0DYVfCZD).**

**📖 Read Quentin’s [blog](https://meilisearch.com.cn/blog/introducing-meilisearch-ai) on building the future of search with Meilisearch AI.**
## Join us on this journey

As we celebrate reaching **50,000 GitHub stars,** we're just getting started on our mission to redefine search. Whether you're new to Meilisearch or already part of our community, these new capabilities unlock more intuitive, personalized search experiences.

To mark the occasion, we’re giving new subscribers an exclusive gift: use the code **`MEILIAI`** and **get [2 months of Meilisearch](https://help.meilisearch.com/en/article/meilisearchs-promo-discount-code-program-1ykitx7/), including AI-powered searches, completely free**. It’s the perfect time to start building the search experience you’ve always wanted.

Meilisearch AI launch week recap

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.net.cn/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.net.cn/docs/LinkTimeOptimization.html) yielding up to 12% improvements. We’re also considering advanced techniques like [profile-guided optimization (PGO)](https://doc.rust-lang.net.cn/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://meilisearch.com.cn/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

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/#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://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/docs/reference/api/dump).

Simply install the latest version of Meilisearch and relaunch it with either [instance option](https://meilisearch.com.cn/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://meilisearch.com.cn/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://meilisearch.com.cn/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#release-v1-13&utm_source=blog), check out the [roadmap](https://roadmap.meilisearch.com/#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/#release-v1-13&utm_source=blog).


Meilisearch 1.13

We're excited to introduce Meilisearch v1.12. 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.12.0) on GitHub.

<Callout>
Meilisearch 1.12 is available on Meilisearch Cloud, too—upgrade now!
</Callout>

## New: `facetSearch` and `prefixSearch` index settings

Meilisearch 1.12 introduces new APIs to disable [facet search](https://meilisearch.com.cn/docs/learn/filtering_and_sorting/search_with_facet_filters) and [prefix search](https://meilisearch.com.cn/docs/learn/engine/prefix). When disabled, both these settings allow Meilisearch to skip building the required data structures to enable these features. As a result, the indexing process gets much faster.

<Callout>
Disabling these features can impact search result relevancy. Be sure to assess whether your product relies on them before proceeding.
</Callout>

### Updating facet search index settings

Use the new API to [update facet search](https://meilisearch.com.cn/docs/reference/api/settings#update-facet-search-settings) index settings:

```ts
// disable facet search
client.index('my_index').setFacetSearch(false)
// enable facet search (default)
client.index('my_index').setFacetSearch(true)
```

### Updating prefix search index settings

Use the new API to [update prefix search](https://meilisearch.com.cn/docs/reference/api/settings#update-prefix-search-settings) index settings:

```ts
// disable prefix search
client.index('my_index').setPrefixSearch('disabled')
// enable prefix search (default)
client.index('my_index').setPrefixSearch('indexingTime')
```

## New: batches API

Meilisearch 1.12 introduces a new [batches API](https://meilisearch.com.cn/docs/reference/api/batches) to retrieve data about batches. A batch is a set of [tasks](https://meilisearch.com.cn/docs/learn/async/asynchronous_operations) processed together by Meilisearch.

Here is an example batch object returned (as of Meilisearch 1.12.0):

```json
{
  "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": {
      "movies": 1
    }
  },
  "duration": null,
  "startedAt": "2024-12-12T09:44:34.124726733Z",
  "finishedAt": null
}
```

Please note that the [get batches API](https://meilisearch.com.cn/docs/reference/api/batches#get-batches) accepts the same parameters as the [get tasks API](https://meilisearch.com.cn/docs/reference/api/tasks#get-tasks), allowing you to retrieve batches by filtering by task data. 

For example, you can use `GET /batches?uid=123` to retrieve batches containing tasks with a `taskUid` of `123`.

### Tasks API update

For better integration, the [tasks API](https://meilisearch.com.cn/docs/reference/api/tasks) now includes a `batchUid` field in task objects. You can use this value to retrieve details about a specific batch using the API to [get one batch](https://meilisearch.com.cn/docs/reference/api/batches#get-one-batch).
## Indexing speed improvements 

Meilisearch 1.12 brings indexing speed improvements across the board for servers making use of multiple cores and having good I/O throughput.

This new release brings:
- 2x faster raw document insertion
- 4x faster incremental document updates in large databases
- 1.5x faster embedding generation

Additionally, this release makes task cancellation faster. On less powerful machines, indexing time remains similar but may show slight improvements.

These advancements build upon the indexing customization and speed enhancements introduced in [Meilisearch 1.6](https://meilisearch.com.cn/blog/meilisearch-1-6).

## Contributors shout-out

We want to give a massive thank you to the external contributors who made this release possible. Thanks to [@airycanon](https://github.com/airycanon), [@DerTimonius](https://github.com/DerTimonius), [@flevi29](https://github.com/flevi29), [@LukasKalbertodt](https://github.com/LukasKalbertodt), [@PedroTurik](https://github.com/PedroTurik), and [@wuast94](https://github.com/wuast94) for their contribution to [Meilisearch](https://github.com/meilisearch/meilisearch), and [@dqkqd](https://github.com/dqkqd) and [@tats-u](https://github.com/tats-u) for their work on [charabia](https://github.com/meilisearch/charabia).

We also want to extend special thanks to our SDK maintainers working hard to make Meilisearch available across many [languages and frameworks](https://meilisearch.com.cn/docs/learn/what_is_meilisearch/sdks).

---

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

Upgrade with ease using Meilisearch Cloud.

[Open Meilisearch Cloud](https://cloud.meilisearch.com/login)

---

For more information, subscribe to our [monthly newsletter](https://dub.sh/meili-newsletter#release-v1-12&utm_source=blog), check out the [roadmap](https://roadmap.meilisearch.com/#release-v1-12&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/#release-v1-12&utm_source=blog).

Meilisearch 1.12

We've been busy working on things you've asked for, and the team is excited to share what's new in Meilisearch this quarter.

## A revamped search preview 🔍

The [search preview](https://meilisearch.com.cn/docs/learn/getting_started/search_preview) has been one of our most-used features, but it didn't let you test everything Meilisearch can do. We've now rebuilt our search preview to make it more useful to assess test search result relevancy when you are tweaking an index's settings.

What's included:

- Show/hide the results' [ranking score](https://meilisearch.com.cn/docs/learn/relevancy/ranking_score):

![ranking score.png](https://unable-actionable-car.media.strapiapp.com/image_38_9583f10fe8.png)

- Check and customize search options
- Configure filterable attributes as facets
- Test [AI-powered searches](https://meilisearch.com.cn/docs/learn/ai_powered_search/getting_started_with_ai_search) if this functionality has been enabled for your project.

An updated preview allows you to test everything in real-time, making it easier to get your search working exactly how you want.

## New index settings in the UI ⚙️

We've fixed one of your biggest frustrations - you and your team no longer need to rely on JSON input to [change your index settings](https://meilisearch.com.cn/docs/learn/configuration/configuring_index_settings). Instead of typing JSON code, you'll now see straightforward controls in the UI for adjusting settings like:

- Add and delete searchable attributes:
![searchable attributes/index settings.png](https://unable-actionable-car.media.strapiapp.com/image_37_5bea152778.png)

- Change the ranks of your searchable attributes
- Reset to default

Now anyone on your team can get access to user-friendly modification of the index settings without needing to understand JSON syntax.

## Speed up your search  with feature opt-out 🚀

We've got some updates for those of you working with massive datasets. To **reduce disk usage** and **speed up indexing by up to 15%**, you can now optimize Meilisearch's performance: 

- Choose to opt-out of prefix search and facet search features
- Reduce indexing time and save disk space

This has been one of our most requested features from users dealing with large-scale deployments, and we're excited to see how you'll use it.

## What else is cooking? 🎯
#### New Japan region is coming in Q4! 🇯🇵
Soon, you’ll be able to host your Meilisearch projects in Japan. This means much faster searches for users in Asia-Pacific - instead of connecting to Singapore, they'll connect directly to servers in Japan. The difference? A search that used to take 80+ milliseconds will happen almost instantly.

To use it, you’ll just need to pick Japan when you create a new project in the [cloud](https://cloud.meilisearch.com) dashboard. Keep an eye on our updates to know exactly when it’s released!


We are not stopping here. Our team is already working on our early 2025 releases. Here's a quick spoiler:

- AI-powered hybrid search general availability
- New Cloud dashboard features
- Even better performance optimizations

## Try it out!

Want to test these features? [Sign up for Meilisearch Cloud](https://cloud.meilisearch.com/) to experience these new features firsthand.

---

We built these changes based on your feedback, and we'd love to know if they help. Try them out and tell us what you think.

For  a more in-depth look at these updates, visit our [documentation](https://docs.meilisearch.com/).

Meilisearch Q4 2024 release wrap-up

We're excited to introduce Meilisearch v1.11. 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.11.0) on GitHub.

<Callout>
  Meilisearch 1.11 is available on [Meilisearch Cloud](https://cloud.meilisearch.com/#release-v1-11&utm_source=blog), too—upgrade now!
</Callout>

## Experimental: vector database indexing performance improvements

Meilisearch v1.11 introduces a [new embedder option](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-11&utm_source=blog#binaryquantized): `binaryQuantized`.

Binary quantization compresses vectors by encoding each dimension with 1-bit values, significantly boosting performance, especially in datasets with over 1M documents and models with more than 1024 dimensions.

Smaller embeddings (under 1024 dimensions) tend to give worse results. With fewer dimensions, the binary vector doesn't retain enough information for good relevancy.


<Callout>
Enabling this feature permanently updates all vectors to contain only 1s and -1s, which can greatly affect search relevancy. This change is irreversible.
</Callout>

Before enabling this feature, we recommend testing it in a smaller or duplicate index in a development environment to evaluate its impact on your use case.

## Experimental: AI-powered search improvements

### Breaking changes

This release introduces several breaking changes for feature stabilization. 

####  `embedder` parameter becomes mandatory

In previous versions, the default embedder was automatically used for search and similar requests when no embedder was specified. Starting with v1.11, it’s now mandatory to specify the `embedder` parameter when performing:
- Semantic or hybrid search via [`GET`](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#search-in-an-index-with-get) and [`POST`](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#search-in-an-index-with-post) where the embedder must be included as part of the `hybrid` object.
- Similarity search via [`GET`](https://meilisearch.com.cn/docs/reference/api/similar#release-v1-11&utm_source=blog#get-similar-documents-with-get) and [`POST`](https://meilisearch.com.cn/docs/reference/api/similar#release-v1-11&utm_source=blog#get-similar-documents-with-post), where the `embedder` is required as a top-level parameter.


```javascript
// Semantic and hybrid search
client.index('INDEX_NAME').search(
  query, {
    hybrid: {
      embedder: 'EMBEDDER_NAME' // mandatory as of v1.11
   }
  }
)

// Similarity search
client.index('INDEX_NAME').searchSimilarDocuments({ 
  id: 'TARGET_DOCUMENT_ID',
  embedder: 'EMBEDDER_NAME' // mandatory as of v1.11
})
```

Additionally, even for full-vector searches (when using `vector` without `q`), you must include the `hybrid` object with the `embedder`.

```javascript
client.index('INDEX_NAME').search({
  vector: [0, 1, 2],
  hybrid: {
      embedder: 'EMBEDDER_NAME'// mandatory as of v1.11
   }
})
```

#### Non-zero `semanticRatio` now ignored when passing `vector` without `q`

Before Meilisearch v1.11, when performing a search with the [`vector`](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#vector-experimental) and [`hybrid`](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#hybrid-search-experimental) parameters but without [`q`](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#query-q), a [placeholder keyword search](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#placeholder-search) occurred unless `hybrid.semanticRatio` was set to `1.0`. In v1.11, a semantic search is always performed unless `hybrid.semanticRatio` is set to `0.0`.

### Additions and improvements

#### Default OpenAI model update

The default [OpenAI model](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-11&utm_source=blog#model) has been updated from `text-embedding-ada-002` to the new `text-embedding-3-small`. This new model is both more cost-effective and more accurate than the legacy `ada` model, offering better performance at a lower cost.

#### New embedder parameter

Meilisearch 1.11's new `documentTemplateMaxBytes` [parameter](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-11&utm_source=blog#documenttemplatemaxbytes) allows truncating the document's template text when it exceeds the specified byte limit. It is set, by default, to 400 bytes. 

This change is backward compatible. Existing embedders will retain the 400-byte default, with no need to recompute embeddings during the upgrade. The new limit will only apply when a document is modified and the template is re-rendered.

#### Improved document template

Fields in `documentTemplate` now include the `field.is_searchable` property. The default [document template](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-11&utm_source=blog#documenttemplate) will filter out both empty fields and fields not in the searchable attributes list. The new default template only applies to embedders created starting with v1.11.


```liquid
// v1.11 default document template
{% for field in fields %}
  {% if field.is_searchable and not field.value == nil %}
    {{ field.name }}: {{ field.value }}
  {% endif %}
{% endfor %}

// v1.10 default document template
{% for field in fields %}
  {{ field.name }}: {{ field.value }}
{% endfor %}
```

## Federated search improvements: facet distribution and stats

Meilisearch v1.11 introduces two new options for federated searches: `facetsByIndex` and `mergeFacets`. These options allow you to request facet [distribution](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#facetdistribution) and [stats](https://meilisearch.com.cn/docs/reference/api/search#release-v1-11&utm_source=blog#facetstats) for federated search results.

### Facet Information by index

To retrieve facet distribution and stats for each individual index, use the `facetsByIndex` [option](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-11&utm_source=blog#facetsbyindex). 


```json
{
  "federation": {
    "facetsByIndex": {
      "movies": ["title", "id"],
      "comics": ["title"]
    }
  },
  "queries": [
    { "q": "Batman", "indexUid": "movies" },
    { "q": "Batman", "indexUid": "comics" }
  ]
}
```

The response will include facet distribution and stats for each index:


```json
{
  "facetsByIndex": {
    "movies": {
      // Facet distribution for queries on the `movies` index
      "distribution": {
        "title": {
          "Batman returns": 1
        },
        "id": {
          "42": 1
        }
      },
      // Facet stats for queries on the `movies` index
      "stats": {
        "id": {
          "min": 42,
          "max": 42
        }
      }
    },
    "comics": {
      // Facet distribution for queries on the `comics` index
      "distribution": {
        "title": {
          "Batman: the killing joke": 1
        }
      },
      // Facet stats for queries on the `comics` index (empty because only numeric values are considered)
      "stats": {}
    }
  }
}
```

### Merged facet information

To get facet distribution and stats from all indexes in a single result, use both [`facetsByIndex`](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-11&utm_source=blog#facetsbyindex) and [`mergeFacets`](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-11&utm_source=blog#mergefacets):


```json
POST /multi-search
{
  "federation": {
    "facetsByIndex": {
      "movies": ["title", "id"],
      "comics": ["title"]
    },
    "mergeFacets": { "maxValuesPerFacet": 10 }
  },
  "queries": [
    { "q": "Batman", "indexUid": "movies" },
    { "q": "Batman", "indexUid": "comics" }
  ]
}
```

The response will include merged facet data:


```json
{
  "facetDistribution": {
    "title": {
      "Batman returns": 1,
      "Batman: the killing joke": 1
    },
    "id": {
      "42": 1
    }
  },
  "facetStats": {
    "id": {
      "min": 42,
      "max": 42
    }
  }
}
```

<Callout>
Learn more about [federated search and its use cases](https://meilisearch.com.cn/blog/what-is-federated-search#release-v1-11&utm_source=blog).
</Callout>

## Experimental: new `STARTS_WITH` filter operator

The new `STARTS_WITH` [filter operator](https://meilisearch.com.cn/docs/learn/filtering_and_sorting/filter_expression_reference#release-v1-11&utm_source=blog#starts-with) matches any field values that start with the specified string pattern:


```json
// returns all heroes whose name starts with 'super'
"filter": "hero STARTS_WITH super"
```

This is an experimental feature. To enable it, use the [experimental features](https://meilisearch.com.cn/docs/reference/api/experimental_features#release-v1-11&utm_source=blog) endpoint and set the `containsFilter` option to `true`. Note that this will also activate the `CONTAINS` filter operator.

<Callout>
Share your feedback via this [GitHub discussion](https://github.com/orgs/meilisearch/discussions/763)
</Callout>

## Contributors shout-out

We want to give a massive thank you to the contributors who made this release possible: [@iornstein](https://github.com/iornstein) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch), and [@luflow](https://github.com/luflow), [@tkhshtsh0917](https://github.com/tkhshtsh0917) for their work on [charabia](https://github.com/meilisearch/charabia).

We also want to extend special thanks to our SDK maintainers working hard to make Meilisearch available across many [languages and frameworks](https://meilisearch.com.cn/docs/learn/what_is_meilisearch/sdks#release-v1-11&utm_source=blog).

* * *

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

Upgrade with ease using Meilisearch Cloud.

[Open Meilisearch Cloud](https://cloud.meilisearch.com/login#release-v1-11&utm_source=blog)

* * *

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter#release-v1-11&utm_source=blog). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/#release-v1-11&utm_source=blog) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions).

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

Meilisearch 1.11

Today we're announcing Meilisearch v1.10. In this article, we’ll review the most impactful changes. For an exhaustive listing, check out the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.10.0) on GitHub.

<Callout>
  Meilisearch 1.10 is available on [Meilisearch Cloud](https://cloud.meilisearch.com/#release-v1-10&utm_source=blog), too—upgrade now!
</Callout>

New: federated search
---------------------

We’re excited to announce that [federated search](/blog/what-is-federated-search/#release-v1-10&utm_source=blog is finally coming to Meilisearch. This feature extends the [multi-search API](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-10&utm_source=blog#perform-a-multi-search) to allow you to merge results from multiple queries into a single, unified response. You can now search different indexes and get the most relevant results across the entire dataset, not only the most relevant for each index.

For SaaS platforms that need to search across various types of resources or ecommerce sites with diverse product categories, federated search is a game-changer.

Here is an example payload for making a [federated search request](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-10&utm_source=blog#federated-multi-search) against the `movies` and `comics` indexes:

```json
{
  "federation": {
    "offset": 5,
    "limit": 10
  },
  "queries": [
    {
      "q": "Batman",
      "indexUid": "movies"
    },
    {
      "q": "Batman",
      "indexUid": "comics"
    }
  ]
}
```

In this example, the [federated search response](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-10&utm_source=blog#response-200-ok-1) will look like this:

```json
{
  "hits": [
    {
      "id": 42,
      "title": "Batman returns",
      "overview": "..",
      "_federation": {
        "indexUid": "movies",
        "queriesPosition": 0
      }
    },
    {
      "comicsId": "batman-killing-joke",
      "description": "..",
      "title": "Batman: the killing joke",
      "_federation": {
        "indexUid": "comics",
        "queriesPosition": 1
      }
    },
 ],
  "processingTimeMs": 0,
  "limit": 2,
  "offset": 0,
  "estimatedTotalHits": 2,
  "semanticHitCount": 0
}
```

### Query weighting

Federated search isn't just about combining results; it's about making those results more meaningful and relevant. Thanks to [query weighting](https://meilisearch.com.cn/docs/reference/api/multi_search#release-v1-10&utm_source=blog#federationoptions), you can prioritize certain queries over others, ensuring that the most important data rises to the top.

The example payload below uses **query weighting** in a federated search to give more importance to documents where the `boosted` field is `true`:

```json
{
  "federation": {},
  "queries": [
    {
      "q": "iphone case",
      "indexUid": "products",
      "filter": "BOOSTED = true",
      "federationOptions": {
        "weight": 3.0
      }
    },
    {
      "q": "iphone case",
      "indexUid": "products"
      // federationOptions.weight defaults to 1
    }
  ]
}
```
<Callout>
  Learn more about [federated search and its use cases](/blog/what-is-federated-search/#release-v1-10&utm_source=blog)
</Callout>

New: language settings for queries and documents
------------------------------------------------

By default, Meilisearch automatically detects the language used in documents and queries. This comes with some limitations for edge cases. Meilisearch 1.10 introduces new language settings that allow users to manually customize their language preferences.

There are two ways to state the language used in a search:

*   Set the language used in a query
*   Set the language used in a document field

### Setting the search query locale

You can define which language is used in a query in the [search parameters](https://meilisearch.com.cn/docs/reference/api/search#release-v1-10&utm_source=blog#query-locales).

**Example payload for searching with query `locales`:**

```json
{
   "q": "進撃の巨人",
   "locales": ["jpn"]
}
```

### Setting the document attributes’ locales

You can define which language is used in your dataset via the [index settings](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-10&utm_source=blog#localized-attributes).

**Example payload for settings with `localizedAttributes`:**

```json
{
  "localizedAttributes": [
    {
      "locales": ["jpn"], 
      "attributePatterns": ["*_japanese"]
    }
  ]
}
```
<Callout>
  Meilisearch support all [ISO-639-2B](https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes) locales.
</Callout>

Self-hosting: Ubuntu v20 is now required
----------------------------------------

If you’re self-hosting Meilisearch, take note: Meilisearch 1.10 now requires **Ubuntu version 20**. This update ensures compatibility with the latest features and maintains optimal performance and security. We advise reading the documentation on [how to upgrade your Ubuntu release](https://documentation.ubuntu.com/server/how-to/software/upgrade-your-release/).

<Callout>
  This change does not affect [Meilisearch Cloud](https://meilisearch.com.cn/cloud#release-v1-10&utm_source=blog) users.
</Callout>

Experimental: AI-powered search DX improvements
-----------------------------------------------

### New: custom headers to REST API-based embedders

Meilisearch 1.10 supports sending custom headers to your API-based embedding service. When using the `rest` source for your [embedder settings](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-10&utm_source=blog#embedders-experimental), Meilisearch now accepts an optional `headers` object. These headers will be added to all requests made to the embedder API.

**Example payload for embedder settings:**

```json
{
  "source": "rest",
  "apiKey": "•••••••••••••••••",
  "headers": {
    "Custom-Header": "value"
  }
}
```

### New: quality of life improvements

Additionally, we added some minor changes to make working with Meilisearch AI-powered search API easier:

*   Embedder settings now accept a `url` parameter for OpenAI embedder to access OpenAI through a proxy
*   Embedder settings now accept a `dimensions` parameter for ollama embedder
*   Meilisearch now includes `_vectors` in the response for documents without vectors (only when `retrieveVectors` is enabled)

### ⚠️ Breaking: REST API-based embedders breaking changes

The API for [configuring an embedder based on a REST API](https://meilisearch.com.cn/docs/learn/experimental/vector_search#release-v1-10&utm_source=blog#generate-vector-embeddings) (e.g., OpenAI, Mistral, etc.) has quickly evolved and to avoid confusion, we have decided to reorganize the parameters in dedicated `request` and `response` fields.

In practice, this change:

*   removes `query` , `inputField`, `inputType`, `pathToEmbeddings` and `embeddingObject` fields
*   adds `request` and `response` fields

Take a look at the example below to learn how to migrate to the new syntax.

**Before** — With Meilisearch 1.9

```json
{
   "source": "rest",
   "url": "https://:10006",
   "query": {
     "model": "minillm",
   },
   "inputField": ["prompt"],
   "inputType": "text",
   "embeddingObject": ["embedding"]
}
```

**After** — Starting with Meilisearch 1.10

```json
{
   "source": "rest",
   "url": "https://:10006",
   "request": {
     "model": "minillm",
     "prompt": "{{text}}"
   },
   "response": {
     "embedding": "{{embedding}}"
   }
}
```

#### Upgrade procedure

This procedure is only necessary if you're using REST API-based embedder. To upgrade to Meilisearch 1.10, follow these steps:

1.  Remove embedders with source `"rest"`
2.  Update your [Meilisearch Cloud project](https://meilisearch.com.cn/docs/learn/update_and_migration/updating#release-v1-10&utm_source=blog#updating-meilisearch-cloud) or [self-hosted Meilisearch instance](https://meilisearch.com.cn/docs/learn/update_and_migration/updating#release-v1-10&utm_source=blog#updating-a-self-hosted-meilisearch-instance) as usual

Experimental: `CONTAINS` filter operator
----------------------------------------

Meilisearch 1.10 introduces the `CONTAINS` operator. This is still in the experimental stage due to some performance issues we’re working to resolve. This new [filter operator](https://meilisearch.com.cn/docs/learn/filtering_and_sorting/filter_expression_reference#release-v1-10&utm_source=blog#contains) allows to check if a substring is included in a larger string.

Given the document `{ id: 1, name: "Keffir" }`, you can use the filter as follows:

*   `name CONTAINS kef` — search will match the document
*   `name CONTAINS clifford` — search will not match the document

<Callout>
  Remember all filters used lowercase, normalized strings (all accents are removed).
</Callout><Callout>
  Share your feedback via this [Github discussion](https://github.com/orgs/meilisearch/discussions/763).
</Callout>

Experimental: update documents with a function
----------------------------------------------

Meilisearch 1.10 allows you to edit documents by executing [a Rhai function](https://rhai.rs/). This allows you to update only a part of your dataset using filters. Additionally, using a function allows you to implement dynamic logic based on your documents’ data.

The following payload updates the title of all documents with `id` above 3000:

```json
{
  "filter": "id > 3000",
  "function": "doc.title = `✨ ${doc.title.to_upper()} ✨`"
}
```

This also enables more complex use cases, like [implementing a decaying ranking strategy](https://felx.me/2021/08/29/improving-the-hacker-news-ranking-algorithm.html). Depending on your needs, you might implement a function such as the following that will be run regularly by a Cron job.

```json
{
  "context": { "now": 1715423249 },
  "function": "
    // `posted_at` and `now` are Unix Epoch timestamps in seconds
    // they must be converted to hours.
    let age_hours = (context.now - doc.posted_at) / 60 / 60;
    doc.ranking_score = doc.upvotes ** 0.8 / (age_hours + 2) ** 1.8;
  "
}
```
<Callout>
  Share your feedback via this [Github discussion](https://github.com/orgs/meilisearch/discussions/762).
</Callout>

* * *

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

Upgrade with ease using Meilisearch Cloud.

[Open Meilisearch Cloud](https://cloud.meilisearch.com/login#release-v1-10&utm_source=blog)

* * *

Contributors shout-out
----------------------

This release wouldn’t be possible without [Meilisearch](https://github.com/meilisearch/meilisearch) and [Charabia](https://github.com/meilisearch/charabia) contributors [@Karribalu](https://github.com/Karribalu), [@hanbings](https://github.com/hanbings), [@junhochoi](https://github.com/hunhochoi), [@JWSong](https://github.com/JWSong), [@PeterDaveHello](https://github.com/PeterDaveHello), [@LukasKalbertodt](https://github.com/LukasKalbertodt), and [@phillitrOSU](https://github.com/phillitrOSU).

We also want to extend special thanks to our SDK maintainers working hard to make Meilisearch available across many [languages and frameworks](https://meilisearch.com.cn/docs/learn/what_is_meilisearch/sdks). We’re excited for [@Sherlouk](https://github.com/Sherlouk) and [@Ja7ad](https://github.com/Ja7ad) to join our open-source maintainers. 💪

* * *

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter#release-v1-10&utm_source=blog). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/#release-v1-10&utm_source=blog) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions).

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

Meilisearch 最新消息和公司动态

Meilisearch 1.16

Meilisearch 1.15

Meilisearch 1.14

Meilisearch AI 发布周回顾

隆重推出 Meilisearch 的下一代索引器：更新速度快 4 倍，存储空间减少 30%

Meilisearch 1.13

Meilisearch 1.12

Meilisearch 2024 年第四季度发布总结

Meilisearch 1.11

Meilisearch 1.10