Today marks the launch of Meilisearch v0.21, our first new release since March 2021. As you might expect, this one packs a whole lot of changes to our search engine, both big and small. You can check our [exhaustive changelog outlining all breaking changes and download the binaries here](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.21.0), but in this post we wanted to take a closer look at some of the most important updates.

Search performance
------------------

First, one of the best news we could give you: v0.21 is the fastest Meilisearch release (so far). How fast? Our tests using a 1GB dataset with 115 million documents indicate that complex queries return results up to ten times faster than v0.20; filtering those results, previously a slow operation, takes a maximum of 50ms.

Refactor
--------

Clémentine already wrote about [why we chose to refactor](/blog/refactoring-meilisearch/)undamental parts of our core engine, but in case you missed it: it became increasingly hard for us to keep our code easy to read for external contributors and to add new features without negatively impacting performance.

We are very proud of what we accomplished in these months, not only because we managed to greatly improve Meilisearch's performance, but also because we know our search engine has a new, rock-solid foundation.

Facets and filters
------------------

Some of the biggest visible (and breaking) changes in v0.21 concern facets and filters.

First of all, [the search parameters `filters` and `facetFilters` have been replaced by `filter`](https://docs.meilisearch.com/reference/features/search_parameters.html#filter). This new parameter allows you to refine search results based on document attributes whose values are either numbers or strings.

```javascript
$ curl 'https://127.0.0.1:7700/indexes/movies/search' \
--data '{ "q": "thriller", "filter": ["genres = Horror", "genres = Mystery"]}'
```

In this example, we create a filter that only returns movies classified as both horror and mystery.

To use an attribute with the `filter` search parameter, you must first add it to [the new `filterableAttributes` index setting](https://docs.meilisearch.com/reference/api/filterable_attributes.html). `filterableAttributes` works exactly like and replaces the `attributesForFaceting` index setting.

```javascript
$ curl \
  -X POST 'https://127.0.0.1:7700/indexes/movies/settings' \
  --data '{
      "filterableAttributes": [
          "director",
          "genres"
      ]
  }'

```

Meilisearch no longer distinguishes between facets and filters: you can use the new `filter` search parameter and the `filterableAttributes` index setting to create [faceted search interfaces](https://docs.meilisearch.com/reference/features/filtering_and_faceted_search.html).

Phrase search
-------------

Meilisearch v0.21 supports [phrase searches](https://docs.meilisearch.com/reference/features/configuration.html#disable-analytics). If you enclose one or more search terms in double quotes (for example, `“african-american poet”` or `“John Waters”`), Meilisearch will only return documents that contain those terms exactly as they were written and in the order they were given. Phrase searches are a great way to make a query more precise and come in handy when you know your search should only get one result, such as when looking for a book using its ISBN number.

```javascript
$ curl 'https://127.0.0.1:7700/indexes/movies/search' \
  --data '{ "q": "\"John\" Waters" }'
```

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

In case you didn't know, [Meilisearch automatically creates a web interface](https://docs.meilisearch.com/reference/features/web_interface.html) when you launch an instance in development mode so you can test our search engine right away. We have updated this interface so it's even easier to use (and nicer to look at)!

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

New telemetry page and simpler analytics settings
-------------------------------------------------

By default, Meilisearch collects anonymized data from all instances using our search engine. We have made it easier to [disable this behavior](https://docs.meilisearch.com/reference/features/configuration.html#disable-analytics) and [added a new page to our docs explaining exactly what data we collect and how we use it](https://docs.meilisearch.com/learn/what_is_meilisearch/telemetry.html). Privacy is an important issue for us, so please feel free to share any comments, concerns or suggestions you may have.

```javascript
$ ./meilisearch --no-analytics=true
```

Highlight matches in array and object fields
--------------------------------------------

Meilisearch v0.20 allowed you to [highlight matched search terms in string fields](https://docs.meilisearch.com/reference/features/search_parameters.html#attributes-to-highlight) so users could see where exactly a term was found within a document. In v0.21, we have extended this functionality to work with arrays of strings and nested objects. Like before, you can find the highlighted matches inside the `_formatted` object of each returned document.

```javascript
$ curl 'https://127.0.0.1:7700/indexes/movies/search' \
  --data '{ 
		"q": "adventure", 
    	"attributesToHighlight": ["title", "genres"] 
	}'
```

```javascript
{
  "id": "50393",
  "title": "The Adventures of Huck Finn",
  "overview": "Climb aboard for an extraordinary version of Mark Twain's sweeping adventure when Walt Disney presents The Adventures of Huck Finn, starring Elijah Wood.",
  "release_date": 733712400,
  "genres": ["Adventure","Family"]
  "_formatted": {
      "id": "50393",
      "title": "The <em>Adventures</em> of Huck Finn",
      "overview": "Climb aboard for an extraordinary version of Mark Twain's sweeping adventure when Walt Disney presents The Adventures of Huck Finn, starring Elijah Wood.",
      "release_date": 733712400,
      "genres": ["<em>Adventure</em>","Family"]
  }
}
```

Title and genre highlighted matches are available inside `_formatted`.

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

*   You might notice minor performance improvements in the indexer: this is a work-in-progress and we are eager to have your feedback on it
*   The `wordsPosition` [ranking rule](https://docs.meilisearch.com/learn/core_concepts/relevancy.html#ranking-rules) has been merged into `attribute`
*   `max-mdb-size` has been renamed to `[max-index-size](https://docs.meilisearch.com/reference/features/configuration.html#max-index-size)`
*   It is now possible to specify `[max-index-size](https://docs.meilisearch.com/reference/features/configuration.html#max-index-size)` and `[http-payload-limit-size](https://docs.meilisearch.com/reference/features/configuration.html#payload-limit-size)` using human-readable units such as `Kb` or `Gb`
*   We have removed the limit of 200 indexes per instance

Bug fixes
---------

*   Windows instances no longer immediately occupy the maximum index size on launch
*   The [ranking rule](https://docs.meilisearch.com/learn/core_concepts/relevancy.html#ranking-rules) `Words` now works as expected
*   [Dumps](https://docs.meilisearch.com/reference/features/dumps.html) now export all document fields correctly, regardless of whether they are present in `displayedAttributes`

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

A lot of this was made possible thanks to our community: we are honestly humbled by your generosity. Meilisearch is a better search engine because of you.

We want to send a special shout out to [@sanders41](https://github.com/sanders41) and [@bb](https://github.com/bb): your bug reports and feedback were super helpful!

Finally, a big thank you to [@shekhirin](https://github.com/shekhirin) for all the help with the new search engine implementation.

* * *

That's about it for this release! To have a full overview of all changes, breaking and otherwise, you can [check out our changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.21.0).

What’s new in v0.21

Today we are releasing the first release candidate (RC) of Meilisearch v0.21. This is the initial step towards the next version of Meilisearch, and a pretty important one given that it will be our first major release since March.

A big part of v0.21 will be relatively invisible to most end-users: our core team has been hard at work refactoring Meilisearch’s engine, something that is as time-consuming as it is crucial for the long-term health of our codebase. In this post, I want to go over why we decided to refactor Meilisearch, how that impacted our product, and where we’ll go from here.

We won’t be discussing everything that’s changed between v0.20 and v0.21—that’s for another blog post—but we will touch on several of the new features we are most excited about.

Why was refactoring needed?
===========================

We first realized that something was wrong when it became increasingly difficult for our core team to add new features without impacting performance. We could see our code was becoming more difficult to maintain, which is something particularly concerning for an open-source project: our community is our greatest ally and keeping code clean, readable, and pleasant-to-use is crucial if we want to keep our allies happy. We were clearly reaching the limits of what the previous codebase could offer us in terms of performance and ease-of-use, so we decided it was time for a change.

How did we do?
==============

We have a lot of good news—but, as with any major software release, there were some goals we weren’t able to attain.

### Search relevancy

The v0.21.0 will provide new ways to make your search more relevant:

*   You can now use numeric attributes as facets—think things like the price of a product or the release date of a book
*   This was actually requested by our users: the equivalent of Algolia’s `words` criterion [is now available](https://meilisearch.dev.org.tw/docs/learn/core_concepts/relevancy#1-words) in Meilisearch!
*   Phrase search: users can now force the engine to only return exact matches by enclosing query terms in double quotes (`"`)
*   Highlighting is now available for array and object values

### Search performance

Searching through huge datasets with Meilisearch has never been so fast! With a 1GB dataset containing around 115 million documents:

*   Queries that return many results are more than ten times faster: searching for a single letter takes less than 50ms in v0.21, compared with 2 seconds in v0.20
*   Similar speed gains when filtering on numbers: most searches take less than 50ms in v0.21

### Indexation

TLDR; indexation is now faster in most cases, but there are exceptions. Lots of room for improvement!

First, the good bits: indexation is globally faster with the refactored search engine.

Unfortunately, we noticed a loss of performance when parsing datasets with lengthy description values (think a list of blog posts or scientific articles with excerpts and abstracts) in v0.21. This is not a complete surprise: the new search engine requires more calculations, which means indexation might take more time. This is not ideal, but we would rather release something that’s not completely optimized than delay v0.21 and all the new features it will introduce. Rest assured, we are doing our best to improve indexation performance.

Another bit of bad news: while we have made significant steps in the right direction and reduced memory consumption across the board, the issue of Meilisearch sometimes crashing due to excessive memory usage has still not been fixed. This is another priority for us going forward.

### **Are there any breaking changes**?

There are indeed! We did our best to avoid breaking changes, but that’s not always possible when we want to keep improving things and making our API easier to use. The two biggest changes related to v.021’s refactoring are:

*   The parameters `filters` and `facetFilter` have been replaced by `filter`. Having two parameters doing almost the same thing added unnecessary complexity when filtering query results
*   Several naming changes that we believe make using Meilisearch more intuitive. None of these have any impact on the end-user experience. A full list will be available when we officially release v0.21

What’s next?
============

Once v0.21 is officially released some time within the next three months, we will return to our monthly release cycle. We are particularly looking forward to working on `sortBy` and geographical search—two features that are highly requested by our users. We hear you loud and clear!

If you are curious about Meilisearch’s upcoming version, feel free to test it and give us as much feedback as possible—we depend on you to catch as many remaining bugs as possible. You can [download the release candidate on GitHub](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.21.0rc0).

Also, a word of advice: we do not recommend using this RC in production. We are confident v0.21 RC1 is looking pretty good, but there are still issues that we need to work out before it is ready for the spotlight.

Thank you again, and see you soon for the official v0.21.0 release!

Refactoring Meilisearch: v0.21 has entered the chat

Announcing Meilisearch v0.13.0  

=================================

Meilisearch v0.13.0 introduces a bunch of new features and changes. Bugs have  
been fixed and some behavior have changed for more consistency, here what's new in meilisearch:

Placeholder search
------------------

  
We've been asked for a placeholder search feature a lot, and it's landed in  
v0.13.0. It allows you to perform a search without specifying query strings,  
and get "placeholder" search results. The results are sorted according to the  
ranking rules you specified, and it supports faceting and filtering.

Post Route search
-----------------

  
A new route has been added to allow you to perform search with a `POST` route instead of `GET`. This will improve performance for searches that require token  
authentication, by allowing [preflight request](https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request) caching.  
  
This is now the recommended way to perform searches with Meilisearch.

New settings behavior
---------------------

  
We have made a couple of changes to the way settings work in order to make them easier to use and intuitive. `searchableAttributes` and `displayedAttributes` now default to all attributes (`*` ). This means that unless you specify otherwise, all attributes will be searchable by default. This removes the need for the `acceptNewField`, that no longer exists.

Sys-info route removal
----------------------

  
We decided not to support the sys-info route anymore, and remove it. This was motivated by the fact that there already are better tools to do this job, and it was not worth the time maintaining this part of the code.

Check that Meilisearch is launched with the correct database version
--------------------------------------------------------------------

  
We added a check to ensure that Meilisearch is launched with a database that's compatible with the engine version. Meilisearch will refuse to start unless versions match.

Bug fixes
---------

*   `facetDistribution` returning the values in lowercase, instead of the correct case.
*   Bug that caused Meilisearch to add documents with the same document id twice, if they were added in the same batch.

Special thanks
--------------

  
We'd like to give a special thank to our external contributors on this release.  
Their involvement means a lot to us!

*   [@balajisivaraman](https://github.com/balajisivaraman) for his help on making our tests faster and cleaner
*   [@Rio](https://github.com/Rio) for his work on authentication and analytics
*   [@aeriksson](https://github.com/aeriksson) for finding and fixing typos in our code

If you feel like contributing, and don't know where to start, ping us on [slack](https://slack.meilisearch.com/).

What's new in 0.13.0

The v0.11 version of Meilisearch introduces a highly anticipated feature: **faceted search**. Every modern search experience includes faceted search. We were eager to offer this experience to our users, and we are excited to have finally achieved this critical step.

Faceted search
--------------

If you're not familiar: Faceted search lets you search by including or excluding some attributes from categories called facets. You have probably come across faceted search during your online consumerist life. It is often presented as a sidebar with checkboxes. Giving me, as a woman, the possibility to show only 8.5 size shoes and see my possible choices decrease to oblivion.

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

In this case the facet is `size`, the attribute is `UK 8 ½`, and the number of products found `2`

Faceted search is not easy to understand. It is often confused with Filters. However, filtering is used to filter the returned results by adding constraints. **Facets**, on the other hand, are used to categorize the data into subsets that will be searched upon: **they reduce the number of documents to process**.

We didn’t see any reason to reinvent the wheel; if you’re familiar with how Algolia does facets, you’ll see we’ve gone with a very similar API. We improved a bit on the usage to reduce furthermore all possible friction in the hope that it is accessible for all users.

To set up faceted search, only two steps are required:

**Add facets in the settings**. For an attribute to be used as a facet it must be added in the `attributesForFaceting` list.

```bash
$ curl \
  -X POST 'https://127.0.0.1:7700/indexes/movies/settings' \
  --data '{
      "attributesForFaceting": [
          "director",
          "genres"
      ]
  }'
```

**Declare** director and genres as **facets**.

**Use facets during search**. By using the query parameter `facetFilters` it is possible to add the chosen facets attributes to narrow down the results:

```bash
$ curl --get 'https://127.0.0.1:7700/indexes/movies/search' \
    --data-urlencode 'q=Get' \
    --data-urlencode 'facetFilters=["director:Jordan Peele"]'
```

Search for movies by a specific director

This is all explained in our [guide on Faceting](https://docs.meilisearch.com/reference/features/faceted_search.html#faceted-search).

SSL support
-----------

All the configuration options to enable SSL are now available.

[Learn more about it in our configuration guide.](https://docs.meilisearch.com/reference/features/configuration.html#ssl-authentication-path)

Max payload size
----------------

In the early versions of Meilisearch, there was no limit to the size of the body Meilisearch accepted. This version introduces the standard default limit of a **maximum payload of 10 Megabytes** and the possibility of changing the limit.

```bash
$ ./meilisearch --http-payload-size-limit=107374182400
```

Change the upload limit to 100 Megabytes

Improved analytics
------------------

To further understand how our users use Meilisearch and how to improve it, more analytics are added.

[A complete list can be found here.](https://docs.meilisearch.com/reference/features/configuration.html#analytics)

Users can deactivate analytics by using the following command line option:

```json
$ ./meilisearch --no-analytics
```

Conclusion
----------

Those are the main changes in this version. For a more thorough list, please visit the [changelogs of this version](https://github.com/meilisearch/MeiliSearch/blob/master/CHANGELOG.md#v011).

We are eager to hear some feedback. Feel free to come and [talk to us any way you prefer](https://docs.meilisearch.com/learn/what_is_meilisearch/contact.html). We are thrilled by all the support given to our search engine and the never-ending growth in users and stars.

Thanks a lot,

The Meilisearch team and the girl with big feet. 🦶

####

Meilisearch v0.11: What’s new?

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://127.0.0.1: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.21 版本的新功能

重構 Meilisearch：v0.21 版本已加入討論

0.13.0 版本的新功能

Meilisearch v0.11：新功能有哪些？

Meilisearch v0.9：新功能有哪些？