# Meilisearch AI launch week recap

As the first quarter of 2025 closes, we've completed our first [Meilisearch launch week](https://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/blog/Agora) as shoppers find products using natural language, while [app builders](https://www.meilisearch.com/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://www.meilisearch.com/blog/Agora) and [MotionElements](https://www.meilisearch.com/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://www.meilisearch.com/blog/how-to-build-rag?ref=dailydev) or [image search](https://www.meilisearch.com/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://www.meilisearch.com/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.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

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 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://www.meilisearch.com/docs/learn/filtering_and_sorting/search_with_facet_filters) and [prefix search](https://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/docs/reference/api/batches) to retrieve data about batches. A batch is a set of [tasks](https://www.meilisearch.com/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://www.meilisearch.com/docs/reference/api/batches#get-batches) accepts the same parameters as the [get tasks API](https://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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?utm_campaign=release-v1-12&utm_source=blog), check out the [roadmap](https://roadmap.meilisearch.com/?utm_campaign=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/?utm_campaign=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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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/?utm_campaign=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://www.meilisearch.com/docs/reference/api/settings?utm_campaign=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://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-11&utm_source=blog#search-in-an-index-with-get) and [`POST`](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=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://www.meilisearch.com/docs/reference/api/similar?utm_campaign=release-v1-11&utm_source=blog#get-similar-documents-with-get) and [`POST`](https://www.meilisearch.com/docs/reference/api/similar?utm_campaign=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://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-11&utm_source=blog#vector-experimental) and [`hybrid`](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-11&utm_source=blog#hybrid-search-experimental) parameters but without [`q`](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-11&utm_source=blog#query-q), a [placeholder keyword search](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=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://www.meilisearch.com/docs/reference/api/settings?utm_campaign=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://www.meilisearch.com/docs/reference/api/settings?utm_campaign=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://www.meilisearch.com/docs/reference/api/settings?utm_campaign=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://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-11&utm_source=blog#facetdistribution) and [stats](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=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://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=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://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=release-v1-11&utm_source=blog#facetsbyindex) and [`mergeFacets`](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=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://www.meilisearch.com/blog/what-is-federated-search?utm_campaign=release-v1-11&utm_source=blog).
</Callout>

## Experimental: new `STARTS_WITH` filter operator

