We are thrilled to announce that the first major release of Meilisearch is here! It's the result of the combined efforts of many people. We are proud to release a completely stable version of Meilisearch, which will guarantee compatibility with future versions of Meilisearch. We are very grateful to our community, which has supported us and helped us to get this far.

Let's take a look at some of the most significant changes. You can read the [full changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.0.0) on GitHub, but we’ll go over the main ones in this article.

New feature: Korean support
---------------------------

Meilisearch is multilingual and features optimized support for several languages. Thanks to our amazing contributor [qbx2](https://github.com/qbx2), we now support Korean as well.

Improvement: language support
-----------------------------

Thanks to the engagement, feedback, suggestions, and PRs of our global community, we improved language support all around with notable enhancements for Chinese:

*   Transliteration of Chinese characters into [Pinyin](https://en.wikipedia.org/wiki/Pinyin) to improve relevancy
*   Updates to [our Chinese segmenter](https://crates.io/crates/jieba-rs) to remove [inconsistencies](https://github.com/meilisearch/charabia/issues/136) when splitting text into words
*   Unification of [Chinese character variants](https://www.unicode.org/reports/tr38/#N10211) to enhance Chinese normalization

We are always looking to improve, join the [discussion](https://github.com/meilisearch/product/discussions/503) about Chinese support on GitHub!

We have also implemented a new, more efficient [normalizer](https://github.com/meilisearch/charabia/blob/main/CONTRIBUTING.md#implement-a-normalizer) to remove [accents and other non-spacing marks](https://www.compart.com/en/unicode/category/Mn), which refines the support of Hebrew, Thai, Arabic, and Latin languages.

Improvement: one-step upgrade
-----------------------------

Users of Meilisearch v0.20 or below had to perform a two-step migration to be able to use their database with any version above 0.24. Until now.

v1.0 is compatible with dumps from all previous versions.

We have simplified the process so that anyone can smoothly migrate to our first major version! Check the [updating guide](https://www.meilisearch.com/docs/learn/update_and_migration/updating) in our documentation.

Improvement: indexing and search speed
--------------------------------------

*   We have reduced memory usage of search requests containing multiple long words.
*   We have also reduced the computational complexity of the exactness ranking rule and have implemented a caching system, resulting in a significant improvement in its performance, especially for search queries containing many words.
*   When interpreting a search query, multi-word synonyms are no longer treated as regular search query terms, but as phrases. Suppose you set San Francisco and SF as synonyms. The following search request:  
    `I am going to SF soon`  
    will now be interpreted as:  
    `I am going to "San Francisco" soon`  
    This change prevents requests containing multi-word synonyms from exceeding the word length limit and degrading the search performance. At the same time, it removes a source of denial-of-service attacks, and improves the relevancy of the search results.
*   We have tweaked the behavior of the proximity rule for search requests ending with prefixes or very short words to achieve substantial speed improvements.
*   Before v1.0, if the settings object contained searchable attributes, updating the settings always triggered a reindex. Now, Meilisearch checks if any changes were made to avoid unnecessary reindexing. Many thanks to [GregoryConrad](https://github.com/GregoryConrad) for implementing this!

Breaking changes
----------------

You will be happy to learn that the following are the last breaking changes we are going to introduce until v2.0 🥳 You can relax for a while, v2.0 is not yet planned ☺️

Check our [new versioning policy](https://github.com/meilisearch/engine-team/blob/main/resources/versioning-policy.md) to learn more about breaking changes.

### New master key security requirement

‌‌To strengthen security, Meilisearch now requires master keys to be at least 16 bytes when the [server environment](https://docs.meilisearch.com/learn/configuration/instance_options.html#environment) is set to `production`. If none is provided or if it doesn’t meet the criteria, Meilisearch will suggest a secure autogenerated master key you can use when restarting your instance.

### Primary key inference revamp

When creating an index or adding documents to Meilisearch, you can set the primary key explicitly or let Meilisearch infer it from your dataset.

To guess the primary key, also known as inference, Meilisearch used to look in your first document for an attribute **containing** the string `id`. Now, it looks for an attribute **ending** with the string `id`.

Furthermore, if multiple attributes ending with `id` are detected, Meilisearch will now throw an error asking you to specify the primary key manually using the [update index endpoint](https://docs.meilisearch.com/reference/api/indexes.html#update-an-index).

### New CLI behavior

`--max-index-size` and `--max-task-db` have been removed as they were not actually limiting the disk space taken by Meilisearch. This change has two consequences:

1.  Due to operating system limits on the amount of virtual memory allocatable by a single process, the number of indexes that can exist simultaneously in a Meilisearch database are:

*   around 200 for Linux/MacOS
*   around 20 for Windows

2\.  The size of an index is limited to 500GiB

While we plan on lifting the limitations described above in v1.1, if any of these changes affect you, it would be of great help to have [your input](https://github.com/meilisearch/product/discussions/567#discussioncomment-4634432). You can find more details in this [GitHub discussion](https://github.com/meilisearch/product/discussions/567).

Since its introduction in v0.26, the auto-batching feature has proven its worth. The `disable-auto-batching` CLI option and the associated environment variable `MEILI_DISABLE_AUTO_BATCHING`, which had been kept for debugging purposes, are no longer needed and have been removed.

‌‌We’re also removing the `--snapshot-interval-sec` flag to make scheduling snapshots simpler.

Before:‌‌

```bash
meilisearch --schedule-snapshot --snapshot-interval-sec 3600
```

After:

```bash
meilisearch --schedule-snapshot 3600
# If no value is provided, Meilisearch will take a new snapshot every 24 hours.
```

‌‌‌‌Finally, for the sake of consistency, the `--dumps-dir` CLI option has been renamed to `--dump-dir`, which is more idiomatic and in conformity with other existing options.

### Error handling improvements

To provide greater clarity and predictability in the use of the API, we have added granular error codes and a new `system` error type. You can consult the detailed list in the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.0.0).

Contributors
------------

A big thank you to all our contributors! We couldn't have reached this milestone without your support. You're really, truly great and we can't thank you enough for all the effort, suggestions, comments, and time you dedicate to Meilisearch. We are so grateful to have such an amazing community.

This month, we want to send a special shout-out to [@amab8901](https://github.com/amab8901), [@colbsmcdolbs](https://github.com/colbsmcdolbs), [@elbertronnie](https://github.com/elbertronnie), [@funilrys](https://github.com/funilrys), [@jiangbo212](https://github.com/jiangbo212), [@mohitsaxenaknoldus](https://github.com/mohitsaxenaknoldus), and [@shivaylamba](https://github.com/shivaylamba) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch), and to [@amab8901](https://github.com/amab8901), [@GregoryConrad](https://github.com/GregoryConrad), and [@pnhatminh](https://github.com/pnhatminh) for their contributions to [Milli](https://github.com/meilisearch/milli). Likewise, we would like to thank [@choznerol](https://github.com/choznerol), [@crudiedo](https://github.com/crudiedo), [@daniel-shuy](https://github.com/daniel-shuy), [@harshalkhachane](https://github.com/harshalkhachane), [@mosuka](https://github.com/mosuka), [@qbx2](https://github.com/qbx2), [@Roms1383](https://github.com/Roms1383), [@Sokom141](https://github.com/Sokom141), and [@yenwel](https://github.com/yenwel) for their precious support on [Charabia](https://github.com/meilisearch/charabia).

What’s new in v1.0

In this article, let's take a look at some of the most significant changes in Meilisearch's latest update. You can read [the full changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.30.0), but we’ll go over the main ones in this article.

Zero downtime index deployment
------------------------------

Syncing your database changes with your Meilisearch index results in downtime. You cannot afford a “broken” search: user experience is paramount. You’ve come up with some workaround, but it takes time and resources. There must be a simpler way to handle this, right?

v0.30 introduces index swapping. You can now deploy a new index version with zero downtime!

To synchronize the changes between your primary database and your Meilisearch index  —`indexA`— in production, you just need to take the following steps:

* Step 1: Create a new version of the index —`indexA_new`— containing all those changes
* Step 2: Swap indexes, which means you replace the documents, settings, and task history of `indexA` with those of `indexA_new`. This is the request you need to send for the magic to happen:

```bash
curl \
 -X POST 'http://localhost:7700/swap-indexes'\
 -H 'Content-Type: application/json' \
 --data-binary '[
 { "indexes": ["indexA", "indexA_new"] }
 ]'
```

⏲️ Wait for the task’ status to update to `succeeded`...

🎉 Tada! Your changes are now in production! Your users are still searching in `indexA`, but it holds the data of `indexA_new` now, and `indexA_new` holds the data of `indexA`.

New features: task cancelation and deletion
-------------------------------------------

v0.30 gives you more control over asynchronous operations: you can now cancel tasks and delete your task history.

### Task cancelation

The inability to cancel tasks has been one of the recurring problems users have raised over time. Not being able to interrupt tasks enqueued by mistake or taking too long to process can be very frustrating.

With v0.30, this problem is now a thing of the past. With the new API route `/tasks/cancel`, you can cancel enqueued or processing tasks based on their:

* `uid`
* `status`
* `type`
* `indexUid`
* the date they were enqueued or started (`beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`)

You can learn more about tasks in our [documentation](https://docs.meilisearch.com/learn/advanced/asynchronous_operations.html#understanding-tasks).

To cancel all enqueued tasks that add or update documents to an index, you should send the following request:

```bash
curl \
 -X POST 'http://localhost:7700/tasks/cancel?statuses=enqueued&types=documentAdditionOrUpdate’

```

### Task deletion

Succeeded or failed —and now canceled— task information can take up much-needed disk space in instances with a large number of asynchronous operations. Clean up finished tasks with the new `DELETE /tasks` endpoint.

Just as for task cancelation, task deletion can be done based on the tasks’:

* `uid`
* `status`
* `type`
* `indexUid`
* the date they were enqueued or started (`beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`)

But you can also delete them based on the date they finished processing and what task canceled them:

* `beforeFinishedAt`
* `afterFinishedAt`
* `canceledBy`

The following request deletes all tasks processed before October 11, 2020, at 11:49:53 am.

```bash
curl \
 -X DELETE 'http://localhost:7700/tasks?beforeFinishedAt=2020-10-11T11:49:53.000Z'

```

New feature: configuration file support
---------------------------------------

Thanks to our dear contributor [mlemesle](https://github.com/mlemesle/), a new way of configuring your Meilisearch instance has entered the chat. Along with environment variables and CLI options, you can use a configuration file 🥳

Configuration files can be easily shared and versioned. They allow you to manage all configuration options in one place and give an overall view at a glance.

To do so, set the desired instance options in a single  `.toml`  file:

```toml
env = "production"
master_key = "YOUR_MASTER_KEY_VALUE"

```

You can use the `--config-file-path` CLI option or the `MEILI_CONFIG_FILE_PATH` environment variable to specify a configuration file. Otherwise, Meilisearch will use the file `./config.toml` in the working directory as the default configuration file. You can download a default configuration file with the following command:

```json
curl https://raw.githubusercontent.com/meilisearch/meilisearch/main/config.toml > config.toml
```
<Callout>
 Please note that specifying the `config-file-path` key in the configuration file will throw an error.
</Callout>

If no configuration file is provided, the `Config file path` is set to `none`.

Improvement: search result pagination
-------------------------------------

v0.30 introduces a numbered pagination mode for users who need pagination interfaces.

Up to v0.29, when using the search endpoint, Meilisearch only returned `estimatedTotalHits`, an estimate of how many documents matched the query. For this reason, creating interfaces with a page selector was not recommended.

You can now use the new search parameters `page` or `hitsPerPage` to get the exhaustive number of hits and the total number of pages for a query.

```bash
curl \
 -X POST 'http://localhost:7700/indexes/movies/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{ "q": "american ninja", "page": 1 }'

```

The above request will fetch the first page of results for the given query and will return the following response:

```JSON
{
 "hits": [
 // … 20 hits
 ],
 "query": "american ninja",
 "processingTimeMs": 2,
 "hitsPerPage": 20,
 "page": 1,
 "totalPages": 49,
 "totalHits": 966
}

```

As you can see, it returns the exhaustive number of search results (`totalHits`) and the number of search results pages (`totalPages`), which allows you to create numbered pagination interfaces easily.

 
👉 Note that `totalHits` and `totalPages` are calculated based on the [pagination.maxTotalHits index setting](https://www.meilisearch.com/docs/reference/api/settings#pagination).

Breaking changes
----------------

### Field rename

When [deleting documents by batch](https://docs.meilisearch.com/reference/api/documents.html#delete-documents-by-batch), the corresponding task object contains a field with the number of document ids received. This field, previously called `receivedDocumentIds`, has been renamed to `providedIds`.

### New error

In cases where users try accessing the `/keys` route without setting a master key, Meilisearch now throws a more helpful error  `missing_master_key`:

```JSON
{
 "message": "Meilisearch is running without a master key. To access this API endpoint, you must have set a master key at launch.",
 "code": "missing_master_key",
 "type": "auth",
 "link": "https://docs.meilisearch.com/errors#missing_master_key"
}
```

### Task filter and error naming

To keep naming consistent with the value they can have, we have pluralized the query parameters used to filter tasks:

* `indexUid` becomes `indexUids`
* `type` becomes  `types`
* `status` becomes  `statuses`

We have also renamed the following error codes:

* `invalid_task_type` to `invalid_task_types_filter`
* `invalid_task_status` to `invalid_task_statuses_filter`

Hacktoberfest contributions
---------------------------

We are infinitely grateful for all the contributions we received during Hacktoberfest. Most of the changes mentioned above were from these contributions, and we would like to highlight two more. We would not have released them in this version if it were not for our contributors.

* Support for compressed API requests (Gzip, Brotli, Zlib) by [@mou](https://github.com/mou)
* Apple Silicon binaries are available thanks to [@jeertmans](https://github.com/jeertmans)

Other changes
-------------

* Meilisearch has been binding by default to `127.0.0.1:7700` , which is an IPv4 address. In order to make Meilisearch reachable through both [IPv4](https://en.wikipedia.org/wiki/IPv4) (`127.0.0.1:7700`) and [IPv6](https://en.wikipedia.org/wiki/IPv6) (`[::1]:7700`) addresses, we have changed the default address to `localhost:7700`.
* All task objects now contain the `canceledBy` and `error` fields
* New [task filters](https://docs.meilisearch.com/learn/advanced/asynchronous_operations.html#filtering-tasks) are available for the `GET /tasks` endpoint:
 * `uids`
 * `beforeEnqueuedAt` / `afterEnqueuedAt`
 * `beforeStartedAt` / `afterStartedAt`
 * `beforeFinishedAt` / `afterFinishedAt`
 * `canceledBy`
* We have introduced a new task type: `snapshotCreation`. Snapshots tasks are now visible in [the task list](https://docs.meilisearch.com/reference/api/tasks.html#get-tasks)
* The indexing speed has been significantly increased
* We have reduced both the size of the Meilisearch binary and the size the Meilisearch instance takes up in disk space
* All instance options now have their corresponding environment variable. Some related to the snapshot and dump features were missing

A big thank you to all our contributors! This project wouldn't have gotten very far without your help 🙏

And that’s it for v0.30! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.30.0) for the full release notes.

What's new in v0.30

This article looks at some of the main changes in Meilisearch’s latest release. For more details, [read the full changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.29.0).

New feature: matching strategy
------------------------------

v0.29 introduces a new search parameter: `matchingStrategy`. This parameter lets you define, at search time, how Meilisearch should match query terms:

* `last`: returns documents that contain all query terms first. Additional results are then retrieved by decreasing number of query terms present in a match: Meilisearch will remove one query term at a time, starting from the end of the query, and include any new matches to the list of results. This has been the behavior since v0.21 and will remain the default strategy.
* `all`: only returns documents containing all query terms.

Example:

```bash
curl \\
 -X POST '<http://localhost:7700/indexes/movies/search>' \\
 -H 'Content-Type: application/json' \\
 --data-binary '{ "q": "american ninja", "matchingStrategy": "all" }'

```

With the above request, Meilisearch will only return documents containing both "american" AND "ninja".

We hope this new feature will encourage those still working with v0.20—the last official Meilisearch release using an `all` matching strategy by default—to update to our latest release and benefit from the new features introduced since then: [sorting](https://docs.meilisearch.com/learn/advanced/sorting.html#sorting), [geosearch](https://docs.meilisearch.com/learn/advanced/geosearch.html#geosearch), [granular API key rights](https://docs.meilisearch.com/reference/api/keys.html) and many more! If you’re still on v0.20 and don’t think you will upgrade just yet, we’d be [happy to know](https://docs.meilisearch.com/learn/what_is_meilisearch/contact.html#contact-us) what’s refraining you.

You can test this feature with the [matching strategy demo](https://matching-strategy.meilisearch.com/), and learn more about it in the [dedicated blog post](/blog/matching-strategy/)mprovement: indexing performance
---------------------------------

We have sped up indexing, especially for the following operations:

* Facet indexing: we have modified the algorithm to increase the indexing speed of filterable attributes
* Document deletion and update:
* We have introduced **soft deletion.** This is a technique in which a flag is used to mark data as deleted, rendering it inaccessible to all users without actually removing it from the database. Documents are deleted at a later date, before they take up too much space on the device. Thus, the time taken to delete records on disk is postponed and doesn’t delay the indexing process.
* when reindexing, Meilisearch now detects if the exact same version of the document already exists and, if that is the case, does not index it again

### Behavior change: auto-batching

In v0.26, we introduced an experimental feature: auto-batching. When activated, auto-batching automatically combines consecutive document addition requests, significantly speeding up the indexing process.

We are happy to announce auto-batching is now the default indexing behavior and no longer experimental  🥳

This means you don’t need to use the `**--enable-auto-batching**` CLI flag to enable it anymore. Using `--enable-auto-batching` will now throw the following error:

```bash
error: Found argument '--enable-auto-batching' which wasn't expected, or isn't valid in this context

	Did you mean '--disable-auto-batching'?

	If you tried to supply `--enable-auto-batching` as a value rather than a flag, use `-- --enable-auto-batching`

USAGE:
 meilisearch --disable-auto-batching

```

The following auto-batching customization options have also been removed and will throw errors if used, so make sure your application is not using any of them before upgrading to v0.29:

* `--debounce-duration-sec`
* `--max-batch-size`
* `--max-documents-per-batch`

If you hadn't activated the auto-batching feature, you have nothing to do but enjoy the increased indexing speed 🏎️

🧐 You may have noticed it in the error message above: if for some reason you do not want Meilisearch to automatically batch requests, a new CLI flag is available to deactivate this feature: `--disable-auto-batching`.

<Callout>
 We are continuously working on improving our search engine, and your feedback is essential. If you experience any issues with document indexing speed, we would be very grateful if you could let us know in this [discussion](https://github.com/meilisearch/meilisearch/discussions/2131).
</Callout>

Improvement: filters
--------------------

We have added two new filter operators: `IN` and `EXISTS`

* The `IN` operator selects all documents whose specified field contains at least one of the given values
* The `EXISTS` operator checks for the existence of a field. Beware that fields with empty or null values still count as existing

Given the following book dataset:

```json
[
 { "id": 1, "title": "Pride and Prejudice", "genres": ["romance"] },
 { "id": 2, "title": "Le Petit Prince", "genres": [] },
 { "id": 3, "title": "Alice In Wonderland" },
 { "id": 4, "title": "The Hobbit", "genres": ["adventure", "fantasy"] },
 { "id": 5, "title": "A Game of Thrones", "genres": ["fantasy"] },
]

```

The expression `genres IN [fantasy, adventure]` will return documents `4` and `5`.

The expression `genres EXISTS` will return documents `1`, `2`, `4`, and `5`.

Both operators can be combined with the  `NOT` (`!=`) operator.

### Behavior change: **`!=` (`NOT`) filter operator**

The `!=` (`NOT`) filter operator returns documents that do not satisfy a condition.

Considering the following documents:

```jsx
{ "id": 1, "product": "T-shirt", "price": 20 }
{ "id": 2, "product": "T-shirt" }
{ "id": 3, "product": "T-shirt", "price": 30 }

```

`NOT price = 20` should return all documents whose price attribute is not equal to 20.

With v0.29, the `!=` (`NOT`) filter matches documents missing the specified attributes. In the above example, this means Meilisearch returns documents `2` and `3`.

Before v0.29, Meilisearch did not include results missing the `price` attribute. In the above example, v0.28 would have returned only document `3`.

You can make sure a filter only returns documents containing the specified attribute by using the `!=` (`NOT`) operator with the new  `EXISTS` operator: `price EXISTS AND price != 20` will only return document `3`.

Improvement: key management
---------------------------

When managing [keys](https://docs.meilisearch.com/learn/security/master_api_keys.html#protecting-a-meilisearch-instance), using the `*` wildcard character in the `actions` array gives access to all endpoints:

```json
{
 "name": "Default Admin API Key",
 "description": "Use it for anything that is not a search operation. Caution! Do not expose it on a public frontend",
 "key": "380689dd379232519a54d15935750cc7625620a2ea2fc06907cb40ba5b421b6f",
 "uid": "20f7e4c4-612c-4dd1-b783-7934cc038213",
 "actions": ["*"],
 "indexes": ["*"],
 "expiresAt": null,
 "createdAt": "2021-08-11T10:00:00Z",
 "updatedAt": "2021-08-11T10:00:00Z"
 }

```

Now, thanks to our contributors, it can also be used as a wildcard to express all endpoints for a single particular route 🙌

Instead of having to list each and every single endpoint, you can append the `*` character to the desired route. For example, `documents.*` authorizes access to all document-related endpoints.

Improvement: Thai support
-------------------------

Our dear contributor [@aFluffyHotdog](https://github.com/aFluffyHotdog) has introduced [optimized support](https://docs.meilisearch.com/learn/what_is_meilisearch/language.html#what-do-you-mean-when-you-say-meilisearch-offers-optimized-support-for-a-language) for Thai 🥳

We are always looking for ways to make Meilisearch’s language support even better. The more [feedback](https://github.com/meilisearch/product/discussions?discussions_q=label%3Aproduct%3Acore%3Atokenizer) we get from native speakers, the easier it is for us to understand how to improve performance and search relevancy for those languages.

Want to help us [support your language](https://docs.meilisearch.com/learn/what_is_meilisearch/language.html#improving-our-language-support)? [Contribute](https://github.com/meilisearch/charabia/blob/main/CONTRIBUTING.md)! Don’t hesitate to [reach out](https://discord.gg/meilisearch) if you need guidance or help; we are looking forward to working with you!

Contributors
------------

Meilisearch could not exist as it does today without the support from our community. You're really, truly great and we can't thank you enough for all the effort, suggestions, comments, and time you dedicate to Meilisearch. This month, we want to send a special thank you to [@evpeople](https://github.com/evpeople), [@Mcdostone](https://github.com/Mcdostone), [@pavo-tusker](https://github.com/pavo-tusker), [@phdavis1027](https://github.com/phdavis1027), [@ryanrussell](https://github.com/ryanrussell), and [@VasiliySoldatkin](https://github.com/VasiliySoldatkin) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch), [@GraDKh](https://github.com/GraDKh) for his help with [Milli](https://github.com/meilisearch/milli), and [@aFluffyHotdog](https://github.com/aFluffyHotdog), [@matthias-wright](https://github.com/matthias-wright), and [@mosuka](https://github.com/mosuka) for their help with our tokenizer [Charabia](https://github.com/meilisearch/charabia).

And that's all, folks! Remember to check out the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.29.0) for the full release notes, and see you next time!

What’s new in v0.29

In this article, let's take a look at some of the most significant changes in Meilisearch's latest update. This release brings you new features such as smart crop and deterministic API keys. With v0.28, we have stabilized our API, taking the first step towards a v1.0 🎉 This stabilization brings multiple changes. You can read [the full changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.28.0), but we’ll go over the main ones in this article.

**New feature: smart crop**
---------------------------

Instead of considering the first search term match as the best cropping location, Meilisearch centers the crop around the largest number of unique matches, giving priority to terms that are closer to each other and follow the original query order.  Meilisearch also considers context when cropping and prioritizes keeping the sentence together.

Given the following string:

<Callout>
 “A young elephant, whose oversized ears enable him to fly, helps save a struggling circus, but when the circus plans a new venture, Dumbo and his friends discover dark secrets beneath its shiny veneer.”‌
</Callout>

If the search query is `Dumbo` and the `cropLength` is `5`, Meilisearch will now return:

`"… Dumbo and his friends discover…”`

Instead of:

`"…new venture, Dumbo and his…”`

**New feature: deterministic API keys**
---------------------------------------

A **deterministic algorithm** is an algorithm that, given a particular input, always produces the same output, with no randomness involved.

You can create a deterministic `key` value by specifying a `uid` field at creation. The `uid` value must follow the [uuid v4](https://www.sohamkamani.com/uuid-versions-explained) format. If you don't specify anything, Meilisearch automatically generates the `uid` for you.

The value of the `key` field is generated by hashing the master key with the `uid`. The same combination always results in the same `key` value.

This will allow you to have the same set of API keys across different Meilisearch instances. Henceforth, when upgrading or redeploying your Meilisearch instance, you’ll be able to keep your API keys.

<Callout>
 As a result of these modifications, keys imported from older versions of Meilisearch will have their `key` and `uid` fields regenerated. When updating your Meilisearch instance, **you will need to update your keys**.
</Callout>

We have also added a `name` field to make API key retrieval more convenient. A key object should now look like this:

```JSON
{
 "name": null,
 "description": "Manage documents: Products/Reviews API key",
 "key": "d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4",
 "uid": "6062abda-a5aa-4414-ac91-ecd7944c0f8d",
 "actions": [
 "documents.add",
 "documents.delete"
 ],
 "indexes": [
 "products",
 "reviews"
 ],
 "expiresAt": "2021-12-31T23:59:59Z",
 "createdAt": "2021-10-12T00:00:00Z",
 "updatedAt": "2021-10-13T15:00:00Z"
}
```

‌Other changes regarding API key management include:

* being able to retrieve, update, and delete a key by either the `key` or `uid` fields
* introducing new actions to manage API keys (`keys.get`, `keys.create`, `keys.update`, `keys.delete`)
* removing the possibility of updating the `actions`, `indexes`, or `expiresAt` properties of an API key after creation for security reasons

**Breaking change: search nomenclature**
----------------------------------------

We’re on the road to v1, which means defining a stable API. To improve clarity, we have made several changes to the naming of some search parameters and response fields in the `/indexes/{uid}/search` endpoint.

Search parameters formerly known as `facetsDistribution` and `matches` are now called `facets` and `showMatchesPosition`, respectively.

The response fields returned when using those parameters are now `facetDistribution` instead of `facetsDistribution` –note the suppression of the _s–_ and `_matchesPosition` instead of `_matchesInfo`.

The response field `nbHits` has been renamed `estimatedTotalHits`. This value was recurrently used to calculate the number of search result pages, which we strongly advise against. To learn how to paginate with Meilisearch without using `nbHits`, check out this [fresh new guide](https://docs.meilisearch.com/learn/advanced/pagination.html).

For the following query:

```bash
curl \
 -X POST 'http://localhost:7700/indexes/movies/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{
 "q": "Shazam",
 "facets: ["genres"],
 "showMatchesPosition": true
 }'
```

‌You’ll get the following response:

```JSON

{
 "hits": [
 {
 "id": "287947",
 "title": "Shazam!",
 "poster": "https://image.tmdb.org/t/p/w500/xnopI5Xtky18MPhK40cZAGAOVeV.jpg",
 "overview": "A boy is given the ability to become an adult superhero in times of need with a single magic word.",
 "release_date": 1553299200,
 "genres": [
 "Action",
 "Comedy",
 "Fantasy"
 ],
 "_matchesPosition": {
 "title": [
 {
 "start": 0,
 "length": 6
 }
 ]
 }
 },
 ...
 ],
 "estimatedTotalHits": 3,
 "query": "Shazam",
 "limit": 20,
 "offset": 0,
 "processingTimeMs": 4,
 "facetDistribution": {
 "genres": {
 "Action": 3,
 "Animation": 2,
 "Comedy": 1,
 "Fantasy": 1
 }
 }
}
 
```

**Breaking change: task management**
------------------------------------

### **Browsing tasks**

We have added a new pagination system to the `/tasks` endpoint.

With this change, it’s much easier to browse through the tasks, as their number can quickly grow in instances with a large number of asynchronous operations.

For each call to this endpoint, the response will return the following fields:

* `limit`: number of tasks returned (defaults to 20)
* `from`: the `uid` of the first task returned
* `next`: the `uid` of the next task

To view the next page of results, you would repeat the same query, replacing the value of `from` with the value of `next`. When the value of `next` is `null`, there are no more tasks to view.

This type of pagination system is called _keyset pagination_. As opposed to offset pagination used to browse indexes, documents, and keys, it has two main advantages: it prevents any inconsistencies and, since there is no need to scan and count records, it’s more efficient, which is a significant advantage when your task queue grows fast.

### **Filtering tasks**

We have also made [the task list filterable](https://docs.meilisearch.com/reference/api/tasks.html#filtering-tasks). You can now get tasks by `status`, `type`, or `indexUid`.

For example, the following command returns all tasks belonging to the index movies that succeeded:

```bash
curl -X GET 'http://localhost:7700/tasks?indexUid=movies&status=succeeded'
```

‌These modifications have led to the deletion of the `GET /indexes/:indexUid/tasks`  and the `GET /indexes/:indexUid/tasks/:taskUid` endpoints.

**Breaking change: dumps**
--------------------------

Dump creation has always been an asynchronous operation but used a separate queue from the task queue. With v0.28, dumps have become tasks. This has resulted in a new task type called `dumpCreation`.

Despite being tasks and thus sharing the same queue, **dumps are given priority**. They’ll be processed as soon as the current task is done running. You can think of dumps as VIPs in a club; even though they arrived last - which is reflected in their `taskUid` - they get to skip the line.

[via GIPHY](https://giphy.com/gifs/fail-fun-entertainment-hKYigb3Djp8pa)

**Contributors’ experience**
----------------------------

We have worked hard on improving the contribution experience of our tokenizer: [charabia](https://github.com/meilisearch/charabia/). The tokenizer’s role is to split a sentence or phrase into smaller units of language, called tokens. It is a critical factor in the quality of search results. Now, it is much easier to add languages to Meilisearch. You just need to follow the instructions on [CONTRIBUTING.md](https://github.com/meilisearch/charabia/blob/main/CONTRIBUTING.md).

Meilisearch works perfectly with any space-separated language and has special support for Japanese and Chinese. **We now support Hebrew,** too, thanks to our awesome community! Other languages will still work, but the quality and relevancy of search results may vary significantly.

We would love to provide global language support. The more feedback we get from native speakers, the easier it is for us to understand how to improve performance for those languages. If you want to help us [support your language](https://docs.meilisearch.com/learn/what_is_meilisearch/language.html#improving-our-language-support), we are eager to hear from you and see how we could make progress together!

**Other changes**
-----------------

* We have added pagination to the response of the `GET /indexes` and the `GET /keys` endpoints, and we have improved pagination for the `GET /indexes/{uid}/documents`
* For performance reasons, we have decided to limit the number of facet values returned per faceted attribute. This limit is customizable and defaults to 100
* You can customize the number of documents Meilisearch returns on search. The default limit is 1000 and protects the database from malicious scraping. Beware that increasing this limit can affect performance

We apologize in advance for any inconvenience caused by all these changes. It’s for a good cause: we are making these changes now to move towards v1.0 and avoid breaking changes later. Don’t hesitate to reach out to us if you need support or have any doubts. We are always happy to help!

**Contributors**
----------------

We are really grateful for this amazing community. We want to thank [@0x0x1](https://github.com/0x0x1), [@choznerol](https://github.com/choznerol), [@pierre-l](https://github.com/pierre-l), [@ryanrussell](https://github.com/ryanrussell), [@Thearas](https://github.com/Thearas), and [@walterbm](https://github.com/walterbm) for their help with Meilisearch, and [@matthias-wright](https://github.com/matthias-wright) for his help with [milli](https://github.com/meilisearch/milli). We want to send a special shout-out to [@benny-n](https://github.com/benny-n) for adding Hebrew to our [tokenizer](https://github.com/meilisearch/charabia).

And that’s it for v0.28! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.28.0) for the full release notes, and see you next time!

‌‌

What's new in v0.28

This article looks at some of the main and breaking changes, but you can view the [full changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.27.0) here.

**New feature: nested field support**
-------------------------------------

Meilisearch now offers full support for nested document fields, allowing you to use dot notation to access these fields. 
Let's take an example. If you have a book store index, you might want to make search results filterable by an author's surname but not by their given name:

```json
curl \
 -X POST 'http://localhost:7700/indexes/books/settings/filterable-attributes' \
 -H 'Content-Type: application/json' \
 --data-binary '[
 	"author.surname"
 ]'

```

You may use dot notation to access object properties anywhere in Meilisearch where you would use an attribute. For instance, you can access index settings like sortable attributes and searchable attributes or search parameters like `attributesToHighlight`.

**New feature: customize typo tolerance**
-----------------------------------------

Meilisearch is typo tolerant! This means our engine can interpret your search even if it contains typos or misspellings. With v0.27, you can customize the typo tolerance settings for an index using the new [update typo tolerance](https://www.meilisearch.com/docs/reference/api/settings#update-typo-tolerance-settings) endpoint or the existing [update settings endpoint](https://docs.meilisearch.com/reference/api/settings.html#update-settings):

The new API endpoints for typo tolerance accept a `typoTolerance` object with the following properties:

* `enabled`: whether the typo tolerance feature is enabled. Defaults to true
* `disableOnAttributes`: disables typo tolerance on specific document attributes. Typo tolerance is enabled on all attributes by default.
* `disableOnWords`: disables typo tolerance on a set of query terms given during search. Typo tolerance does not ignore any words by default.
* `minWordSizeForTypos`: Meilisearch only accepts typos in words over a certain size
* `oneTypo`: Customize the minimum word size for accepting one typo. Defaults to 5 characters.
* `twoTypos`: Customize the minimum word size for accepting two typos. Defaults to 9 characters.

Suppose you have a `movie` index that contains many character names. You might want Meilisearch to never look for typos in certain words but be more permissive with everything else:

```json
curl --location --request POST 'http://localhost:7700/indexes/children-movies/settings/typo-tolerance' \
--header 'Authorization: Bearer <API_KEY>' \
--header 'Content-Type: application/json' \
--data-raw '{
 "enabled": true,
 "minWordLengthForTypo": {
 "oneTypo": 3,
 "twoTypos": 7
 },
 "disableOnWords": ["Shrek"],
 "disableOnAttributes": []
}'

```

You can read more on typo tolerance [here](https://docs.meilisearch.com/learn/configuration/typo_tolerance.html).

New feature: improved highlighting and cropping search parameters
-----------------------------------------------------------------

This release brings three new search parameters: `highlightPreTag`, `highlightPostTag`, and `cropMarker`. The first two allow you to customize the appearance of highlighted search terms further, while the last one should be used in conjunction with `attributesToCrop`. 
When using `attributesToHighlight`, Meilisearch encloses matching terms in `` and strings by default. You can now configure these values to include any string using the `highlightPreTag`, and `highlightPostTag`. As the name indicates, `highlightPreTag` specifies the tag before the highlighted query terms, and `highlightPostTag` after the highlighted query terms. 
Likewise, when using `attributesToCrop`, you can now change the default `"…"` `cropMarker` to any string for marking crop boundaries. 
When designing an application that allows users to search through a database of movies, you might want to change `cropMarker` and the highlight tags to match your design:

```json
curl --location --request POST '<http://localhost:7700/indexes/movies/search>' \\
--header 'Authorization: Bearer <API_KEY>' \\
--header 'Content-Type: application/json' \\
--data-raw '{
 "q":"shifu",
 "attributesToCrop":["overview"],
 "attributesToHighlight":["overview"],
 "cropLength":10,
 "highlightPreTag":"",
 "highlightPostTag":"",
 "cropMarker":"[…]"
}'

```

Using the above query, the search term `shifu` is enclosed within tags, and the cropped text is marked by `[…]`:

```json
{
 "id": "50393",
 "title": "Kung Fu Panda Holiday",
 "overview": "The Winter Feast is Po's favorite holiday. Every year he and his father hang decorations, cook together, and serve noodle soup to the villagers. But this year Shifu informs Po that as Dragon Warrior, it is his duty to host the formal Winter Feast at the Jade Palace. Po is caught between his obligations as the Dragon Warrior and his family traditions: between Shifu and Mr. Ping.",
 "_formatted": {
 "id": "50393",
 "title": "Kung Fu Panda Holiday",
 **"overview": "[…]the villagers. But this year Shifu informs Po that as[…]"**
 }
}

```

For more information, check out our guide on [search parameters](https://docs.meilisearch.com/reference/api/search.html#search-parameters).

**Breaking change: \`cropLength\` behavior**
--------------------------------------------

The `cropLength` search parameter is now specified in the number of words instead of characters. 
Let’s take an example query:

```json
curl --location --request POST '<http://localhost:7700/indexes/movies/search>' \\
	--header 'Authorization: Bearer <API_KEY>' \\
--header 'Content-Type: application/json' \\
--data-raw '{
 "q":"shifu",
 "attributesToCrop":["overview"],
 "cropLength":10
}'

```

Meilisearch v0.27 returns:

```json
{
 "id": "50393",
 "title": "Kung Fu Panda Holiday",
 "overview": "The Winter Feast is Po's favorite holiday. Every year he and his father hang decorations, cook together, and serve noodle soup to the villagers. But this year Shifu informs Po that as Dragon Warrior, it is his duty to host the formal Winter Feast at the Jade Palace. Po is caught between his obligations as the Dragon Warrior and his family traditions: between Shifu and Mr. Ping.",
 "_formatted": {
 "id": "50393",
 "title": "Kung Fu Panda Holiday",
 **"overview": "…the villagers. But this year Shifu informs Po that as…",**
 }
}

```

**Breaking change: improved Docker workflow**
---------------------------------------------

Docker now starts from a different working directory: `/meili_data`. This streamlines situations when you might want to use snapshots and dumps with Docker. 
Usage remains mostly the same, but don't forget to update the data path:

```json
docker run -it --rm \\
-p 7700:7700 \\
-v $(pwd)/meili_data:/meili_data \\
getmeili/meilisearch:latest

```

With this change, dumps and snapshot features should work with Docker right out of the box. Rather than mounting separate volumes, it mounts all Meilisearch data into the meili\_data directory. 
Another consequence of this change is that the `meilisearch` binary has been moved to a new location. When using instance options to configure Meilisearch, you must now use `meilisearch`, `/meilisearch`, or `/bin/meilisearch` instead of ./meilisearch. We recommend using `meilisearch`, though. 
The updated command is:

```json
docker run -it --rm -p 7700:7700 getmeili/meilisearch:latest **meilisearch** --master-key="foobar"

```

**Other Changes**
-----------------

1. A typo on the first letter of a word will count as two typos. This reduces the search space for typo tolerance resulting in a faster search response time
2. Meilisearch now has a non-customizable limit of returning 1000 documents per search to protect the database from malicious scraping.
3. We added two new instance options to allow you more control over the use of machine resources during indexation(--max-indexing-memory and —-max-indexing-threads).
4. We now support Japanese.
5. The speed of adding new documents to a non-empty index has improved.

**Contributors**
----------------

A big thank you to all our contributors! We wouldn't have made it here without your support. This month, we want to send a special shout-out to [@miiton](https://github.com/miiton), [@djKooks](https://github.com/djKooks), [@mosuka](https://github.com/mosuka) for adding Japanese support, [@2shiori17](https://github.com/2shiori17) for adding support for new instance options for RAM and CPU usage during indexation. 
 
And that's all, folks! Remember to check out the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v0.27.0) for the full release notes, and see you next month!

What's new in v0.27

In this article, let's take a look at some of the most significant changes in Meilisearch's latest update. You can check out the [full changelog here](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.26.0).

New feature: tenant tokens
--------------------------

In software development, multitenancy means that multiple users—also called tenants—share the same computing resources but have different levels of access to system-wide data. In Meilisearch, you might have one index containing data belonging to many distinct tenants.

**Tenant tokens** are small packages of encrypted data containing **security credentials** and a set of **search rules**. These search rules effectively limit what documents a search query can return. For example, you might use tokens to ensure users of a healthcare application can only search through their own medical records, even when all records are stored in the same index.

To start using tenant tokens, set up a token generation process in your application's back-end:

```js
const currentUserID = 'aUserID';

const searchRules = {
  'patient_medical_records': {
    filter: `user_id = ${currentUserID}`
  }
};

const apiKey = 'yourApiKey';

const expiresAt = new Date('2025-12-20'); // optional

const token = client.generateTenantToken(searchRules, {
  apiKey: apiKey,
  expiresAt: expiresAt,
});

```

After you have created your tenant token, you can send it to your end-user's front-end and use it to query an index:

```js
const frontEndClient = new MeiliSearch({ host: 'http://127.0.0.1:7700', apiKey: token });
frontEndClient.index('patient_medical_records').search('blood test');

```

You can read more about multitenancy and how to implement tenant tokens in your application in [our dedicated guide](https://docs.meilisearch.com/learn/security/tenant_tokens.html).

Experimental feature: auto-batching
-----------------------------------

When it comes to improving Meilisearch's indexation performance, we have often recommended users to split their documents into batches. However, finding the right batch size can present an additional challenge. On the one hand, large batches use a lot of resources; on the other, small batches are significantly slower. We know we can do better than this.

In this release, we are introducing an experimental auto-batching feature. Auto-batching will help you improve indexing speed by **automatically batching together consecutive document additions**.

You can activate auto-batching by passing the `--enable-auto-batching` flag when launching Meilisearch:

```sh
./meilisearch --enable-auto-batching

```

We are very hopeful that this feature will make Meilisearch indexation faster and easier to use. You can read more about auto-batching on [our documentation website](https://www.meilisearch.com/docs/learn/core_concepts/documents#auto-batching).

We decided to ship it in an experimental state since this feature may be heavily reworked. We need your [feedback](https://github.com/meilisearch/MeiliSearch/discussions/2070) to measure its success and make it evolve.

Breaking change: new dump behavior
----------------------------------

Importing a dump into an instance with an existing database will throw an error and Meilisearch will not launch. Prior to v0.26 the import only failed silently and gave no indication anything had gone wrong.

```sh
./meilisearch --import-dump path_to_dump_file

```

If necessary for your workflow, you can use two new command-line flags to suppress import errors: `--ignore-dump-if-db-exists` and `--ignore-missing-dump`.

Breaking change: command-line flag behavior
-------------------------------------------

Starting with v0.26, the following instance options no longer accept values when used in the command-line: `-no-analytics`, `--schedule-snapshot`, `--ignore-missing-snapshot`, `--ignore-snapshot-if-db-exists`, `--ssl-require-auth`, `--ssl-resumption`, and `--ssl-tickets`.

```js
# new behavior
meilisearch --no-analytics

# old behavior
meilisearch --no-analytics=true

```

A value is still required when using these options as environment variables.

Other changes
-------------

*   Empty CSV cells are now converted to `null` values
*   Valid but empty payloads no longer throw errors when adding and updating documents
*   armv8 binaries are deprecated in favour of aarch64 binaries
*   Improved highlighting for searches containing non-unicode characters
*   Improved `_geoPoint` sorting behavior

Contributors
------------

Thank you very much to the contributors that helped us out! We want to give a special shout-out to [@robjtede](https://github.com/robjtede), [@Thearas](https://github.com/Thearas), and [@Samyak2](https://github.com/Samyak2)—we're humbled by your effort and generosity.

* * *

And that's all folks! Remember to check out the [changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.26.0) for the full release notes and see you soon for v0.27!

What's new in v0.26

In this article, we will take a look at some of the main and breaking changes introduced by v0.25. You can also read the [full changelog on GitHub](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.25.0).

Breaking changes
----------------

### API key management

Starting from this release, developers can now create API keys with specific permissions and expiration dates, allowing precise control over which users/applications can access which indexes and endpoints.

As part of this feature, the `private` and `public` keys are deprecated and replaced by two default API keys with similar permissions: `Default Admin API Key` and `Default Search API Key`.

The `X-MEILI-API-KEY: <apiKey>` header is replaced by the `Authorization: Bearer <apiKey>` header.

Let's say that you're creating an application in the medical industry. Here's how to create an API key that only has access to search endpoints on the `patient_medical_records` index:

```bash
curl \
 -X POST 'http://localhost:7700/keys/' \
 -H 'Content-Type: application/json' \
 -H 'Authorization: Bearer [your_master_key]' \
 --data-binary '{
 "description": "Search patient records key",
 "actions": [
 "search"
 ],
 "indexes": ["patient_medical_records"],
 "expiresAt": "2023-01-01T00:00:00Z"
 }'

```

**Response: `201 Created`**

```json
{
 "description": "Search patient records key",
 "key": "d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4",
 "actions": [
 "search"
 ],
 "indexes": [
 "patient_medical_records"
 ],
 "expiresAt": "2023-01-01T00:00:00Z",
 "createdAt": "2022-01-01T10:00:00Z",
 "updatedAt": "2022-01-01T10:00:00Z"
}

```

A user could then supply this key to make search requests on the `patient_medical_records` index:

```bash
curl \
 -X POST 'http://localhost:7700/indexes/patient_medical_records/search' \
 -H 'Content-Type: application/json' \
 -H 'Authorization: Bearer d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4' \
 --data-binary '{ "q": "trypophobia" }'

```

For more information, read our new guide to [securing a Meilisearch instance](https://www.meilisearch.com/docs/learn/security/master_api_keys).

### Asynchronous operations

With v0.25, we refashioned Meilisearch's asynchronous operations from the ground up, replacing the `updates` API with the new `tasks` API.

In a related change, creating, updating, and deleting indexes are now asynchronous operations. This fix eliminates the potential for race conditions.

Before v0.25, any request handled asynchronously (e.g. adding documents) returned an `updateId` for tracking the status of the operation:

```json
{ "updateId": 1 }

```

After v0.25, asynchronous operations will now return a summarized version of the _task_ object:

```json
{
 "uid": 1,
 "indexUid": "patient_medical_records",
 "status": "enqueued",
 "type": "documentAddition",
 "enqueuedAt": "2021-08-10T14:29:17.000000Z",
}

```

You can get the full _task_ object—and the current status of the operation—using the `/tasks` route.

```bash
curl \
 -X GET 'http://localhost:7700/tasks/1'
 
```

**Response: `200 Ok`**

```json
{
 "uid": 1,
 "indexUid": "patient_medical_records",
 "status": "succeeded",
 "type": "documentAddition",
 "details": { 
 "receivedDocuments": 1,
 "indexedDocuments": 1
 },
 "duration": "PT1S",
 "enqueuedAt": "2021-08-10T14:29:17.000000Z",
 "startedAt": "2021-08-10T14:29:18.000000Z",
 "finishedAt": "2021-08-10T14:29:19.000000Z"
}

```

Here the task has succeeded. Other possible statuses for a task are `enqueued`, `processing`, or `failed`.

When a task fails, Meilisearch returns an `error` object as part of the response:

```json
{
 "uid": 2,
 "indexUid": "patient_medical_records",
 "status": "failed",
 "type": "documentAddition",
 "details": { 
 "receivedDocuments": 1,
 "indexedDocuments": 0
 },
 "error": {
 "message": "Document does not have a `:primaryKey` attribute: `:documentRepresentation`.",
 "code": "internal",
 "type": "missing_document_id",
 "link": "https://docs.meilisearch.com/errors#missing-document-id",
 },
 "duration": "PT1S",
 "enqueuedAt": "2021-08-11T14:29:17.000000Z",
 "startedAt": "2021-08-11T14:29:18.000000Z",
 "finishedAt": "2021-08-11T14:29:19.000000Z"
}

```

For more information, check out the [Asynchronous operations](https://docs.meilisearch.com/learn/advanced/asynchronous_operations.html) article or the [tasks API reference](https://docs.meilisearch.com/reference/api/tasks.html).

Other changes
-------------

* **Cross-version compatibility:** Meilisearch v0.25 and subsequent releases are incompatible with dumps created prior to v0.22. 
 To migrate a dump from pre-v0.22 to v0.25 Meilisearch, first load your dump into v0.24.0, create a dump using v0.24.0, and then import this dump into v0.25.0.
* We have added several new error messages, most of which are related to managing API keys.
* `matches` now highlights string and numeric values.
* We added some new telemetry metrics.

Contributors
------------

A big thank you to all our contributors! This project couldn't get very far without your help.

Thanks to [@Mcdostone](https://github.com/Mcdostone) and [@Thearas](https://github.com/Thearas) for your help with Meilisearch, and to [@datamaker](https://github.com/datamaker) and [@Samyak2](https://github.com/Samyak2) for your help with our Tokenizer library.

* * *

If you want more details on updates we didn’t mention here, check out our [release changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.25.0).

What's new in v0.25

In this new version of Meilisearch, we focused on improving our error handler and reviewing our data collection policy—but don't worry, we still managed to squeeze in quite a few quality-of-life updates. We'll go through the most important bits here, but you can check out the [full changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.24.0) on our GitHub release page.

Breaking change: Improved error handling
----------------------------------------

Our revamp of the error handler started with minor changes to field and value names: `errorCode`, `errorType`, and `errorLink` have been shortened to `code`, `type`, and `link` respectively, and the three possible values for `type` have been shortened to `invalid_request`, `internal`, and `auth`.

```JSON
 {
 "message": "authorization header is missing",
 "code": "missing_authorization_header",
 "type": "auth",
 "link": "https://docs.meilisearch.com/errors#missing_authorization_header"
 }
```

In a related change, the update response in case of an error has been altered.

```JSON
{
 "status": "failed",
 "updateId": 1,
 // ...
 "error": {
	 "message": "Document `:documentId` not found.",
 	"code": "document_not_found",
 	"type": "invalid_request",
 	"link": "https://docs.meilisearch.com/errors#document_not_found"
 },
 }
```

**Instead of being located directly in the body, error fields are now located in a nested error object.**

Most importantly, we added new error codes and changed some old ones to make resolving errors faster and more intuitive. [Take a look at our release changelog for a more detailed list of updates](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.24.0).

Breaking change: `attributesToHighlight` now works on numeric values
--------------------------------------------------------------------

When you use the [`attributesToHighlight`](https://www.meilisearch.com/docs/reference/api/search#attributes-to-highlight) search parameter in your query, returned documents will include a `_formatted` object containing matching query terms wrapped in `` tags.

Starting with v0.24, `attributesToHighlight` works with both strings and numeric values. This means numbers inside `_formatted` will be automatically converted to strings:

```sh
curl \
 -X POST 'http://localhost:7700/indexes/games/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{ "q": "101", "attributesToHighlight": ["id, title, description"] }'
```
```JSON
{
 "id": 101,
 "title": " The Wonderful 101: Remastered",
 "description": "Lead an army of 101 Wonderful Ones from around the world in this Unite Action game!",
 "_formatted": {
 "id": "101",
 "title": " The Wonderful 101: Remastered",
 "description": "Lead an army of 101 Wonderful Ones from around the world in this Unite Action game!"
 }
}
```

Telemetry page update
---------------------

By default, we collect usage data from all Meilisearch instances that do not explicitly opt out.  A few releases ago, we [added an article to our documentation website](https://www.meilisearch.com/docs/learn/what_is_meilisearch/telemetry) describing why and how we collect usage data from Meilisearch instances. With v0.24, we have expanded that article to include [an exhaustive list of all the collected data points](https://www.meilisearch.com/docs/learn/what_is_meilisearch/telemetry#exhaustive-list-of-all-collected-data).

As part of this renewed commitment to data transparency, we have also put in place a process for users to request the deletion of their collected data. Simply drop us a message at [privacy@meilisearch.com](/blog/p/49021b33-6bd0-45b6-b3d8-2b962acbaae9/privacy@meilisearch.com)ncluding your instance's UID and we'll remove everything from our records, no questions asked.

Privacy is a difficult subject in tech and there is no shortage of companies who repeatedly violate it out of carelessness or because they stand to profit from unethical data harvesting. We hope to speak more about this in an upcoming blog post, but the important thing to know is that we believe honest and constant communication about these issues is the only way to ensure your data is safe and properly handled. If at any time you feel something looks odd or suspicious, you can use the [privacy@meilisearch.com](/blog/p/49021b33-6bd0-45b6-b3d8-2b962acbaae9/privacy@meilisearch.com)ddress to contact us and hold us accountable.

Other changes
-------------

* Performance improvements related to the \`attribute\` ranking rule
* Maximum attribute size increased from 1000 to 65535 positions
* Fixed erroneous CSV Content-Type error message
* Improved error handling when importing an empty dump
* Fixed indexation performance when using mounted disks

Contributors
------------

Not going to lie, this is our favourite part of the release blog post: thanking everyone who has dedicated their time to improving Meilisearch. You're all wonderful 🤩

This month, we'd like to give a special shout out to [@Jhnbrn90](https://github.com/Jhnbrn90), [@nav1s](https://github.com/nav1s), [@nfsec](https://github.com/nfsec), [@patrickdung](https://github.com/patrickdung), [@sanders41](https://github.com/sanders41), [@CNLHC](https://github.com/CNLHC), [@fumblehool](https://github.com/fumblehool), and [@palfrey](https://github.com/palfrey).

* * *

That's it for this release. If you want more details on updates we didn't have the time to mention here, do check out our [release changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.24.0).

See you next month for v0.25!

What's new in v0.24

This month’s release brings you geosearch and support for CSV and NDJSON payloads! You can read the full [changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.23.1), but let's take a look at some of the main and breaking changes.

New feature: Geosearch
======================

Meilisearch v0.23 supports geosearch. This allows you to filter and sort results based on their location.

To start using this feature, the `_geo` field must be present in your indexed documents and added to either the `filterableAttributes` or `sortableAttributes` list, depending on the type of operation you’d like to perform.

To filter your results so that they are within a certain area, you can use the built-in `_geoRadius` filter rule. Let’s say we're in the center of Muscat and want to view restaurants that are within two kilometers:

```bash
curl  
    -X POST 'http://localhost:7700/indexes/restaurants/search' \
    --data-binary '{ 
		"filter": "_geoRadius(23.5880, 58.3829, 2000)" 
	}'
```

`_geoRadius` establishes a circular area based on a central point and a radius. It requires three parameters: `lat`, `lng`, and `distance_in_meters`—the latitude, longitude, and distance in meters respectively.

You can also sort search results in ascending or descending order based on their distance from a geographic location using `_geoPoint`_._ Let’s say you want to order documents based on how close they are to the Eiffel Tower:

```bash
curl \
    -X POST 'http://localhost:7700/indexes/restaurants/search' \
	-H 'Content-type:application/json'
	--data-binary '{
	  "sort": "_geoPoint(48.8583701,2.2922926):asc" 
	}`
```

The search response will return an extra field called `_geoDistance`. This is the distance in meters computed from the `_geoPoint` and the `_geo` coordinates of the search results.

New feature: support for NDJSON and CSV payloads
================================================

Meilisearch now accepts CSV and NDJSON along with JSON as data sources. You will now need to specify a Content-Type header for HTTP requests through tools like `curl`.

Both CSV and NDJSON offer better indexation performance, consume less RAM and are not as CPU-intensive as JSON. NDJSON is easier to validate and, unlike CSV, can handle nested structures.  

Breaking change: Content-Type headers are now mandatory
=======================================================

Since Meilisearch now supports JSON, NDJSON, and CSV, you need to specify content headers for HTTP requests through tools like `curl`.

*   `Content-Type: application/json` for JSON
*   `Content-Type: application/x-ndjson` for NDJSON
*   `Content-Type: text/csv` for CSV

An example of the JSON header when creating an index:

```bash
curl \
    -X POST 'http://localhost:7700/indexes' \
    -H 'Content-Type: application/json' \
    --data-binary '{
      "uid": "movies",
      "primaryKey": "movie_id"
    }'
```

Contributors
============

A big thank you to all our contributors! We wouldn't have made it here without your support. This month, we want to send a special shout out to [@anirudhRowjee](https://github.com/anirudhRowjee), [@felixonmars](https://github.com/felixonmars), [@happysalada](https://github.com/happysalada), [@kappa-wingman](https://github.com/kappa-wingman), [@k-nasa](https://github.com/k-nasa), and [@shekhirin](https://github.com/shekhirin).

* * *

And that's all folks! Remember to check out the [changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.23.1) for the full release notes and see you next month!

Meilisearch latest news and company updates