Meilisearch, one of the fastest-growing open-source search engines on GitHub, has reached general availability with its cloud-based Search-as-a-Service product, [Meilisearch Cloud](https://cloud.meilisearch.com/register?utm_campaign=cloud-ga&utm_source=blog).

What is Meilisearch Cloud?
--------------------------

Meilisearch Cloud is a **cloud-based SaaS platform** that enables developers to implement search functionality quickly and easily. It is built on top of the popular [Meilisearch open-source search engine](https://github.com/meilisearch/meilisearch), which has gained a reputation for being lightning-fast, easy to use, and incredibly flexible. Meilisearch Cloud takes these attributes to the next level, offering a managed search service that is scalable, reliable, and designed to meet the needs of all companies.

With Meilisearch Cloud, we handle **all server management**, including

*   monitoring server health
*   installing and updating Meilisearch
*   server upgrades and patches

Our service is designed to **scale automatically** as your usage increases, so you don't have to worry about any sudden surge in traffic affecting your search performance.

Additionally, our costs scale with your usage, so there are no hidden fees to worry about. You only **pay for what you use**, which makes our platform an affordable and efficient solution for businesses of all sizes.

### Save time and resources

Meilisearch Cloud simplifies the process of implementing search, saving time and resources. It is made to be so user-friendly that a front-end developer with no prior search experience can build a world-class search experience in no time. Our intuitive interface streamlines the whole search process — no server management or DevOps experience is required!

We handle the grunt work. Once your Meilisearch project is up and running, we’ll ensure it stays that way so **you can focus on building your products**.

### Meilisearch Cloud has a great track-record

We’ve spent the last year gradually rolling out Meilisearch Cloud for selected users.

> _______Initial value came from the fact that Bookshop started using the Meilisearch open source solution, hosting the infrastructure locally. However, working with it in staging environments and test environments was a harder task for a small team like ours that can't focus on search year-round. We did eventually switch to Meilisearch Cloud because it was better for us to outsource._______

__\- Mason Stewart, CTO at Bookshop.org__

Our platform's commitment to customer satisfaction is reflected in our top-of-the-line support, which is always available to help customers with any issues they encounter. Overall, Meilisearch Cloud's customer-focused approach makes it a top choice for businesses looking to enhance their search capabilities.

Why businesses love Meilisearch Cloud?
--------------------------------------

**1\. Lightning-fast relevant search results**  
Meilisearch Cloud is designed from the ground up for performance and delivers search results in milliseconds. It does not only improve the user experience, but it also leads to increased engagement and conversion rates.

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

[See Meilisearch Cloud in action here](https://where2watch.meilisearch.com/?utm_campaign=cloud-ga&utm_source=blog)

**2\. Reliable and secure**  
Meilisearch Cloud is built on top of a highly secure and reliable infrastructure, leveraging the industry's best practices to ensure your search solution is always available and secure. You can focus on building the best possible search experience for your users without worrying about servers going down in the middle of the night.

**3\. Easy to use**  
Meilisearch Cloud is designed to be easy to use, even for developers without extensive experience working with search engines. Its intuitive interface makes creating and managing search indexes easy, allowing developers to quickly create highly relevant search experiences tailored to their specific needs.

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

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

Meilisearch Cloud upcoming interface

**4\. Highly scalable**  
Meilisearch Cloud is designed to be highly scalable, making it ideal for businesses of all sizes. Whether you are a small startup or a large enterprise, Meilisearch Cloud can easily scale to meet your needs.

### Meilisearch Cloud will adapt to your business

Meilisearch provides a range of plans to meet the needs of your business. The _Pro plan_ includes enough search units to accommodate most large businesses. It becomes the most cost-effective plan available, starting from 5 million searches per month. But until you reach 10M searches, it won't cost another penny. Many online merchants will be able to handle flash sales: even if the number of requests double, the price won't.

### Usage-based pricing

Meilisearch Cloud scales with your success. You will never be surprised by [our pricing](https://www.meilisearch.com/pricing?utm_campaign=cloud-ga&utm_source=blog): **we’ll only bill when your users search**. And when they do, they find more and make your business more successful.

This usage-based pricing works for any project: from a developer's personal project to a super-scaled company. And our free tier plan includes enough credits to accommodate most individual or small projects, so you’ll only start paying when it makes sense.

### Bookshop.org, an e-commerce platform, sees a +43% surge in search-based sales

[For the Bookshop.org team](/blog/bookshop-increases-search-based-purchases?utm_campaign=cloud-ga&utm_source=blog the advantage of Meilisearch lies in its simplicity and ease of use, making it possible for decision-makers and non-developers to be very close to the ranking rules. It was necessary to accommodate the ever-changing book search criteria during the busy holiday period and keep the search results relevant at all times.

> ______The fact that we can iterate back and forth quickly and have speedy re-indexing times when we change our rules was a new way of working with search. Previously, only our engineers had the expertise to tweak the rules for book search.______

__\- Mason Stewart, CTO at Bookshop.org__

Future of Meilisearch Cloud
---------------------------

### Upcoming Meilisearch features

In upcoming versions of Meilisearch, a range of new features will cater specifically to the e-commerce industry:

*   Searching for facet values and sorting them
*   Defining searchable fields at search time
*   Defining ranking rules at search time

Additionally, we will introduce scalability improvements enabling search engines to handle more queries and data more efficiently.

### Enterprise-ready improvements

The Cloud development team will soon release new features for production purposes:

*   geo-replication to provide fast search results to end users
*   specific e-commerce analytics
*   an even simpler interface

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

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

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

The upcoming interface of Meilisearch Cloud

We are currently in the process of obtaining a SOC 2 security certification, an auditing procedure that ensures we are securely managing sensitive and private data.

Conclusion
----------

With Meilisearch Cloud, you can be confident that your search is in safe hands. We offer a comprehensive and reliable search engine solution that can help you improve the performance and functionality of your search.

[Register for a Meilisearch Cloud account](https://cloud.meilisearch.com/register?utm_campaign=cloud-ga&utm_source=blog) today.

Search-as-a-service Meilisearch Cloud is open to the public

Let's take a look at some of the most significant changes in Meilisearch's latest update. We’ll go over the main changes in this article, but you can also view the [full changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.1.0) on GitHub.

New feature: multi-search API endpoint
--------------------------------------

With the introduction of the `/multi-search` API endpoint, Meilisearch allows you to send multiple search queries using a single HTTP request. This will allow you to accomplish a number of different things, like federated search and multi-select facets!

### Federated search

Suppose you have two distinct datasets: “brands” and “products”. Wouldn’t it be convenient if you could search for both at once while keeping them separate in their respective indexes? You can perform a federated search, also known as multi-index search, by querying multiple indexes:

```bash
curl \
-X POST 'http://localhost:7700/multi-search' \
-H 'Content-Type: application/json' \
--data-binary '{
 "queries": [
 {
 "indexUid": "products",
 "q": "Nike",
 "limit": 1
 },
 {
 "indexUid": "brands",
 "q": "Nike",
 "limit": 1
 }
 ]
}'

```

The response is a `results` array containing one object for each queried index:

```JSON
{
 "results": [
 {
 "indexUid": "products",
 "hits": […],
 "query": "Nike",
 "processingTimeMs": 1,
 "limit": 1,
 "offset": 0,
 "estimatedTotalHits": 17
 },
 {
 "indexUid": "brands",
 "hits": […],
 "query": "Nike",
 "processingTimeMs": 0,
 "limit": 1,
 "offset": 0,
 "estimatedTotalHits": 7
 }
 ]
}

```

### Multi-select facets

The multi-search requests API is particularly useful when it comes to implementing multi-select facets behavior in a faceted search interface.

Multi-select facets, also called disjunctive facets, allow users to view items that meet multiple criteria at the same time. This type of interface also shows the number of items available for each option, even if these items have not been selected. This allows for fast and efficient exploration of items that meet your users’ specific criteria, ultimately saving time and effort.

![](https://lh5.googleusercontent.com/HMSHnrtzKaXnDTE1Wh2AH3KupbhGTEM7-xIEid8X7oKjgHF30bQfb07gkpMBc9vz0Bb07NfanDCUHWfBhq37sxP_L_KMPem-sUKuhZ2ZNfJQ-z_vmXJPIuVEDB6978G0kYTy76Vvcrqvd6Xp4tvW560)

Since multi-select facets operate according to the inclusive `OR` logic, computing them requires sending several queries to Meilisearch. Sending these queries separately can lead to reduced performance and potentially higher hosting service costs.

Using the `/multi-search` endpoint, you can send multiple queries to the same index in a single request, thereby optimizing performance and reducing hosting costs.

<Callout>
 Prior to v1.1, achieving disjunctive facets behavior with [Instant Meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch) was possible but required making multiple requests to the API. This workaround is no longer necessary since Instant Meilisearch now uses the `/multi-search` endpoint.
</Callout>

Check our documentation to learn more about [multi-search requests](https://docs.meilisearch.com/reference/api/multi_search) and [faceted search](https://docs.meilisearch.com/learn/advanced/faceted_search).

New feature: \_geoBoundingBox
-----------------------------

A bounding box is a rectangular box that completely encloses an area. With the new `_geoBoundingBox` filter expression, you can search for results contained within a rectangular geographic area.

![](https://lh4.googleusercontent.com/YuchesiNXoIqJBYTcBTjVRUkuNiwTTn9xUG0ac7nvq8KDVIJH9sMmsBexIzyfbqfxjxUewijKk5XXIuUjEQPi7uozvu48lrF8XpYg_CC8VR7TU5qzdT2e8S3o06ahx05_THxQR4d0307Qevq9RQLoIQ)

It takes two parameters corresponding to the coordinates of the top right (northeast) and bottom left (southwest) corners of the desired area: `_geoBoundingBox([lat, lng], [lat, lng])`

```bash
curl \
-X POST 'http://localhost:7700/indexes/restaurants/search' \
-H 'Content-type:application/json' \
--data-binary '{ "filter": "_geoBoundingBox([45.472735, 9.184019],[45.473711, 9.185613] )" }'
```

Check our [guide](https://docs.meilisearch.com/learn/advanced/geosearch#filtering-results-with-georadius-and-geoboundingbox) on filtering results based on geographic coordinates.

New feature: introducing facetStats
-----------------------------------

When using the `facets` parameter in a search query, the search results object will now include a `facetStats` object that provides minimum and maximum values for each numerical facet. Any facets without numerical values will be omitted.

Given an index of products, suppose that you want to know the highest and the lowest price to implement a range slider component:

```bash
curl \
 -X POST 'http://localhost:7700/indexes/products/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{
 "facets": ["price"]
 }'

```

You would get the following response with all necessary information ready to use:

```JSON
{
 "hits": […],
 "facetDistribution": {
 "price": {…}
 },
 "facetStats": {
 "price": {
 "min": 1.99,
 "max": 1898.28
 }
 }
 }

```

Experimental feature: systems monitoring with Prometheus
--------------------------------------------------------

This release introduces a new `/metrics` endpoint that provides data compatible with [Prometheus](https://prometheus.io/), an open-source systems monitoring and alerting toolkit. This experimental endpoint gives valuable insights into the behavior and performance of Meilisearch.

To enable it, use the `--experimental-enable-metrics` flag when launching Meilisearch.

Are you planning to use this feature? Tell us about your experience in the [GitHub discussion](https://github.com/meilisearch/product/discussions/625).

Improvement: removing limits on index size and count
----------------------------------------------------

Meilisearch has lifted restrictions on the number and size of indexes per instance, so you can create as many indexes as you need 🥳

The only limit now is the memory address space allocated to a single process by your operating system. Read more about this in the [documentation](https://docs.meilisearch.com/learn/advanced/known_limitations#maximum-number-of-indexes-in-an-instance).

Other improvements
------------------

* You can now use wildcards (`*`) at the end of index names when managing API keys and tenant tokens. For example, `"medical*"` will match the `medical_records` and `medical_equipement` indexes
* You can override the default CSV delimiter–a single comma (`,`)– using the `csvDelimiter` parameter of the [add or update documents](https://docs.meilisearch.com/reference/api/documents#add-or-update-documents) or [add or replace documents](https://docs.meilisearch.com/reference/api/documents#add-or-replace-documents) endpoints
* Interleaved document addition and deletion tasks are now automatically batched together, speeding up the indexing process
* Our fantastic community has helped us enhance support for Greek and Arabic languages
* Language detection now happens at indexing time, reducing erroneous language recognition during search and thus improving relevancy

We are really grateful for all the community members who participated in this release. We would like to thank: [@akhildevelops](https://github.com/akhildevelops), [@AymanHamdoun](https://github.com/AymanHamdoun), [@cymruu](https://github.com/cymruu), [@FrancisMurillo](https://github.com/FrancisMurillo) [@GregoryConrad](https://github.com/GregoryConrad), [@gregsadetsky](https://github.com/gregsadetsky), [@james-2001](https://github.com/james-2001), [@MixusMinimax](https://github.com/MixusMinimax), [@waveywaves](https://github.com/waveywaves), and [@ztkmkoo](https://github.com/ztkmkoo) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch).

We also want to send a special shout-out to [@choznerol](https://github.com/choznerol), [@cymruu](https://github.com/cymruu), and [@james-2001](https://github.com/james-2001) for their work on [Charabia](https://github.com/meilisearch/charabia?ref=meilisearch-blog).

And that’s it for v1.1! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.1.0) for the full release notes. If you have any questions or would like to stay updated, you can join us on [Discord](https://discord.gg/meilisearch) or subscribe to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). You can also check out our [roadmap](https://roadmap.meilisearch.com/) and participate in our [Product Discussions](https://github.com/meilisearch/product/discussions) to help us improve.

What’s new in v1.1

We have just released our new version which development has been driven by our desire for simplicity of use.

We realized that some features were not easy to use because of design choices. The whole team gathered around the table and debated the API routes and their RESTfulness until everyone agreed on a proposal. We hope to strike a good balance between simplicity and customization.

So what is new in the v0.9?

*   Schema deletion!
*   Included web interface to try out your search
*   New settings handling
*   Simplified custom ranking rules
*   Added primary key
*   New built-in ranking rule names
*   Simplified authentication
*   Production and development mode
*   Bug fixes, syntax changes and, improvements

Schemaless
----------

The schemaless idea was in our mind for quite a while. When getting started, the user shouldn’t be required to specify how Meilisearch should handle every field, but only when their needs are really specific and out of the ordinary.  
Now, by default, Meilisearch will display every documents field, make them all searchable and will infer the document's primary key based on the provided documents structure.  
This solution causes way less friction when starting using Meilisearch.

Web interface
-------------

In the previous version, once you had started your Meilisearch engine and inserted some documents into it, the smooth experience stopped there. In order to try out the search, you had to either submit requests using curl or an SDK, either creating a front-end search bar connected to Meilisearch.

Now that a web interface is shipped with Meilisearch, all you need to do is open your web browser and enter Meilisearch’s address to visit it locally. This will lead you to a web page with a search bar that will allow you to search in a selected index.

![movies_web_2-1](https://unable-actionable-car.media.strapiapp.com/movies_web_2_1_f8a769507a.gif)

Since the production environment requires an API-key for searching, the web interface is only available in development mode.

Settings
--------

Anything that isn’t necessary to make your Meilisearch instance up and running can now be configured in the settings.

For each setting there is a route, thus making it possible to only update a specific setting. The global setting route gives you the possibility to post a configuration file describing your customizations, which will facilitate the creation of similar Meilisearch instances based on the same settings.

#### Example

```json
{
  "rankingRules": [
      "typo",
      "words",
      "proximity",
      "attribute",
      "wordsPosition",
      "exactness",
      "desc(release_date)"
  ],
  "distinctAttribute": null,
  "searchableAttributes": [
      "title",
      "description",
      "uid"
  ],
  "displayedAttributes": [
      "title",
      "description",
      "release_date",
      "rank",
      "poster"
  ],
  "stopWords": null,
  "synonyms": {
      "wolverine": ["xmen", "logan"],
      "logan": ["wolverine", "xmen"]
  },
  "indexNewFields": false
}

```

[All the settings can be found here](https://docs.meilisearch.com/reference/api/settings.html)

Simplified custom ranking rules
-------------------------------

In the previous version, creating your own rules could be confusing. We simplified this task! All you have to do now is add an ascending (`asc()`) or descending (`desc()`) rule on one of your fields in the ranking rules list.

```json
 "rankingRules": [
      "typo",
      "words",
      "proximity",
      "attribute",
      "wordsPosition",
      "exactness",
      "desc(release_date)"
  ]

```

If you update your ranking rules following this example, you will note that your changes have been taken into account by Meilisearch immediately. This means that once all the other rules have been applied, Meilisearch will consider documents with more recent release\_date's more relevant than older ones.

Primary key
-----------

Meilisearch will try to infer the primary key from the documents you upload. This inference will search for the first field containing the string `id` in its attribute.  
Sometimes, it may happen that no key can be found. In such a case, Meilisearch is not able to infer it.

Since Meilisearch needs a primary key to store the documents, if the latter cannot be inferred, we have set up two alternative ways to communicate the primary key to Meilisearch.

*   By giving it on index creation :

```json
{
  "uid": "movies",
  "primaryKey": "movieUniqueName"
}
```
    
*   By giving it on document addition

```bash
curl -X POST 'http://localhost:7700/indexes/movies/documents?primaryKey=movieUniqueName' --data @movies.json
```



New ranking rules names
-----------------------

In the previous versions, ranking rules names were too long and could contain unnecessary special characters. From now on, they have been simplified. Here is the list of the new built-in ranking rules:

*   `typo`
*   `words`
*   `proximity`
*   `attribute`
*   `wordsPosition`
*   `exactness`

[Follow this guide to know more about what each ranking rules does](https://docs.meilisearch.com/learn/core_concepts/relevancy.html).

Simplified authentication
-------------------------

When adding a master key to Meilisearch, a private key and a public key are generated on launch.  
The public key only grants permission to the routes that execute searches and get documents.  
The private key grants access to every other route in Meilisearch except for the `GET /keys` route. As it returns both the public and private keys, this route is accessible only with the master key.

[Read this to learn more about authentication in Meilisearch](https://docs.meilisearch.com/reference/features/authentication.html).

Production and development mode
-------------------------------

When launching your Meilisearch instance, setting the environment is now available as an option.  
By default, the environment is set to development mode.

While in development mode, you don't have to provide a master key. In that case, every route is accessible without requiring any API key. You are also able to **access the web interface**.

While in production mode, if no master key is given, the instance will be considered unsafe for production and will not start.

Bug fixes, syntax changes, and improvements
-------------------------------------------

*   Removed dead-lock in the update system
*   Settings can be added even when no primary key is known
*   `POST /documents/delete` changed to `POST /documents/delete-batch`
*   Speed up the reindexing system
*   When no highlight is prompted during search there will be no `_highlighted` field in the returned documents
*   Removed `searchableAttributes` from the search query parameters.
*   To know the stats of an index the route is now: `GET /indexes/:index_uid/stats` and not `GET /stats/:index_uid`
*   Documents ids' can only contain the following characters: `A-Z a-z 0-9`, `-`, and `_`

Some adjustments on routes’ design we made are temporary choices we took in order to release a working version. The `/key` route, for example, although functional, is too simple and not tailored to developers’ common needs. We are currently thinking about how to handle it better, and we are open to any advice!

This version took us about three months to finish, taking into account that the v0.8.5 has not been officially released but added to the v0.9 release. We did a lot of work on process organization to ensure that everything would be ready at the same time: the core Meilisearch, the documentation, and the SDK.

We are thrilled about how these latest changes will improve the users' experience with Meilisearch. This release is the result of a lot of discussions among our contributors and us. We are eager to hear about your experience with Meilisearch. Any suggestion or feedback is more than welcome since those are the premises of a long-term and ambitious project that will be built upon the decisions we make today.

![](https://unable-actionable-car.media.strapiapp.com/o_Ipwxee_S_Py1cnw_Ypq_J1w_Dufer_Collateral_test_0ac313d3ae.jpg)

Meilisearch v0.9: What’s new?

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!

Meilisearch latest news and company updates