We knew it was only the beginning of our 4-day offsite when we boarded the train to Brittany. But little did we know it was only the beginning of our foray into strange and delightful vehicles.

Our hotel was on the coastal path, offering a beautiful sea view from the restaurant lounge. It could have been enough—but would it have been worth it had the offsite been too demanding on our team members? At Meili, we believe in prioritizing the well-being of our employees. As a [mainly remote company](/blog/remote-work-is-the-future-of-work/)he offsite is more than a break in our daily routine. It’s also the chance to meet all the team members who could make it in real life. However, we believe it’s our responsibility as a company to provide a safe environment to everyone, especially during offsites. Our core values are carefully reflected each step of the way, structurally and from workshops to team-building activities.

Upholding our values during an offsite
--------------------------------------

At Meilisearch, [we are committed to upholding our values](/blog/advice-on-answering-interview-questions-about-values/)e are constantly striving to improve on an individual and organizational level. An offsite is a perfect opportunity to educate ourselves collectively on skills that are important to us.

On our second day during this offsite, we attended a workshop about unconscious bias. We believe all companies must be watchful of these stereotypes; they can affect how we recruit, include, and support team members. The practical questions and situations were very relevant to see how quickly we can rely on stereotypes to make decisions and how we could mitigate these effects. Some of the actions are as easy as involving other people! We are more committed than ever to ensuring our decision process involves feedback from team members from different jobs at Meilisearch and different backgrounds.

