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.4.0) on GitHub.

<Callout>
  v1.4 is now available on [Meilisearch Cloud](https://cloud.meilisearch.com/#release-v1-4&utm_source=blog). Upgrade your Meilisearch instance in one click without downtime.
</Callout>

New feature: custom text separators  

--------------------------------------

To make string data searchable, Meilisearch relies on [separators](https://meilisearch.com.cn/docs/learn/advanced/datatypes#release-v1-4&utm_source=blog#separators), as they serve to divide a string into tokens or words. Examples of separators include whitespaces, full-stops, or number signs (#). They play a crucial role in helping Meilisearch segment text effectively and enhance search relevancy.

Meilisearch comes with a predefined list of separators. However, these separators do not suit all use cases. For example, in a hashtag search, the number sign should not be considered a separator, but part of the word.

Starting with v1.4, Meilisearch allows you to customize the separators list to suit your specific needs.

### Using an SDK or the API

<Callout>
  This section shows code samples in JavaScript. Check out our [official SDKs](https://meilisearch.com.cn/docs/learn/what_is_meilisearch/sdks#release-v1-4&utm_source=blog) or the [API reference](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-4&utm_source=blog#separator-tokens) for more examples.
</Callout>

#### Adding characters to the separators list  

To include a character in the separators list, update your index’s _Separators Tokens_ settings:

```JavaScript
client.index('myIndex').updateSeparatorTokens(['&sect;'])
```

This request adds the encoded version of the section sign character (\`§\`) to the separator tokens list.

#### Removing characters from the separators list  

To remove one or more characters from the separators list, update your index’s _Non Separator Tokens_ settings:

```JavaScript
client.index('myIndex').updateNonSeparatorTokens(['@', '#', '&'])
```

### Using Meilisearch Cloud

On [Meilisearch Cloud](https://cloud.meilisearch.com/#release-v1-4&utm_source=blog), you can configure _Separator Tokens_ from your index’s settings. Both fields accept JSON format. To include separators, add them to the 'separators' field. To exclude certain characters as separators, list them under 'non-separators'.

![Screenshot of Meilisearch Cloud UI showcasing the 'separator settings' section. It features two fields: one for listing separators and another for listing non-separators. ](https://unable-actionable-car.media.strapiapp.com/0dfq_LJ_Qj_G_L_Rt9_X_r_F6d6_RKYCTU_Kt_K_ib_Q9_E_Ye3_A8_Cq_V_Ea20_Mv_q3_Pgo_Yrdkbcy_WC_8_QSZN_6f_Bn_D_Wu_QN_87_H_Izf_1_Zyk_FWKKD_Lv_b64487b283.jpg)

New feature: custom dictionary
------------------------------

<Callout>
  This section shows code samples in JavaScript. Check out our [official SDKs](https://meilisearch.com.cn/docs/learn/what_is_meilisearch/sdks#release-v1-4&utm_source=blog) or the [API reference](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-4&utm_source=blog#dictionary) for more examples.
</Callout>

Now, you can add a custom word dictionary to improve Meilisearch's segmentation of specific words. This is particularly useful when working with domain-specific terminology like “Node.js” or proper nouns like “E. E. Cummings”.

To add words to the dictionary, update your index’s _Dictionary_ settings:

```JavaScript
client.index('myIndex').updateDictionary(['e. e.', 'e.e.', 'e e'])
```

On [Meilisearch Cloud](https://cloud.meilisearch.com/#release-v1-4&utm_source=blog), you can configure a _Custom Dictionary_ by providing a JSON array in your index’s settings. You can also upload a JSON file as dictionary.

### Using custom dictionary with stop words and synonyms

The introduction of a custom dictionary acts as a powerful adjunct to existing features like [stopWords](https://meilisearch.com.cn/docs/reference/api/settings#release-v1-4&utm_source=blog#stop-words) and [synonyms](https://meilisearch.com.cn/docs/learn/configuration/synonyms#release-v1-4&utm_source=blog). Together, they synergize to improve the relevancy of the search results.

Let’s consider a literary database where an author's name may appear in various forms or abbreviations. This leads to fragmented search results, making it challenging for users to find works by that specific author. For example, take the different ways one might search for works by E. E. Cummings. Using the custom dictionary feature along synonyms can standardize these name variations, thereby enhancing the relevancy of search results.

Using synonyms and custom dictionary together, here’s an example of index settings that address this scenario:

```JSON
{
"dictionary": ["E. E.", "E.E.", "E E"],
"synonyms": {
    "E. E.": [ "E.E.", "E E", "Edward Estlin"],
    "E.E.": ["E. E.", "E E", "Edward Estlin"],
    "E E": ["E. E.", "E.E.", "Edward Estlin"],
    "Edward Estlin": ["E. E.", "E.E.", "E E"]
}
```

Breaking bug fix: improved filtering with backslashes
-----------------------------------------------------

In v1.4, we've addressed a longstanding bug that users faced when using backslashes (\\) at the end of the \`filter\` search parameter expression.

Let’s consider the following documents:

```JSON
[
  {
    "id": 1,
    "path": "my\\test\\path"
  },
  {
    "id": 2,
    "path": "my\\test\\path\\"
  }
]

```

**Note**: The double backslashes in the example are for JSON escaping.

Before v1.4.0, trying to filter on the second document using either of the filters `path = "my\\test\\path\\"` or `path = "my\\test\\path\\\"` would lead to errors.

Now, you can use any filter expression with backslashes. Just make sure to escape each `\` character in your filter.  

Using our example, to filter on the second document successfully, the filter should be written as: `path = "my\\\\test\\\\path\\\\"`.  

⚠️ **Warning:** If you're upgrading from v1.3.X or earlier and have previously used backslashes in filters, be aware that in v1.4.0, the correct filter for the first document should be `path = "my\\\\test\\\\path"`.  

Two layers of escaping are applied: : first, escape for JSON, then for the Meilisearch filter. Meilisearch turns `\\\\` back to `\\`, and JSON parsing will result in a single `\`.  

<Callout>
  Consider using built-in methods of your programming language to handle backslashes:- PHP: [addslashes() function](https://php.ac.cn/manual/en/function.addslashes.php)\- JavaScript: While JS doesn't have a specific method for adding slashes. You can use the [replace method](https://mdn.org.cn/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace), as suggested on [StackOverflow](https://stackoverflow.com/questions/7744912/making-a-javascript-string-sql-friendly)
</Callout>

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

We are really grateful for all the community members who participated in this release. We would like to thank: [@dogukanakkaya](https://github.com/dogukanakkaya), [@JannisK89](https://github.com/JannisK89), and [@vivek-26](https://github.com/vivek-26) for their help with Meilisearch. We want to send a special shout out to [mmachatschek](https://github.com/mmachatschek/) for his help and involvement with the backlash bug.

Conclusion
----------

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

You can stay in the loop by subscribing to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/) and come participate in our [Product Discussions](https://github.com/meilisearch/product/discussions).  

For anything else, join our developers community on [Discord](https://discord.gg/meilisearch).

What's new in v1.4?

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.3.0) on GitHub.

v1.3 is now available on [Meilisearch Cloud](https://meilisearch.com.cn/cloud), including all experimental features. Upgrade your Meilisearch instance in one click without downtime.

Experimental feature: vector search
-----------------------------------

<Callout>
  Using LangChain? You can now use the [Meilisearch vector store](https://python.langchain.ac.cn/docs/integrations/vectorstores/meilisearch) to benefit from powerful search features!
</Callout>

We are excited to introduce [vector storage](https://meilisearch.com.cn/docs/learn/experimental/vector_search)! Now, you can index and search documents using vector embeddings—numerical representations of data. For the first iteration of this feature, you need to use an external tool such as [Hugging Face](https://hugging-face.cn/), [Cohere](https://cohere.com/), or [OpenAI](https://openai.com/), to create such embeddings. Check out the [announcement post](/blog/vector-search-announcement/ to discover the extensive possibilities and potential applications of this feature.

<Callout>
  This feature is experimental, you can enable it using the new [experimental-features endpoint](https://meilisearch.com.cn/docs/reference/api/experimental_features).
</Callout>

To search documents based on their vector proximity, make sure they contain a `_vectors` field:

```bash
curl -X POST -H 'content-type: application/json' \
  'localhost:7700/indexes/songs/documents' \
  --data-binary '[
      { "id": 0, "_vectors": [0, 0.8, -0.2], "title": "Across The Universe" },
      { "id": 1, "_vectors": [1, -0.2, 0], "title": "All Things Must Pass" },
      { "id": 2, "_vectors": [[0.5, 3, 1], [-0.2, 4, 6]], "title": "And Your Bird Can Sing" }
  ]'
```

Once stored, you can search your vectorized documents by using the new `vector` search parameter in combination with the [search](https://meilisearch.com.cn/docs/reference/api/search) and [multi-search](https://meilisearch.com.cn/docs/reference/api/multi_search) routes.

```bash
curl -X POST -H 'content-type: application/json' \
'localhost:7700/indexes/songs/search' \
--data-binary '{ "vector": [0, 1, 2] }'
```

👉 Note that you need to generate the vector in your query using a third-party tool.

The returned documents include a `_semanticScore` field indicating the semantic similarity—or relevancy—of each document with the query.

```JSON
{
  "hits": [
    { "id": 0, "_vectors": [0, 0.8, -0.2], "title": "Across The Universe", "_semanticScore": 0.6754 },
    { "id": 1, "_vectors": [1, -0.2, 0], "title": "All Things Must Pass", "_semanticScore": 0.7546 },
    { "id": 2, "_vectors": [[0.5, 3, 1], [-0.2, 4, 6]], "title": "And Your Bird Can Sing", "_semanticScore": 0.78 }
  ],
  "query": "",
  "vector": [0, 1, 2],
  "processingTimeMs": 0,
  "limit": 20,
  "offset": 0,
  "estimatedTotalHits": 2
}
```
<Callout>
  This feature is experimental and we need your help to improve it! Share feedback on [this GitHub discussion](https://github.com/meilisearch/product/discussions/677).
</Callout>

New feature: display ranking scores at search
---------------------------------------------

Use the new `showRankingScore` search parameter to see the [ranking score](https://meilisearch.com.cn/docs/reference/api/search#ranking-score) of relevancy of each document:

```bash
curl \
  -X POST 'https://:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "Batman Returns", "showRankingScore": true }'
```

Each document in the response will include a `_rankingScore` property, which represents a score between 0 and 1:

```JSON
"_rankingScore": 0.8575757575757575,
```

The higher the `_rankingScore`, the more relevant the document is.

Experimental feature: ranking score details
-------------------------------------------

For every document returned, Meilisearch provides a [detail of the ranking score](https://meilisearch.com.cn/docs/learn/experimental/ranking_rule_score_details) of each ranking rule. This feature is a perfect example of [how community engagement can enrich the design process](/blog/from-ranking-to-scoring/ at Meilisearch.

<Callout>
  This feature is experimental, you can enable it using the new [experimental-features endpoint](https://meilisearch.com.cn/docs/reference/api/experimental_features).
</Callout>

Set the `showRankingScoreDetails` search parameter to `true` to view the ranking score details:

```bash
curl \
  -X POST 'https://:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "Batman Returns", "showRankingScoreDetails": true }'
```

  
The response should include the relevancy score of each rule:

```JSON
"_rankingScoreDetails": {
  "words": {
    "order": 0,
    "matchingWords": 1,
    "maxMatchingWords": 1,
    "score": 1.0
  },
  "typo": {
    "order": 1,
    "typoCount": 0,
    "maxTypoCount": 1,
    "score": 1.0
  },
  "proximity": {
    "order": 2,
    "score": 1.0
  },
  "attribute": {
    "order": 3,
    "attributesRankingOrder": 0.8,
    "attributesQueryWordOrder": 0.6363636363636364,
    "score": 0.7272727272727273
  },
  "exactness": {
    "order": 4,
    "matchType": "noExactMatch",
    "score": 0.3333333333333333
  }
}
```
<Callout>
  This feature is experimental. You can help us improve it by sharing your feedback on [this GitHub discussion](https://github.com/meilisearch/product/discussions/674).
</Callout>

New feature: search for facet values
------------------------------------

Once you have defined your [filterable attributes](https://meilisearch.com.cn/docs/reference/api/settings#filterable-attributes), you can use the new endpoint `POST /indexes/{index}/facet-search` to [search for facet values](https://meilisearch.com.cn/docs/learn/fine_tuning_results/faceted_search#searching-facet-values).

```bash
 curl \
  -X POST 'https://:7700/indexes/movies/facet-search' \
  -H 'Content-Type: application/json'  \
  --data-binary '{
    "facetName": "genres",
    "facetQuery": "a"
  }'
```

  
As facet search is typo tolerant and supports prefix search, the above query will return de following results:

```JSON
{
    "facetHits": [
        {
            "value": "Action",
            "count": 5403
        },
        {
            "value": "Adventure",
            "count": 3020
        },
        {
            "value": "Animation",
            "count": 1969
        }
    ],
    "facetQuery": "a",
    "processingTimeMs": 0
}
```

To test this feature, check out our updated [ecommerce demo](https://ecommerce.meilisearch.com/).

  

![](https://lh5.googleusercontent.com/AvwqKTkbB0RfTYrWL4xeBUZEdzRwrEjgL0yKllbM5AZu0aXkpmO-peqP7y-5SC-O30TsAdaiXEMdOck4hiS44UvF8UFV-MwsM-mvtdRmxEeKtPowTUXQThTlqlP5yqz2p_5WohLCIgOtydEvK33TdAY)

  

New feature: sort facet values by count
---------------------------------------

By default, facets are sorted in ascending alphanumeric order. Now, you can sort facet values in descending order based on the number of matched documents containing each facet value.

To order facets by count, you can use the new `sortFacetValuesBy` property in the  [faceting index settings](https://meilisearch.com.cn/docs/reference/api/settings#faceting).

To modify the order for all facets, you can use the asterisk (\*) wildcard:

```bash
 curl \
  -X PATCH 'https://:7700/indexes/movies/settings/faceting \
  -H 'Content-Type: application/json'  \
  --data-binary '{
    "sortFacetValuesBy": {"*": "count"}
  }'
```

Alternatively, you have the flexibility to order a single facet by count while maintaining alphanumeric ordering for other attributes:

```json
 curl \
  -X PATCH 'https://:7700/indexes/movies/settings/faceting \
  -H 'Content-Type: application/json'  \
--data-binary '{
    "sortFacetValuesBy": {"*": "alpha", "genre": "count"}
  }'
```

You can also try it in the [ecommerce demo](https://ecommerce.meilisearch.com/).

![](https://lh4.googleusercontent.com/s7qTls-ayHQpaIASqAQjNX0AnGUfc5TkZu6r83XvZBJyyyxU54qpeAXvjgofCgEbiMs72wwmVQF5m-LnLNkiQVkQFJULEvqgSYdtVh_dxGufHr8FC7zxag9PMsSXb0YbsjysSqBQuRRiSSFWcqNqyKc)

New feature: searchable attributes at query time
------------------------------------------------

With the new `attributesToSearchOn` search parameter, you can now [restrict the search](https://meilisearch.com.cn/docs/reference/api/search#customize-attributes-to-search-on-at-search-time) to a subset of the [searchable attributes](https://meilisearch.com.cn/docs/learn/configuration/displayed_searchable_attributes#the-searchableattributes-list) at query time. It accepts an array of strings indicating one or more document attributes:

```JSON
{
  "q": "adventure",
  "attributesToSearchOn": ["genre"]
}
```

Given the following documents, the above query will only return document with id 1.

```JSON
{
    "id": 0,
    "name": "An Adventure in Space and Time",
    "genre": ["drama"]
},
{
    "id": 1,
    "name": "A Strange and Stubborn Endurance",
    "genre": ["adventure"]
}
```

Relevancy change: attribute ranking rule
----------------------------------------

With v1.3, the [attribute ranking rule](https://meilisearch.com.cn/docs/learn/core_concepts/relevancy#4-attribute) assigns higher relevancy to documents where the query words appear closer to their position in the query, compared to documents where the query words are farther from their position in the query.

Before, this rule measured relevancy based on the position of the words in the attribute rather than on their position in the search query. Documents with attributes containing the query words at the beginning of the attribute were considered more relevant.

Consider the following query: "Batman the dark knight returns" and the corresponding documents:

```JSON
{ 
    "id": 0, 
    "title": "Batman the dark knight returns" 
},
{ 
    "id": 1, 
    "title": "Dark the Batman knight returns" 
},
{ 
    "id": 2, 
    "title": "Batman returns: a retrospective", 
    "description": "The Dark knight is analyzed in this new Batman documentary" 
}
```

Prior to version 1.3, the attribute ranking rule placed document 2 at the top of the list, followed by documents 0 and 1, ranked in a tie.

Since version 1.3, the order is strictly: document 0, document 1, document 2, which provides a more natural ranking.

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

*   The `/tasks` route now shows the total number of tasks in the queue using the `total` property. It also displays the total number of tasks based on specific filters
*   Enhanced Japanese support and segmentation
*   Improvements in the Prometheus `/metrics` experimental feature

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

We are really grateful for all the community members who participated in this release. We would like to thank: [@vvv](https://github.com/vvv), [@jirutka](https://github.com/jirutka), [@gentcys](https://github.com/gentcys), [@cuishuang](https://github.com/cuishuang), [@0xflotus](https://github.com/0xflotus), and [@roy9495](https://github.com/roy9495) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch#blog.meilisearch.com).

We also want to send a special shout-out to our Meilistar, [@mosuka](https://github.com/mosuka), for his continuous Japanese improvements on [Charabia](https://github.com/meilisearch/charabia#meilisearch-blog).

Conclusion
----------

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

You can stay in the loop by subscribing to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e&ref=blog.meilisearch.com). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/#blog.meilisearch.com) and come participate in our [Product Discussions](https://github.com/meilisearch/product/discussions#blog.meilisearch.com).

For anything else, join our developers community on [Discord](https://discord.gg/meilisearch#blog.meilisearch.com).

What’s new in v1.3?

We’re thrilled to announce the release of Meilisearch v1.2. This minor version comprises new features for filters and engine improvements across the board. Let’s dig into the most noteworthy changes!

New feature: enhanced document management with filters
------------------------------------------------------

We’re excited to improve Meilisearch developers' experience by introducing filters for fetching and deleting documents. 🥳

<Callout>
  As always with filters, document fields must first be set as [filterable attributes](https://meilisearch.com.cn/docs/learn/core_concepts/indexes#filterable-attributes).
</Callout>

### Retrieving documents

Filters bring new capabilities to fetching documents. For example, we could check how many documents match some filters before performing a deletion.

So we’re introducing a new endpoint to retrieve documents:

`**POST** /indexes/{indexUid}/documents/fetch`

Let’s consider an index that contains movies. We will write a request to retrieve 10 movies from the _Horror_ or _Mystery_ genre. Using the [array syntax](https://meilisearch.com.cn/docs/learn/advanced/filtering#creating-filter-expressions-with-arrays), we can express the filters in the request body as following:

```json
{
  "filter": [
    "genre = Horror",
    "genre = Mystery"
  ],
  "limit": 10
}
```

This new endpoint saves you from having to make a search request to explore your data. Read more about fetching documents using filters in the [dedicated docs](https://meilisearch.com.cn/docs/reference/api/documents#get-documents-with-post).

### Deleting documents

You can now delete documents matching a list of filters. This feature comes with a dedicated endpoint:

`**POST** /indexes/{indexUid}/documents/delete`

Taking the example of an index that contains movies, let’s write a request to delete all _Horror_ or _Comedy_ movies, as well as movies directed by _James Cameron_. This can expressed with the following request body:

```json
{
  "filter": [
    [ "genre = Horror", "genre = Comedy" ],
    "director = \"James Cameron\""
  ]
}
```

This requests launches a task to delete matching documents. Meilisearch will respond with a summarized task object:

```json
{
  "taskUid": 42,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "documentDeletion",
  "enqueuedAt": "2023-06-05T11:01:58.721841Z"
}
```

This task represents the asynchronous deletion operation. Don’t forget to [check the task status](https://meilisearch.com.cn/docs/reference/api/tasks#get-one-task) to ensure that documents have been deleted before proceeding. Read more about deleting documents in the [dedicated docs](https://meilisearch.com.cn/docs/reference/api/documents#delete-documents-by-filter).

New feature: `IS EMPTY` and `IS NULL` filter operators
------------------------------------------------------

This release gives new powers to filters. So we thought, how can we go further? Maybe if we could filter in even more ways. I mean, don’t you want some more filters with your filtering?

So, we’re introducing two new filter operators: `IS EMPTY` and `IS NULL`. `IS EMPTY` matches existing attributes with empty value while `IS NULL`  matches fields with a null value.

Here’s an example considering the following documents:

```json
[
  {
    "id": 0,
    "color": []
  },
  {
    "id": 1,
    "color": null
  },
  {
    "id": 2,
  }
]
```

The new filter operators work like this:

*   `color IS EMPTY`: matches document `0`
*   `color IS NULL`: matches document `1`

Note that neither `IS EMPTY` nor `IS NULL` matches documents missing the `color` field. Both operators can also be used in conjunction with `NOT`. Read more in the [related documentation](https://meilisearch.com.cn/docs/learn/advanced/filtering#filter-operators).

Experimental feature: reducing memory usage
-------------------------------------------

We’re introducing a new experimental flag to decrease the RAM usage of Meilisearch. Try it by launching Meilisearch with the `--experimental-reduce-indexing-memory-usage` CLI flag or the `MEILI_EXPERIMENTAL_REDUCE_INDEXING_MEMORY_USAGE` environment variable.

You can give feedback on this [Github discussion](https://github.com/meilisearch/product/discussions/652).

Improvement: relevancy
----------------------

We’ve enhanced [typo tolerance](https://meilisearch.com.cn/docs/learn/configuration/typo_tolerance). Split words are now considered a typo, meaning `whit ehorse` may now match documents containing `white horse`. However, [n-grams](https://en.wikipedia.org/wiki/N-gram) and split words will now rank lower. This means that `sun flower` will now return a document containing `Sun Flower` before one with `Sunflower`.

Improvement: automated task deletion
------------------------------------

Meilisearch handles operations like adding documents to an index [asynchronously](https://meilisearch.com.cn/docs/learn/advanced/asynchronous_operations). This means they are not handled immediately. Instead, Meilisearch places them in a tasks queue and processes them in the order they were received. Starting with v1.2, the maximum capacity of the task queue is 1 million.

Once the queue is full, Meilisearch will try to delete the oldest 100,000 tasks. Meilisearch will not remove tasks that are _not_ finished (enqueued or processing). It will simply delete as many finished tasks as possible among the 100,000 oldest.

<Callout>
  When automatic deletion fails for a task, Meilisearch will issue logs with \`warning_\`_ levels.
</Callout>

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

*   Updated how Meilisearch handles ranking rules to improve search consistency and latency
*   [Geosearch](https://meilisearch.com.cn/docs/learn/advanced/geosearch) sorting is now more performant for both descending and ascending sort
*   Enhanced language support for Latin languages and Arabic thanks to [charabia](https://github.com/meilisearch/charabia/releases/tag/v0.7.2) update

Conclusion
----------

This wraps up the biggest changes in Meilisearch v1.2. For an exhaustive review, including security updates and bug fixes, consult the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.2.0).

We’re already preparing version 1.3 of Meilisearch. We already have three prototypes ready for you to play with: [search for facet values](https://github.com/meilisearch/product/discussions/515#discussioncomment-5806759), [sorting facet values](https://github.com/meilisearch/product/discussions/519#discussioncomment-6030480), and the  [CONTAINS,  STARTS WITH, and ENDS WITH filter operators](https://github.com/meilisearch/product/discussions/544#discussioncomment-5918077). We’re eager to hear from you to nail the finishing touches.

This release wouldn’t be possible without the contributions of [@cymruu](https://github.com/cymruu), [@GregoryConrad](https://github.com/GregoryConrad), [@inductor](https://github.com/inductor), [@jirutka](https://github.com/jirutka), [@jlucktay](https://github.com/jlucktay), [@roy9495](https://github.com/roy9495), and [@Sufflope](https://github.com/Sufflope) to [meilisearch](https://github.com/meilisearch/meilisearch). This also includes the work of [@akeamc](https://github.com/akeamc), [@DrAliRagab](https://github.com/DrAliRagab), [@goodhoko](https://github.com/goodhoko), and [@mosuka](https://github.com/mosuka) who contributed to the last release of [charabia](https://github.com/meilisearch/charabia) to keep improving language support. Massive thanks to our awesome contributors. 🫶

You can stay in the loop by subscribing to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/) and come participate in our [Product Discussions](https://github.com/meilisearch/product/discussions).

**Join the discussion on [/r/rust](https://www.reddit.com/r/rust/comments/1418k4v/opensource_search_engine_meilisearch_releases_v12/).**

For anything else, join our developers community on [Discord](https://discord.gg/meilisearch).

I’ll see you there.

What's new in v1.2?

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#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/#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://meilisearch.com.cn/pricing#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#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#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 'https://: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 'https://: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 'https://: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.ac.cn/), 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#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 'https://: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://meilisearch.com.cn/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 'https://: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 'https://: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 'https://: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 'https://: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://meilisearch.com.cn/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 '<https://: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!

Meilisearch 最新消息和公司动态

v1.4 有什么新功能？

v1.3 有什么新功能？

v1.2 有哪些新功能？

Meilisearch 云搜索服务已向公众开放

v1.1 中的新功能

Meilisearch v0.9：有什么新功能？

v1.0 版本的新特性

v0.30 有什么新变化

v0.29 有什么新功能？