The new `STARTS_WITH` [filter operator](https://www.meilisearch.com/docs/learn/filtering_and_sorting/filter_expression_reference?utm_campaign=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://www.meilisearch.com/docs/reference/api/experimental_features?utm_campaign=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://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks?utm_campaign=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?utm_campaign=release-v1-11&utm_source=blog)

* * *

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=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/?utm_campaign=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/?utm_campaign=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/?utm_campaign=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/?utm_campaign=release-v1-10&utm_source=blog is finally coming to Meilisearch. This feature extends the [multi-search API](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=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://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=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://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=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://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=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/?utm_campaign=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://www.meilisearch.com/docs/reference/api/search?utm_campaign=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://www.meilisearch.com/docs/reference/api/settings?utm_campaign=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/cloud?utm_campaign=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://www.meilisearch.com/docs/reference/api/settings?utm_campaign=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://www.meilisearch.com/docs/learn/experimental/vector_search?utm_campaign=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://localhost:10006",
   "query": {
     "model": "minillm",
   },
   "inputField": ["prompt"],
   "inputType": "text",
   "embeddingObject": ["embedding"]
}
```

**After** — Starting with Meilisearch 1.10

```json
{
   "source": "rest",
   "url": "https://localhost: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://www.meilisearch.com/docs/learn/update_and_migration/updating?utm_campaign=release-v1-10&utm_source=blog#updating-meilisearch-cloud) or [self-hosted Meilisearch instance](https://www.meilisearch.com/docs/learn/update_and_migration/updating?utm_campaign=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://www.meilisearch.com/docs/learn/filtering_and_sorting/filter_expression_reference?utm_campaign=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?utm_campaign=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://www.meilisearch.com/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?utm_campaign=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/?utm_campaign=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/?utm_campaign=release-v1-10&utm_source=blog).

Meilisearch 1.10

We're excited to unveil Meilisearch v1.9. 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.9.0) on GitHub.

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

New: ranking score threshold
----------------------------

Meilisearch 1.9 allows excluding search results with low ranking scores. When using the new `rankingScoreThreshold` option, Meilisearch will not return any documents below the defined threshold.

```bash
curl \
 -X POST 'http://localhost:7700/indexes/movies/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{
    "q": "green ogre living in a swamp",
    "hybrid": { 
	    "semanticRatio": 0.9, 
	    "embedder": "default" 
	},
    "showRankingScore": true,
    "limit": 5,
    "rankingScoreThreshold": 0.2
 }'
```

Using the ranking score threshold when implementing [hybrid search](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-9&utm_source=blog#hybrid-search-experimental) removes irrelevant results and allows your [search analytics](https://www.meilisearch.com/docs/learn/analytics/analytics?utm_campaign=release-v1-9&utm_source=blog) to collect the _No search results_ metric properly.

<Callout>
  Excluded results do not count towards `estimatedTotalHits`, `totalHits`, or facet distribution.
</Callout>

New: distinct attribute at search time (group by)
-------------------------------------------------

Meilisearch 1.9 adds the ability to define a [distinct attribute](https://www.meilisearch.com/docs/learn/configuration/distinct?utm_campaign=release-v1-9&utm_source=blog) at search time. Meilisearch will only return one document with the specified attribute value when using the new `distinct` search parameter.

This feature is commonly used in ecommerce applications. Consider a `products` index containing multiple variants of the same product, e.g. `Blue iPhone 15` and `Red iPhone 15` documents that share the same `product_id`. The API call below will return _a single_ iPhone 15:

```bash
curl \
 -X POST 'http://localhost:7700/indexes/products/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{
    "q": "iphone",
    "distinct": "product_id"
 }'
```
<Callout>
  When `distinct` is provided, Meilisearch ignores the index’s [distinct attribute](https://www.meilisearch.com/docs/learn/configuration/distinct?utm_campaign=release-v1-9&utm_source=blog).
</Callout>

New: `frequency` matching strategy
----------------------------------

Meilisearch 1.9 introduces a new [matching strategy](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-9&utm_source=blog#matching-strategy) to prioritize results that contain occurrences of the least frequent query terms. When using the `frequency` matching strategy, Meilisearch will deprioritize very common words.

Let’s take the example of the `"the little prince"` query. In our indexed documents, the words `"the"` and `"little"` likely have a lot of occurrences. Consequently, the matching strategy will prioritize documents containing `"prince"` instead.

Experimental: new similar documents API
---------------------------------------

Meilisearch 1.9 introduces a new [AI-powered search](https://www.meilisearch.com/docs/learn/ai-powered-search/getting_started_with_ai_search?utm_campaign=release-v1-9&utm_source=blog) feature that allows searching for documents similar to an existing document.

The following API call searches for documents similar to the document whose [primary key](https://www.meilisearch.com/docs/learn/core_concepts/primary_key?utm_campaign=release-v1-9&utm_source=blog) is `23` in the movies index:

```bash
curl \
  -X POST /indexes/movies/similar
  -H 'Content-Type: application/json' \
  --data-binary '{
    "id": "23",
    "embedder": "default",
  }'
```

Check out the [similar documents API](https://www.meilisearch.com/docs/reference/api/similar?utm_campaign=release-v1-9&utm_source=blog) for more information about additional parameters.

Experimental: avoid re-generating embeddings
--------------------------------------------

When importing a [dump](https://www.meilisearch.com/docs/learn/advanced/dumps?utm_campaign=release-v1-9&utm_source=blog) created with Meilisearch 1.9 or higher, Meilisearch will not re-generate the embeddings. This will avoid unnecessary computing when upgrading your Meilisearch database.

### New: `regenerate` parameter

Additionally, Meilisearch 1.9 introduces a new API to give more fine-grained control over [document embedding generation](https://www.meilisearch.com/docs/learn/ai-powered-search/getting_started_with_ai_search?utm_campaign=release-v1-9&utm_source=blog#generate-vector-embeddings-with-openai). Specifically, it enables embedding generation whenever a document is updated.

The document `_vectors` object now accepts objects in addition to arrays. The provided object accepts a `regenerate` boolean and an optional `embeddings` array.

Consider the example document below with user-provided embeddings:

```json
{
	"id": 42,
	"_vectors": {
		// Embeddings for the `default` embedder
		// Equivalent to `regenerate: true`
		"default": [0.1, 0.2 ],
		// Embeddings for the `text` embedder
		"text": {
			"embeddings": [[0.1, 0.2, 0.3], [0.4, 0.5, 0.6]],
			// Never regenerate embeddings
			"regenerate": false
		},
		"translation": {
			"embeddings": [0.1, 0.2, 0.3, 0.4],
			// Regenerate embeddings when document is updated
			"regenerate": true
		}
	}
}

```

While, in general, you might want to re-generate your embeddings whenever the document is updated, this facilitates migrating from user-provided embeddings to letting Meilisearch handle embedding without incurring unnecessary costs.

Experimental: hybrid search breaking changes
--------------------------------------------

As we move toward [stabilizing AI-powered search features](https://github.com/meilisearch/meilisearch/issues/4733), we introduced minor breaking changes to make the APIs less error-prone.

### Breaking: empty `embeddings` array

Following user feedback that the previous behavior was unexpected and unhelpful, providing an empty `embeddings` array will now tell Meilisearch that the document has no embeddings.

<Callout>
  Before Meilisearch 1.9, an empty `embeddings` array was interpreted as a single embedding of dimension 0.
</Callout>

### Breaking: removed `_vectors` in search results

Starting with Meilisearch 1.9, API responses to [vector search and hybrid search](https://www.meilisearch.com/docs/learn/ai-powered-search/getting_started_with_ai_search?utm_campaign=release-v1-9&utm_source=blog) requests will not include `_vectors` in the response.

However, you can now use the new `retrieveVectors` search parameter if you want API responses to include them:

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "q": "star wars",
    "retrieveVectors": true
  }'
```

### Breaking: optimizing user-provided `embeddings`

Starting with Meilisearch 1.9, vector embeddings will no longer be stored as-is. Numbers will be cast to floats in canonicalized representation to save storage and optimize performance. Simply put, the vector `[3]` might be stored as `[3.0]`.

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

Thanks to all community members who participated in this release. Shout out to [@gh2k](https://github.com/gh2k), [@writegr](https://github.com/writegr), and [@yudrywet](https://github.com/yudrywet) for their contributions to [Meilisearch](https://github.com/meilisearch/meilisearch) and [@mosuka](https://github.com/mosuka), [@Soham1803](https://github.com/Soham1803), and [@tkhshtsh0917](https://github.com/tkhshtsh0917) for their contributions to [Charabia](https://github.com/meilisearch/charabia).

And, of course, many thanks to our SDK maintainers, thanks to whom Meilisearch is available across many languages. Special thanks to [@the-sinner](https://github.com/the-sinner) and [@norkunas](https://github.com/norkunas). 🫶

* * *

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

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=release-v1-9&utm_source=blog). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=release-v1-0&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/?utm_campaign=release-v1-9&utm_source=blog).

Meilisearch 1.9

On June 11, 2024, Meilisearch hosted a live event packed with product updates, sneak peeks, and roadmap discussions. If you couldn't make it, here's a quick recap of what went down.

**AI-powered search refresher and new embedders**
-------------------------------------------------

Our product team took the stage to share insights into developing our AI-powered search solution and outlined our vision for providing ready-to-use components for seamless AI-powered search integration. By adding semantic and AI capabilities to Meilisearch's core keyword and full-text product, we introduced a [hybrid search solution](https://www.meilisearch.com/solutions/hybrid-search) in early 2024.

To streamline the developer experience, we have since added [Ollama and REST embedders](/blog/meilisearch-1-8/ for easier integration within the v1.8 scope.

![](https://lh7-us.googleusercontent.com/docsz/AD_4nXd_QlnM1707ZYLjpOrhzxjZrWDxgdVo3TL5Dewz6dM1ZIbhZp4CcPUJdtDhV4xAA_ZZACDSv8h9JF_d2AoFSNGYNlShW_JOI_s1TrqbEtntN-7pvxW8UnTTdVMNml9oBroLhZfrVprM5dQmM0HiTP55MZPw?key=pr3OBspkNUkqXQYoKJ84OA)

You are welcome to try out the hybrid search feature using our [movie demo database](https://where2watch.meilisearch.com/). 

**New relevancy improvements and smarter search**
-------------------------------------------------

We also introduced several new features designed to _improve search relevancy_ in v1.9:

*   **Negative keyword search**: exclude unwanted results easily.
*   **New frequency matching strategy**: enhance search accuracy by removing the most common term found in the dataset.
*   **Filter by score**: set a baseline _rankingScore_ to return only results considered "good enough" in terms of relevancy.
*   **Get similar documents:** utilize AI to find similar documents within your dataset.

This new feature set is slated for launch on July 1st.

**Query suggestions sneak peek**
--------------------------------

Attendees also got a sneak peek into an upcoming release. The new _query suggestions_ feature aims to enhance search efficiency by returning real-time, relevant suggestions as users type, ordered by popularity. This feature leverages [cloud search analytics](/blog/search-analytics-release/ to generate and rank suggestions based on popularity and relevance. Designed for seamless integration, it requires no new endpoints or tools and is expected to be released in Q3. Ongoing improvements will be based on user feedback.

**Check out the recording of the event for more details:**
----------------------------------------------------------

* * *

Get these monthly updates straight to your inbox by subscribing to our [newsletter](https://dub.sh/meili-newsletter).

For more things Meilisearch, join our developers' community on [Discord](https://discord.meilisearch.com/?ref=blog.meilisearch.com). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in [product discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).

Until next time!

Here's what you missed in the latest Meilisearch live event: V1.8, V1.9, new embedders, query suggestions, and more.

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

New: negative search
--------------------

Meilisearch 1.8 allows you to exclude specific terms from your search results using the `-` operator. 

For example, to find documents that contain the word "room" but not "escape", place a `-` before "escape”:

```Bash
curl \
  -X POST 'https://edge.meilisearch.com/indexes/places/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "-escape room" }'

```

Experimental: Improved hybrid search
------------------------------------

<Callout>
  AI search is an experimental feature. Give feedback in this [GitHub discussion](https://github.com/orgs/meilisearch/discussions/677).
</Callout>

### New Ollama embedder

Meilisearch 1.8 introduces support for Ollama models. [Configure the embedder](https://www.meilisearch.com/docs/learn/experimental/vector_search?utm_campaign=release-v1-8&utm_source=blog#generate-vector-embeddings) in your index settings:

```JSON
"default": {
  "source": "ollama", // 👈 Use the ollama source
  "url": "http://localhost:11434/api/embeddings",
  // ☝️ optional, fetched from MEILI_OLLAMA_URL environment variable if missing
  "apiKey": "<your-api-key>",
  // ☝️ optional
  "model": "nomic-embed-text",
  "documentTemplate": "{{doc.field_name}}" // like for openAI and huggingFace sources
}

```

### New REST Embedder

Starting with Meilisearch 1.8, you can use any embedder accessible via a REST API. Here’s how to configure an OpenAI embedder with the `rest` source:

```JSON
{
  "source": "rest",
  "apiKey": "<your-openai-api-key>",
  "dimensions": 1536,
  "url": "https://api.openai.com/v1/embeddings",
  "query": {
    "model": "text-embedding-ada-002"
  },
  "inputField": ["input"],
  "inputType": "textArray",
  "pathToEmbeddings": ["data"],
  "embeddingObject": ["embedding"]
}

```

For more details on the API and available parameters, please consult the documentation on [REST embedders](https://www.meilisearch.com/docs/learn/experimental/vector_search#generate-auto-embeddings?utm_campaign=release-v1-8&utm_source=blog).

### New embedder setting: distribution shift

<Callout>
  This is an advanced API for custom models. OpenAI and Hugging Face models don't require this setting.
</Callout>

Depending on the embedding model, [vector embeddings](/blog/what-are-vector-embeddings/?utm_campaign=release-v1-8&utm_source=blog) are not always uniformly distributed within the [vector space](/blog/what-are-vector-embeddings/?utm_campaign=release-v1-8&utm_source=blog) When vectors are overly clustered, semantic search scores can be very closely ranked. As a result of semantic scores being packed, hybrid results might have sub-optimal relevancy.

To address this issue, you can now shift the distribution of results with an affine transformation. This transformation normalizes semantic scores to prevent them from clustering too high or too tightly, making them more comparable to the [keyword scores](https://www.meilisearch.com/docs/reference/api/search#ranking-score).

```JSON
"default": {
  "source": "huggingFace",
  "model": "MODEL_NAME",
  "distribution": {  // describes the natural distribution of results
    "mean": 0.7, // mean value
    "sigma": 0.3 // standard deviation
  }
}

```

*   The **mean** value represents the central point around which you observe semantic search scores to be densely packed. In the provided code sample, the setting indicates that semantic scores from this model tend to cluster around a mean of 0.7.
*   The **sigma** value determines the spread of ranking scores from the mean (standard deviation). The sigma provided in the code sample above means that before shifting the distribution, the results tend to have an average distance of 0.3 to the mean.

This allows for a more effective comparison of `_rankingScore` between semantic and keyword search results, leading to improved results ranking.

### Breaking: trimmed API response

To speed up the search response and reduce bandwidth usage, Meilisearch v1.8 no longer returns the following fields in the search responses:

*   the `vector` field, which returned the query vector 
*   the `value` field included in the [`vectorSort`](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-8&utm_source=blog#vectorsorttarget_vector) object, which is returned when you add \`”showRankingScoreDetails”: true”\` to a search query
*   the `_semanticScore` field; its value is the same as `_rankingScore`, which you should use instead. Set [`”showRankingScore”: true”`](https://www.meilisearch.com/docs/reference/api/search?utm_source=blog&utm_campaign=release-v1-8#ranking-score) in the search parameters

Search robustness improvements
------------------------------

### New search cut-off setting

To enhance stability and performance, Meilisearch automatically terminates any search request that exceeds 1500 milliseconds. 

To adjust this timeout threshold, you can customize the `searchCutoffMs` setting:

```bash
curl \
  -X PATCH 'https://edge.meilisearch.com/indexes/movies/settings' \
  -H 'Content-Type: application/json' \
  --data-binary '{
    "searchCutoffMs": 150
  }'

```

### Experimental: concurrent search requests limit

This release introduces a limit on concurrent search requests to prevent Meilisearch from using excessive amounts of RAM and crashing. The default queue limit is set to 1000 requests. 

To modify this limit, restart your self-hosted instance with the `--experimental-search-queue-size` option:

```bash
./meilisearch --experimental-search-queue-size 100
```

👉 This limit does not impact the search performance. It only controls the number of search requests that can be queued simultaneously to enhance system security.

<Callout>
  Give feedback regarding concurrent search requests limit in this [GitHub discussion](https://github.com/orgs/meilisearch/discussions/729).
</Callout>

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

We are really grateful for all the community members who participated in this release. We would like to thank: [@availhang](https://github.com/availhang), [@hack3ric](https://github.com/hack3ric), [@jakobklemm](https://github.com/jakobklemm), [@mohsen-alizadeh](https://github.com/mohsen-alizadeh), [@redistay](https://github.com/redistay), [@rohankmr414](https://github.com/rohankmr414), [@shuangcui](https://github.com/shuangcui), [@Toromyx](https://github.com/Toromyx), [@6543](https://github.com/6543) for their help with Meilisearch, and [@Gusted](https://github.com/Gusted), [@mosuka](https://github.com/mosuka), [@6543](https://github.com/6543), for their work on [Charabia](https://github.com/meilisearch/charabia).

Special thanks to our SDKs maintainers, thanks to whom Meilisearch is available across so many languages. 🫶

* * *

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

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

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

Meilisearch latest news and company updates