During this 4-day week, we attended another workshop: the [Climate Fresk](https://climatefresk.org/). The goal was also to identify some actions we could take, individually and as a company in the tech industry. One of the first actions we have to take is to educate ourselves about the fundamental science behind climate change—that workshop was a beginning, and we now have to pursue our efforts, for example, with our servers.

Throughout the offsite, we cater to different preferences and needs. This means being comfortable with a loser schedule and allowing our team members time and space to go at their rhythm. For example, we choose to allow separate rooms for each person. We’ve found it makes a huge difference in our energy level, and our team members get to the end of the offsite with less mental fatigue.

We also give people free time each day to spend as they wish, whether exploring the local area, going to the hotel spa, chatting with people, or simply recharging their batteries.

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

Picture by Ingrid Hazan

One of our core values is to learn from feedback. The offsite is no exception: we ask questions after each offsite to see what we did well and what to work on for the following offsites. Measuring how we do is our way to ensure that everyone's needs are met. This is a plea to all hotels: we need more veggie and vegan qualitative options during meals!

Supporting a positive and safe team-building
--------------------------------------------

At Meili, we believe in the power of teamwork. Our [collaborative approach](/blog/how-meilisearch-built-upon-42-collaborative-approach/)s at the heart of our company. At the question “What was your favorite thing about the offsite?”, most people say it was chatting with other team members.

This is why we organize low-stakes team-building activities. A loose structure helps people to bond and get to know each other better without taking away the spontaneity of the connection. We want people to have fun without feeling pressured to perform. As such, they can opt out of activities before the offsite.

We asked every team member to write a short anecdote about themselves before the offsite, printed them, and distributed them randomly to other team members. It served as a great ice-breaker and conversation starter on Tuesday evening!

On our first day, we went on a pedestrian treasure hunt in the Corsair city of Saint-Malo. Though we had to rush to make all the spots, it was a great way to explore the city with a squad of people we don’t usually work with. It’s a shame to go to a beautiful place only to spend all our time in a meeting room.

![Photo of rocks in the sea, with a tiny island in which there’s a house, surrounded by fortification walls.](https://unable-actionable-car.media.strapiapp.com/Bretagne3_3bb3447be8.jpg)

Picture by Ingrid Hazan

We had a blast building our cardboard karts on Wednesday afternoon. We had the blueprints, sheets, and cardboard tubes, and there we went! Each team did their best to build, decorate and name their cars. Each kart had its personality and backstory. The presentation speeches were a highlight of our offsite! We had a race to determine which was the fastest kart. I’m afraid I must report we suffered heavy losses and some cars didn’t make it—but they are always in our hearts!

![A white kart made all in cardboard on the road in front of trees. The kart sides are decorated with bone shapes.](https://unable-actionable-car.media.strapiapp.com/kart_379654d107.jpg)

Picture by Roxane Beaufils

Ultimately, we see ourselves as the vessel for a fantastic team to come together and create something special. Like the cars we build during our offsite activities, we provide the structure and the elements, but our team makes the jazz and soul of Meilisearch. We wish to thank the team of [Gloria](https://www.gloriaforbusiness.com/) with whom we worked on the workshops and the team of [Kymono Life](https://www.kymonolife.co/), with a special thanks to Anaïs who organized the offsite for us.

How to organize a people-first offsite

Search bars are an integral part of browsing the web. Whether we are shopping for clothes, enjoying music, or planning a vacation, there is always a dedicated search engine at work to simplify our lives. Have you ever wondered how these search engines actually work? In this article, we will delve into the inner workings of one of them: [Meilisearch](https://meilisearch.com).

Indexing time: from data to documents
-------------------------------------

Indexing is a fundamental process that encompasses the collection, parsing, and storage of data for subsequent retrieval. It plays a crucial role in enabling search engines to deliver fast and relevant results.

### A performant storage engine

Meilisearch stores data in the form of discrete records called "[documents](https://docs.meilisearch.com/learn/core_concepts/documents.html)," which are grouped together into collections known as "[indexes](https://docs.meilisearch.com/learn/core_concepts/indexes.html)." Under the hood, Meilisearch uses the LMDB ([Lightning Memory-Mapped Database](http://www.lmdb.tech/doc/)) key-value store which has proven stability and extensive usage in database applications. As the name implies, key-value stores are storage systems that organize data as a **collection of key-value pairs**.

![Illustration of a key-value store with 'engine' set to 'meilisearch' and 'language' set to 'rust'](https://unable-actionable-car.media.strapiapp.com/key_value_store_d2a8b6ff55.png)

Example of key-value entries

Key-value stores offer flexibility, fast access times, and efficient performance, contributing to quick and responsive interactions for users. By permitting only a single writing process at a time, LMDB avoids synchronization-related issues. As a result, it enables unlimited concurrent readers to have fast access to up-to-date, consistent data.

Before storing data in its key-value store, Meilisearch must preprocess it thoroughly. That’s where tokenization comes in.

### From words to tokens

**Tokenization** involves two main processes: segmentation and normalization.

**Segmentation** consists in splitting a sentence or phrase into smaller units called tokens.

Meilisearch uses (and maintains) the open-source tokenizer named [Charabia](https://github.com/meilisearch/charabia). The tokenizer is responsible for retrieving all the words (or tokens) from document fields.

<Callout>
  In practice, Meilisearch users can configure which fields should be [searchable](https://www.meilisearch.com/docs/learn/configuration/displayed_searchable_attributes#searchable-fields), allowing Charabia to know which fields should be tokenized.
</Callout>

Then comes **normalization**. Words are normalized based on each language’s particularities. For a romance language like French, this process includes setting the word in lowercase letters and removing diacritical marks such as accents. For instance, a sentence like “Le café de Nicolas” is transformed into “le cafe de nicolas”.

![The sentence 'Le café de Nicolas,' with a capital 'L' and 'N,' and an accent on the 'é' of 'café,' is first split into words during the segmentation phase. Then, during normalization, each word is lowercased, and accents are removed.](https://unable-actionable-car.media.strapiapp.com/Tokenisation_3_ea1333d3a3.png)

Example of the segmentation and normalization stages in the tokenization process

After segmenting and normalizing words, the engine needs to classify them. Using the appropriate data structure to organize tokens is crucial for performance. This will later allow swift retrieval of the most relevant search results.

### Storing tokens

Modern full-text search engines like Meilisearch come with features such as prefix search, typo tolerance, and geo search. Each data structure has its own advantages and disadvantages. When designing the search engine, our team carefully selected the ones best suited to enable these features without compromising on speed.

Throughout this section, we will explore which data structures powers Meilisearch.

#### Inverted index

First and foremost, we need to talk about inverted indexes. Without a doubt, it’s the data structure that stands out by its importance. Meilisearch uses it to return documents fast upon search.

An **inverted index** maps each word in a document to the set of documents where that term appears along with additional information like their position in the document.

![Given the following documents: `{   “id”: 1   "title": "Hello world!" }, {     “id”: 2     "title": "Hello Alice!" }.  The inverted index would look like this:  "alice" -> [2], "hello" -> [1,2],  "world" -> [1]` ](https://unable-actionable-car.media.strapiapp.com/Inverted_index_3_edcd06ad15.png)

Illustration of an inverted index generated from given documents, showcasing the mapping of keywords to document IDs

By storing words once and associating them with the documents where they appear, inverted indexes leverage the redundancy of terms across documents. Thanks to this, Meilisearch does not need to browse all documents in order to find a given word, resulting in faster searches.

Meilisearch creates approximately 20 inverted indexes per document index, making it one of the data structures with the highest number of instances. Indeed, to provide a search-as-you-type experience, the engine needs to precompute a lot at indexing time: word prefixes, documents containing filterable attributes, and more. For a better understanding of how inverted indexes work read more on [indexing best practices](/blog/best-practices-for-faster-indexing/

<Callout>
  You can find the complete list of Meilisearch inverted indexes [on GitHub](https://github.com/meilisearch/meilisearch/blob/78e611f282d726a604cfbc231666265a37c4d46b/milli/src/index.rs#L103-L157).
</Callout>

#### Roaring bitmap

**Roaring bitmaps** are compressed data structures designed for efficiently representing and manipulating sets of integers.

Meilisearch uses roaring bitmaps widely throughout its inverted indexes to represent document IDs. Roaring bitmaps offer a space-efficient way to store large sets of integers and perform set operations like [union, intersection, and difference](https://en.wikipedia.org/wiki/De_Morgan%27s_laws). These operations play a crucial role in refining search results by allowing the inclusion or exclusion of specific documents based on their relationship with others.

#### Finite-state transducer

A finite-state transducer (FST) is a structured data representation ideal for performing string-matching operations. It represents a sequence of states ordered from smallest to largest, with words arranged in lexicographic order.

<Callout>
  [Lexicographic order](https://en.wikipedia.org/wiki/Lexicographic_order) is a method of arranging or sorting items, such as words or symbols, based on their alphabetical or numerical sequence.
</Callout>

A finite-state transducer is also called a _word dictionary_ because it contains all words present in an index. Meilisearch relies on the utilization of two FSTs: one for storing all words of the dataset, and one for storing the most recurrent prefixes.

FSTs are useful because they support compression and lazy decompression techniques, optimizing memory usage and storage. Additionally, by using automata such as regular expressions, they can retrieve subsets of words that match specific rules or patterns. Moreover, this enables the retrieval of all words that begin with a specific prefix, empowering fast, comprehensive search capabilities.

The FST, with its compact design, presents the added advantage of being a smaller data structure than the inverted index. As we will see later, this contributes to faster and more efficient reading operations. You can learn more about the topic in this [comprehensive article on finite-state reducers](https://blog.burntsushi.net/transducers/).

#### R-tree

R-trees are a type of [tree](https://en.wikipedia.org/wiki/Tree_\(data_structure\)) used for indexing multi-dimensional or spatial information. Meilisearch leverages R-trees to power its geo search functionality.

The **R-tree** associates geographical coordinates with the identifiers of the document to which it belongs. By organizing coordinates this way, it enables Meilisearch to perform spatial queries with remarkable efficiency. These queries allow users to find nearby points, points within a specific area, or points that intersect with other spatial objects.

Search time: query processing
-----------------------------

Modern search experiences only require you to start typing to get results. To achieve this search-as-you-type experience, Meilisearch precomputes a list of the most frequent prefixes.

To be tolerant to typos, Meilisearch uses finite-state transducers in conjunction with the [Levenshtein algorithm](https://www.meilisearch.com/docs/learn/configuration/typo_tolerance#understanding-typo-calculations). This algorithm calculates the Levenshtein distance which can be thought of as the cost of transforming a string into another. In other words, it quantifies the number of transformations required for a word to be converted into another word.

In the context of the Levenshtein algorithm, possible transformations are:

*   insertions, e.g. hat -> chat
*   deletions, e.g. tiger -> tier
*   substitutions, e.g. cat -> hat
*   transpositions or swaps, e.g. scared -> sacred

FSTs generate all possible variations of a word within a specified edit distance, enabling the engine to calculate the Levenshtein distance and accurately detect typos by comparing user input against a dictionary of valid words.

It becomes apparent that there are many factors to consider when processing a search request. Has the user finished typing? Are there typos in the query? Which documents should appear first in the search results?

Let’s discuss how Meilisearch processes search queries and how it refines and sorts search results.

### Query graph

Each time it receives a search query, Meilisearch creates a query graph representing the query and its possible variations.

To compute these variations, Meilisearch applies [concatenation](https://www.meilisearch.com/docs/learn/advanced/concat#concatenated-queries) and [splitting](https://www.meilisearch.com/docs/learn/advanced/concat#split-queries) algorithms to the query terms. The variations considered also include potential typos and synonyms–if the user set them. As an example, let’s examine the query: `the sun flower`. Meilisearch will also search for the following queries:

*   `the sunflower`: concatenation
*   `the sun flowe**d**`: substitution
*   `the sun flower**s**`: addition

Consider now a more complex query: `the sun flower is facing the su`, the query graph should look like this:

![Graph representing interpretations of the search query 'the sun flower is facing the su'. The engine precomputes for each query term word variations, like 'flowed' or 'flowers' and the associated Levenshtein cost ](https://unable-actionable-car.media.strapiapp.com/debuggong_image_e0a6ce757c.png)

Visual generated using our internal debugging tool, powered by [D2](https://github.com/terrastruct/d2), showcasing the execution process of search requests

As illustrated above, the graph represents different interpretations of the search query. The engine precomputes the word variations (and their cost) for each query term. Moreover, it detects whether the last query term is a prefix (not followed by a space), thus signaling the need to consult the prefix database.

So how does the engine utilize a query graph?

As we saw earlier, during the indexing process, Meilisearch identifies all documents that have filterable attributes, such as `genre`. Subsequently, it generates a list of document IDs associated with each attribute value, like `comedy` or `horror`. First of all, when a filter is applied, Meilisearch narrows down the potential results to the document IDs that fulfill the filter criteria.

Next, it uses the query words and the variations generated in the query graph and searches for matching words in the finite-state transducer (that is, our word dictionary). If the word is considered a prefix, it will also look it up in the prefix FST.

When encountering words in a FST, it searches them within the inverted index—which contains a mapping of words to document IDs— to retrieve the corresponding document IDs.

Finally, the engine performs an intersection to identify the documents that contain the words in the query graph and meet the filter criteria.

Let's take an example to better understand query processing: suppose you have a dataset of songs. The search query is `John Lennon`. The user wants to retrieve only songs released between 1957 and 1975.

First, Meilisearch retrieves the document IDs of songs within that time frame. Then, after checking in the FST that the words in the query graph exist, Meilisearch retrieves the IDs of the documents that contain either `John`, `Lennon`, or both. It also retrieves the possible variations, but we are not including them in this example for the sake of simplicity.

![Three Venn diagrams illustrating the process of retrieving songs released based on a user query (John Lennon) with a date filter (between 1057 and 1975).  Diagram 1: Represents songs released between 1957 and 1975. Diagram 2: Represents songs with "John" and/or "Lennon" in the title. Diagram 3: Represents the intersection between the two previous diagrams.](https://unable-actionable-car.media.strapiapp.com/diagrams_2_ac89ed0fa9.png)

Diagrams illustrating the operations involved in retrieving documents based on a user query.

Finally, the intersection of the two sets of document IDs is taken (the purple area in the diagram.) This means only document IDs that appear in both sets are kept. In other words, Meilisearch retains the document IDs of songs released between 1957 and 1975 that contain either `John`, `Lennon`, or both.

What happens when several documents match the search query, how does the engine decide which one to return first? Which one is more relevant? Let's explore the rules allowing Meilisearch to determine how to rank results.

### Relevancy

As we discussed earlier, the query graph includes possible variations of words. As a result, Meilisearch will also return documents with an artist, such as _John_ _Lebon_, as part of the search results.

Fortunately, the query graph not only accounts for word variations but also assigns them the Levenshtein cost, which, among other factors, helps Meilisearch determine the relevancy of the search results.

Meilisearch sorts documents in the search results using [bucket sort](https://en.wikipedia.org/wiki/Bucket_sort). This algorithm allows ranking documents based on a set of consecutive rules. By default, Meilisearch prioritizes rules as follows:

1.  Words: sorts documents based on the number of matched query terms, with documents containing all query terms ranked first
2.  Typo: sorts documents based on the number of typos, with documents matching query terms with fewer typos ranked first
3.  Proximity: sorts documents based on the distance between matched query terms. Documents where query terms occur close together and in the same order as the query string are ranked first
4.  Attribute: sorts documents based on the ranking order of attributes. Documents containing query terms in more important attributes are ranked first. Documents with query words at the beginning of attributes are considered more relevant than those with query words at the end
5.  Sort: sorts documents based on the user-defined parameters set at query time, if active
6.  Exactness: sorts documents based on the similarity of matched words with the query words

Meilisearch applies these rules sequentially, sorting results step by step. If two documents are tied after one rule, it uses the next rule to break the tie.

<Callout>
  Note that these rules are fully customizable, meaning you can add, delete, and reorder them as needed. Read more in the [relevancy documentation](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#ranking-rules).
</Callout>

By default, Meilisearch returns up to 1000 documents per search, prioritizing delivery of the most relevant results rather than all matching results. In other words, Meilisearch prioritizes efficiency and relevance over exhaustive results to ensure an optimized search experience.

Conclusion
----------

Search engines are complex systems that encompass multiple interconnected components, all working together to deliver a seamless search experience. While the inner workings may differ among search engines, we have explored the underlying mechanisms that power a modern search engine.

Meilisearch is currently exploring the vast realm of [**semantic search**](https://github.com/meilisearch/meilisearch/issues/3838). **AI-powered search** is reshaping the way we understand queries and documents, opening up new possibilities and use cases. If you’re eager to experience it firsthand, we invite you to try our [vector search prototype](https://github.com/meilisearch/product/discussions/621#discussioncomment-6183647)—your feedback would be greatly valuable!

Meilisearch is an open-source search engine that not only provides state-of-the-art experiences for end users but also a simple and intuitive developer experience. Do you want to see Meilisearch in action? Try our [demo](https://where2watch.meilisearch.com/?ref=blog.meilisearch.com). You can also [run it locally](https://www.meilisearch.com/docs/learn/getting_started/quick_start?ref=blog.meilisearch.com) or create an account [on Meilisearch Cloud](https://cloud.meilisearch.com/login?ref=blog.meilisearch.com).

For more things Meilisearch, you can join the community on [Discord](https://discord.gg/meilisearch/?ref=blog.meilisearch.com) or subscribe to the [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e&ref=blog.meilisearch.com). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in [product discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).

How to deliver the best search results: inside a full text search engine

  
Hello, have you met Paul?
----------------------------

Today and for the third time, we’re very happy to share another one of our Meilistars interviews! The Meilistars are some of our top contributors, they all have a plethora of experience they kindly agree to share with us.

The Meilistar we’d like to shine our spotlight on in this article is Paul Sanders, or [sanders41](https://github.com/sanders41), as you may know him on GitHub! Paul has worked in various positions throughout his tech career, for instance he was a data manager as well as a software engineer.

Aside from that, Paul also enjoys spending his free time working on open-source software, both as a maintainer and contributor, which is how he got involved with Meilisearch.  
  
We were curious to know whether someone had mentioned the project to him or if he discovered us by himself:

> “I stumbled upon it. I believe it was Twitter where I saw it mentioned and it sounded like an interesting project. Looking through the repo on GitHub I saw some open issues that I knew how to fix and have been contributing ever since.”

We’re grateful he found his way to Meilisearch! We then wondered on the reasons that motivated him to keep on contributing all this time:  

> “The way Meilisearch does open source makes it a great project to contribute to, regardless of the repo. With a lot of other open source projects it's not unusual to have PRs sit for weeks before getting any review, then there are several weeks between each review. I've even had PRs sit for almost two years before getting reviewed on some projects. With Meilisearch the team is good about getting reviews done and seems to really appreciate the help. After contributing for so long the team there know me and I know them which also makes new contributions easier.”  

Upon first discovering us, Paul felt like Meilisearch and Elasticsearch were quite similar but that Meilisearch was easier to set up and maintain, which was interesting to him then.  
  
When asked about how Meilisearch today holds up in comparison to Meilisearch at the time, Paul shares:

> “The biggest difference I see from when I first found Meilisearch to now is all the work that has gone into indexing. Work done on indexing speed and batching of jobs have been big improvements. One difference that I haven't used myself, but I see a lot of talk about and seems to be a popular addition is the addition of geo search.”

We were delighted to hear his positive feedback, and we wondered if there was anything he’d noticed could be improved upon:

> “One thing that would be nice is some kind of configuration file for the settings. This is especially true for development when you are frequently starting fresh. What I have done for this so far is created a startup script that runs and updates the settings, but it would be nice to have a configuration file to do this.”

We’re very grateful for his feedback since Paul is such an experienced contributor.

A career in tech
----------------

Indeed, on top of contributing to Meilisearch on the regular, he worked, up until recently, for his former’s company’s open source [Fides projects](https://github.com/ethyca/fides). Fides is an open-source privacy engineering platform made to manage the fulfillment of data privacy requests and the enforcement of privacy regulations in code. And that’s without mentioning his personal projects:

> “ From my own projects the one that Meilisearch people may find interesting is Meilisearch [Python Async.](https://github.com/sanders41/meilisearch-python-async) As the name implies it is an SDK like Meilisearch Python, but for code bases using asyncio.”

  
During his time contributing to Meilisearch, Paul mentions he hasn’t had the chance to talk much with his fellow contributors outside of PRs. However, he would be keen to change that! Especially for anyone looking for a mentor:

> “Most of my time these days is spent in Python so if there is anyone that wants to get started with Meilisearch using Python, or contributing to the Python SDK and has any questions they can reach out to me and I'd be happy to help.”

With his extensive experience, we are sure he can provide valuable insights and guidance, so don't hesitate to reach out to him.  
  
Knowing that Paul works in tech, we wondered whether or not he’s had the chance to use Meilisearch in a professional environment:

> “I was building a system at a previous job where I was using Meilisearch, but ended up moving to a new job at a different company before it was finished. The idea in that system was in clinical trials there is a lot of free text data, audit trails and communications being a few examples. Because this was free text there was traditionally no good way to search this data (typos, misspellings, etc.) so people just had to know that the data existed and where to find it. With typo tolerance in Meilisearch I finally had a way to do it.”

  
And on his free time?
------------------------

Aside from his work, Paul also tells us a bit more about the way he uses Meilisearch for a pet project of his.

> “I am currently working on a personal project where I plan to use Meilisearch. My sister is a school teacher and she has been having me help her with some tracking data the school systems have to do on students. They are currently using Google Sheets to do this, and there are multiple issues with this in my view. For one it just wasn't made to do what they are trying to do, and for two each student is his/her own file so there is no way to search across students. How far this one goes depends on how interested the school system is in solving their pain point.”

As a final thought, Paul also shares with us an alternate way to look at Meilisearch:

>   
> “ I feel like a lot of times Meilisearch only gets looked at for it's ability to search through millions of records because that is impressive and has the "wow factor". I think there is a potential to bring a lot of value in using Meilisearch for much smaller datasets also. Manually searching through even hundreds of records is not something people are going to do, and with Meilisearch being so easy to setup I think this is a missed opportunity for people in these situations. ”

  
We’d like to extend a warm thank you to Paul for his time and candor during this interview. Don’t hesitate to check out more of our Meilistars interviews and the future ones as well!

Paul Sanders: an open-source veteran among the Meilistars

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://www.meilisearch.com/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://www.meilisearch.com/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](http://meilisearch.com/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://www.meilisearch.com/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](http://meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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://www.meilisearch.com/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?

[Minipouce.fr](https://www.minipouce.fr/) is an online platform that enables future parents to create a baby registry list, which is a list of items that parents-to-be would like to receive as gifts. With the help of a multi-brand catalog featuring over 150,000 products, Minipouce.fr aims to make navigation intuitive and incredibly smooth for its users, ensuring everything is easy to find.

**By opting for Meilisearch as the search backbone of its marketplace, Minipouce.fr is able to maintain its commitment to delivering the best possible user experience.**

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

<Callout>
  __"As a user, it felt like magic compared to other solutions I've tried. I'm not sure whether it's related to how typo tolerance works or to the default configuration. Still, right after setting up Meilisearch with no particular tweaks, I got fantastically relevant results." - Anthony Catel, Co-founder of__ [__Minipouce.__](https://www.minipouce.fr/)
</Callout>

### Challenge

As parents themselves, the cofounders of Minipouce.fr were very familiar with the struggles faced by new parents. It's crucial to create a multi-brand baby registry checklist to enable friends and relatives to shop from various distributors in a single location, rather than being confined to one sole provider.

Launching a new marketplace is a complex task: you need to generate enough traffic to convince distributors to list their products in the first place. On the other hand, you need a diverse and extensive catalog in order to attract customers and drive that traffic.

For Anthony Catel, the co-founder and head of engineering, it was clear that Minipouce.fr needed to offer a competitive and high-quality user experience right from the beginning. It is important to enhance the search functionality for a platform like Minipouce.fr: more relevant search results leads to increased user purchases, which in turn allow Minipouce.fr to collect an affiliate percentage fee from every product purchase originating from its platform. To achieve this, the technology behind the platform needed to be top-notch and enable quicker and smoother product selection by incorporating layers of meaning to accommodate various search terms users might use.

To add to the complexity, each retailer tends to use different formats for its product catalog, which results in mismatched and missing information that Minipouce.fr then needs to address. Synonyms also play a crucial role as one product can have multiple names, and customers may only be familiar with one of them. Without the search accounting for all potential synonyms, users may not find the right products.

All such intricacies needed to be addressed with the help of the most appropriate search solution.

### Why Minipouce.fr chose Meilisearch  

1.  **Higher out-of-the-box relevancy**

At the very beginning, Minipouce.fr considered using Algolia but couldn't find an appropriate plan that would accommodate a young, rapidly growing platform. While searching for an alternative, Anthony discovered Typesense and conducted extensive testing on it. After an initial set of tests, he decided to continue searching for another solution that could offer higher relevance in search results compared to Typesense. Eventually, Minipouce.fr came across Meilisearch and found that its default configuration demonstrated **higher relevancy in search results** than Typesense during the testing phase, without requiring any additional tweaks.

2\. **Lower maintenance**

Anthony chose not to consider ElasticSearch or similar solutions due to his desire to avoid managing numerous Java dependencies. Furthermore, he was drawn to Meilisearch's open-source platform, which operates on **Rust, a modern language in comparison to the C++** predominantly used by its competitors. This choice resulted in less time spent on debugging and infrastructure maintenance, a crucial factor for a smaller-sized team.

3\. **Meilisearch’s support and services bolster its open-source offering**

With high business stakes and the quality of search results being central, Minipouce.fr sought a solid, well-maintained solution. With Meilisearch’s open source engine, the organized handling of tickets and commits hinted at an established business backing it.

### Implementation

Today, Minipouce.fr is using Meilisearch to fully power the entire website. The migration of the marketplace from Typesense to Meilisearch's offering was completed within half a day, making it a quick and efficient process. Anthony particularly appreciated the availability of different SDKs in multiple programming languages, including a Python SDK. This feature made Meilisearch a natural addition to his tech stack, as it facilitated the setup of the platform without requiring additional resources.

To further optimize the search experience, additional tweaks are implemented using Meilisearch. This includes sorting functions that prioritize certain items in the catalog based on popularity. Updates are pushed in real-time, ensuring the search results are always up to date.

### Results

[Minipouce.fr](https://www.minipouce.fr/) was delighted with the **seamless integration and low maintenance requirements of Meilisearch**, thanks to its default configuration working effectively from the start. The relevancy of the search results was impressive, surpassing the performance of other tested alternative solutions. On top of that, since the implementation of Meilisearch, Minipouce.fr has observed a 5x growth in search volume across its platform.  

Looking ahead, Minipouce.fr envisions even greater possibilities, such as the implementation of vector search, which would enable intelligent connections between searches, further enhancing search experience. Considering the future, Minipouce sees the potential benefit of migrating to Meilisearch's Cloud offering to outsource the infrastructure maintenance, allowing for greater efficiency and scalability.

Minipouce.fr provides a top-grade customer experience with Meilisearch's open-source offering

Full text search refers to matching some or all of a text query with documents stored in a database. Compared to traditional database queries, full text search provides results even in case of partial matches. It allows building more flexible search interfaces for users, thus enabling them to find accurate results more quickly.

From simple in-app search to browsing huge ecommerce catalogs, full text search use cases are numerous. It is so common that Postgres and other relational databases include dedicated APIs for full text search. Unfortunately, Postgres falls short of search-focused databases in multiple areas.

1\. Complex setup
-----------------

To provide relevant results, full text search should tolerate typos, allow synonyms, and allow partial matches. Additionally, results ranking needs to be highly customizable to adapt to a business’s specific needs. Configuring full text search on Postgres comes at the cost of [comprehensive configuration](https://rachbelaid.com/postgres-full-text-search-is-good-enough/) and often requires extensions that can’t be used when using managed Cloud services.

Creating database indexes, writing queries, and ranking algorithms quickly overstep domain knowledge and demand expertise in searching, indexing, and linguistics. Optimizing for performance gets even harder when working around constraints from mixed-and-matched extensions aimed at coping with Postgres full text search limitations.

Conversely, a search-focused database comes with [state-of-the-art features](https://www.meilisearch.com/docs/learn/what_is_meilisearch/overview#features) like typo tolerance, prefix search, fuzzy matching, synonyms, and customizable rankings out of the box.

2\. Faceted search
------------------

[Faceted search](https://www.meilisearch.com/docs/learn/fine_tuning_results/faceted_search) allows users to refine search results by broad categories. It’s often used in ecommerce applications. For example, a clothing shop can implement filtering by facets such as brand, size, or rating range.

[![Faceted search on an ecommerce website](https://unable-actionable-car.media.strapiapp.com/ecommerce_demo_4_final_1_48b9d742ac.gif)](https://ecommerce.meilisearch.com/)

Faceted search on an ecommerce website ([see demo](https://ecommerce.meilisearch.com/))

Implementing filtering is tricky enough for a single facet. But facets can take many shapes: category tags, price ranges, or minimum rating. Implementing filtering for all types is very challenging. By all means, the trickiest query to implement is aggregating results to build facet counts. This becomes very resource intensive on large datasets.

The complexity of implementing faceted search with Postgres grows exponentially with the number of facets. Faceted search alone makes a strong selling point for search engines like [Elasticsearch or Meilisearch](/blog/why-should-you-use-meilisearch-over-elasticsearch/)hey come with optimized, first-class APIs to handle facets filtering and counting.

3\. Typo tolerance
------------------

By default, Postgres full text search cannot handle misspellings. Users commonly install the `pg_trgm` extension to work around this limitation. (Again, this solution is not always available in managed Postgres.) This extension notably introduces new operators to compare similarity between strings along with search-optimized GIN and GIST indexes.

The new indexes allow more configuration for full text search, but choosing between GIN and GIST indexes is not always trivial. Moreover, the new operators do not take into account word proximity, space separators, or word size. This, in particular, makes it hard to achieve real fuzzy matching with Postgres.

Ideally, a search-focused database should allow configuring different rules for single versus multiple words queries. It is the case of Meilisearch, which allows disabling typos entirely for specific fields. This enables users to search via unique identifiers like a book’s _International Standard Book Number_ (_ISBN_).

[![Example of typo tolerance](https://unable-actionable-car.media.strapiapp.com/typo_tolerance_2_gif_4409419422.gif)](https://typo-tolerance.meilisearch.com/)

Typo tolerance is disabled for the ISBN field ([see demo](https://typo-tolerance.meilisearch.com/))

4\. Language support
--------------------

Linguistic specificities vary a lot between languages using the Latin alphabet and others like Arabic or Chinese. As of Postgres 15, full text search dictionaries are unavailable for Simplified and Traditional Chinese, Korean, and Japanese, among others. This means resorting to specific implementations for different languages.

<Callout>
  To see the [list of languages supported by Postgres full text search](https://gist.github.com/Strift/3155b9238bac6495d4cd57b83d78415f), you can run the \`\\dFd\` command in Postgres.
</Callout>

Language support constraints are amplified in managed environments like Amazon RDS where users are unable to access the filesystem. This restricted access prevents them from implementing custom dictionaries, stemmers, synonyms, and more.

Meilisearch comes with [optimized language support](https://www.meilisearch.com/docs/learn/what_is_meilisearch/language) for Chinese, Japanese, Korean, Hebrew and more, on top of all languages using whitespace to separate words.

<Callout>
  Thanks to its vibrant open-source community, Meilisearch benefits from native speakers' contributions to [improve language-specific features](/blog/improving-meilisearchs-language-support/)
</Callout>

5\. Paying the backend price
----------------------------

Postgres is a database intended to communicate with server-side languages. When building a public-facing client application, it means building an API on top of the database to communicate with clients. On top of additional development time, creating such a proxy entails further problems.

First comes the issue of latency: making requests to an API that queries the database before returning results is bound to take some time. This does not affect dedicated search engines, as they come with a public API intended to deliver data to end users.

Now comes the second issue: security. Search engines APIs are designed, from the start, for public consumption. And security’s baked in for that use case. By default, API keys restrict search requests, while advanced features like [tenant tokens enable multi-tenancy](https://www.meilisearch.com/docs/learn/security/tenant_tokens#tenant-token-payload-reference).

[![Example of tenant tokens usage](https://unable-actionable-car.media.strapiapp.com/meili_create_token_c6fb7330a6.gif)](https://tenant-token.meilisearch.com/)

Using tenant tokens to restrict access to documents ([see demo](https://tenant-token.meilisearch.com/))

6\. Scaling limitations
-----------------------

There is a legitimate motive for wanting to keep all data in a single database. But having search-related data in the main database comes with great technical consequences. Full text search queries on large dataset become costly with Postgres, especially when ranking results and computing facet counts.

Monolithic databases often become the bottleneck of applications that need to scale. Don’t add unnecessary search-related costs to this resource when you can avoid it. These costs are only multiplied when building user-facing applications with high traffic.

Unlike relational databases, full text search engines like [Meilisearch use inverted indexes](/blog/best-practices-for-faster-indexing/)his data structure creates information redundancy to allow quicker information retrieval. It is designed to perform search operations, and will naturally outperform relational databases on large datasets. And, when search usage spikes, there is a single service that needs scaling.

7\. Relevancy
-------------

As we mentioned earlier, relevant search requires typo tolerance, custom rankings, and synonyms. In modern applications, users expect results to update on each keystroke, which requires [prefix searching](https://www.meilisearch.com/docs/learn/advanced/prefix). But Postgres full text search `ts_rank` function only allows attribute weighting. When using the `pg_trgm` extension, developers are left to implement their own sorting based on similarity.

In search-focused databases, the concepts of result ranking, attribute priority, numbers of word matched, and exactness of the query are first-class concepts. They match high-level APIs that allow explicit fine-tuning of search behavior. This makes it easier to make these concepts available to non-tech, business stakeholders. This was cited as a key reason for [why Bookshop chose Meilisearch](/blog/bookshop-increases-search-based-purchases/)or their ecommerce search.

8\. Missing out on InstantSearch libraries
------------------------------------------

When it comes to search experience, websites and applications often implement the same user interface patterns: a textual search bar, checkbox lists of facets, range sliders, sorting menu, page navigation, etc. The open-source InstantSearch library comes with implementations of all these features in the form of widgets available via SDKs in JavaScript, iOS, and Android.

When time to market is paramount, it’s hard to pass on such niceties. Supported by Algolia, the InstantSearch libraries enjoy wide adoption and several search engine databases come with [InstantSearch-compatible APIs](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch). Read our Nuxt guide for ecommerce search to learn [how to implement InstantSearch widgets with Vue](/blog/nuxt-ecommerce-search-guide/)Callout>
  Prefer React? Read our tutorial on [using InstantSearch with React](/blog/instant-meilisearch/)/Callout>

9\. Limited Cloud support
-------------------------

Outsourcing the provisioning, maintenance, and scaling of servers is a common strategy in the Cloud era. Instead of managing servers, teams can focus on delivering value to their users. Postgres, like other databases, is available in a wide range of Cloud offerings for managed services. Unfortunately, managed services often come with limitations.

In the case of Postgres, implementing state-of-the-art full text search requires installing extensions. Moreover, fine-tuning language dictionaries and more configuration require access to the file system. Unfortunately, this means that many features are unavailable in Cloud environments.

To enable delegation of infrastructure, search engines often come with [dedicated cloud services](https://meilisearch.com/cloud). Those bespoke platforms do not compromise and allow using the full palette of search features. Moreover, customers can benefit from premium SLAs, support, and other enterprise services tailored to their searching use cases.

* * *

Postgres is a great, flexible database that allows the implementation of many custom, all-in-one solutions. Its full text search features might be sufficient for basic search, but it falls short when it comes to real-time search with relevance concerns. These limitations become worse on large datasets. It’s only natural, because Postgres is a database, not a search engine.

Meilisearch is an open-source search engine to build fast and relevant search experiences. It aims at providing state of the art experiences for end users while providing a simple and intuitive developer experience. You can try it by [running Meilisearch locally](https://www.meilisearch.com/docs/learn/getting_started/quick_start) or creating an account [for free on Meilisearch Cloud](https://cloud.meilisearch.com/login).

* * *

Learn more about what Meilisearch can bring to your business

[Talk to a search expert](https://dub.sh/meili-sales?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-postgres)

* * *

For more things Meilisearch, you can join the community on [Discord](https://discord.meilisearch.com/) or subscribe to the [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). You can learn more about the product by checking the [roadmap](https://roadmap.meilisearch.com/) and participating in [product discussions](https://github.com/meilisearch/product/discussions).

When does Postgres stop being good enough for full text search?

Meet Markus
-----------

To kick things off, we asked Markus to introduce himself.

> “I'm Markus, a software developer at [devjob.at](https://devjobs.at/). I enjoy experimenting with new technologies and packages, prototyping ideas, and improving the code base. My main area of interest lies in backend and infrastructure topics. During my free time, I read a lot of tech articles and follow Tech Twitter to see what's new in our ever-changing dev world.”

You can find him on Twitter as [@m4ch4tschek](https://twitter.com/m4ch4tschek)

> “Apart from the tech stuff, I also enjoy spending time in nature. Since owning a dog, I got interested in dog training. I dedicate a significant amount of time to it and consider it time well spent.”

Curious minds want to know! We couldn’t help but ask for account recommendations. If you are dying to know too, don’t worry, here’s the list of Markus’ top Twitter accounts:

*   [@marcelpociot](https://twitter.com/marcelpociot): Markus praised Marcel Pociot for creating the best developer tools around Laravel and other projects, and for quickly providing working solutions to developers' issues.
*   [@JackEllis](https://twitter.com/jackellis): He finds Jack Ellis' journey as a CTO challenging Google's analytics business to be very inspiring.
*   [@mathemagic1an](https://twitter.com/mathemagic1an): This account covers all things AI, and he recommends it to anyone interested in the field.
*   [@mattpocockuk](https://twitter.com/mattpocockuk): Markus believes this account owner has "TypeScript superpowers"
*   [@tobias\_petry](https://twitter.com/tobias_petry): For SQL content, he advises following Tobias
*   [@mjackson](https://twitter.com/mjackson) and [@kentcdodds](https://twitter.com/kentcdodds) were recommended for their work with Remix

And, of course, he also suggests following [@meilisearch](https://twitter.com/meilisearch) 😎

Love at first sight
-------------------

Markus discovered Meilisearch in late 2020. While he couldn't recall exactly how he first heard of Meilisearch, he did remember being drawn to its simplicity:

> “Finally, something fast and configurable, that I can easily understand and deploy without a PhD.”

He ended up implementing it into two projects, with one of them, [DEVWorkplaces](https://en.devworkplaces.com/), being highlighted in our [newsletter](https://mailchi.mp/meilisearch/newsletter-6025733?e=[UNIQID]). DEVWorkplaces focuses on job search and dev workplace discovery in the DACH region. It was already using Algolia in production, but it didn’t fully meet the product’s needs.

When asked what Meilisearch brought to the table that Algolia couldn't, Markus listed a few key advantages. First, **Meilisearch offers a self-hosting option**, which was a big plus for his team. Second, he appreciated the **local development environment** and the fact that Meilisearch is open-source. Finally, Markus found that Meilisearch was **easy to use and understand for team members**, making it a more accessible tool for everyone involved.

We were curious to know Markus’ take on how Meilisearch has evolved from 2020 to 2023. Has Meilisearch gone from good to great, or has it gotten worse? Thankfully, Meilisearch seems to have evolved in the right direction 😀

> “Seeing the community grow is the biggest point. Increased adoption of framework/language integrations has been wild. Also, there are a lot more team members now. Everything is way more professional (in a good way), from the releases, product decisions to communication, blog posts, and community interaction.”

As a developer advocate and one of the earliest team members, I love to hear that! The truth is that everyone at Meilisearch is very proud of how far we have come and very excited about the future!  We are moved to see that there are people who have been supporting us from the beginning 🥰

From user to contributor
------------------------

We're always intrigued by how individuals take the leap to contribute to a project. In Markus’ case, it was a matter of necessity. When he encountered an issue, he saw no other option but to fix it himself. As he became more involved with open-source projects, Markus began contributing to [Meilisearch](https://github.com/meilisearch/meilisearch) and [KeystoneJS](https://github.com/keystonejs/keystone), two projects that he uses in his work.

> “As open-source projects are mostly dependent on user contributions, this was the way to go. Also, contributing to an open-source project (no matter which size) is something I enjoy, even though I would like to contribute more.”

Markus’ contributions have evolved over time. Although he still contributes to code fixes, he has become more involved in non-coding tasks. Markus is particularly interested in [Laravel Scout](https://github.com/laravel/scout)\-related issues or questions and tries to provide helpful answers whenever possible. He’s been also participating actively in product discussions.

> “I've subscribed to topics that make my daily usage of Meilisearch easier. [Guillaume Mourier](https://github.com/gmourier/) (Meilisearch's Product Manager) makes a big effort to try to collect as much information as possible about new features or changes. This is great as we (contributors and users) can add input to any product decision before it gets implemented.”

It's feedback like this that has helped us continue to improve Meilisearch over time, and we are grateful for Markus’ and our community's contributions. We are excited to continue improving our product with his and our community's input. That's why we asked him about the features he would like to see in the near future, and he did not disappoint! He’s got plenty of ideas:

> “I think it would be great if Meilisearch would be [upgradable without the need of creating dumps and re-importing them](https://github.com/meilisearch/product/discussions/213). Just shutting down Meilisearch and starting it with a newer version. Currently, if we want to implement a zero downtime deployment (having the old Meilisearch instance and a new one and syncing the changes to both instances until everything is up to date), it leads to extended downtime on the search endpoint and overhead on the implementation side.”

> “Furthermore, for my current project at work, we would appreciate [multi-geopoint](https://github.com/meilisearch/product/discussions/508) support. As this is missing, we need to use the distinct attribute feature, which unfortunately is extremely slow on search requests with a lot of hits.”

It was great chatting with Markus and learning about his experience with Meilisearch. It's always a pleasure to hear from our community members and learn about the diverse ways in which they are using Meilisearch. We are grateful to Markus for taking the time to share his thoughts and experience with us, and we look forward to continuing to work with him and our community to create fast, powerful, and reliable search experiences.

If you are interested in learning more about how Meilisearch is being used by other developers and organizations, check out our [previous Meilistar interview](/blog/meilistar-interview-minoru-osuka/ with Minoru Osuka, one of our main language contributors.

Markus Machatschek: POV of a long-time Meilisearch contributor

Squeezing millions of documents in 128 TB of virtual memory

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

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

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

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

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

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

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

### Save time and resources

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

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

### Meilisearch Cloud has a great track-record

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

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

__\- Mason Stewart, CTO at Bookshop.org__

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

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

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

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

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

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

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

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

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

Meilisearch Cloud upcoming interface

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

### Meilisearch Cloud will adapt to your business

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

### Usage-based pricing

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

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

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

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

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

__\- Mason Stewart, CTO at Bookshop.org__

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

### Upcoming Meilisearch features

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

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

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

### Enterprise-ready improvements

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

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

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

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

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

The upcoming interface of Meilisearch Cloud

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

Conclusion
----------

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

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

Meilisearch latest news and company updates