Working as an employee experience manager in a hybrid-remote team heading to an offsite by the sea, I hear the usual questions: _“How long are we staying? How's the weather over there? What time are we leaving?”_

Later, sitting in a taxi to the airport with the Paris-based squad, clutching their sunglasses and their headphones, a voice asks quietly: _“By the way… how tall do you think Bruno is?”_

And as we look around, we realize nobody quite knows the answer to that question.

Despite countless hours spent working together over the past year, many of our coworkers haven’t seen more than our torsos and chosen Zoom backgrounds.

![Picture shows the Meilisearch team](https://lh4.googleusercontent.com/ZIDT5OR2sgNCiDzSGMOJ9XQ6_EzCXjkTlCi2i6IIXcT9apT3941_NOd8HAoqJREwVpGySo9xtcOgJM3z3acmIJk7W60PeNm6BiTPPDqZf8Pp-mz_MhOGLtrPQmAN0FRsQMUnf6wXfp4XP1dXxA)

It seems a long time since our last offsite in Hyères, France. In just a year, Meilisearch grew by ten more people. We now have enough to fill a soccer team!

As our company gets larger, it becomes harder to know everyone. With the offsite, our goal is to provide a venue for Meilisearch-ers to meet in real-time and in the same space. They can get to know each other even if they're not working closely together.

In fact, a question we loved hearing during the trip back is, _"Who did you discover during this offsite?"_ Because the feeling when you're reminded that your colleagues are people you are proud to be working with makes it all worth it!

Bringing the Meilisearch touch to our company offsite
-----------------------------------------------------

Meilisearch was created with the idea of being a people-first company. Early on, we chose to go with a [4-day work week](/blog/how-we-implemented-the-4-day-work-week/)nd later on implemented flexible working hours and unlimited remote working. Today, our team is hybrid-remote. Anyone can choose to work remotely, from the office in Paris, from a coworking space, or a mix of it all.

Although we think the offsite is the best way for everyone at Meilisearch to meet their coworkers, we know being away from home can be tiring. We want to ensure that work-life balance can still be maintained during this time.

![Picture shows the coastline](https://lh5.googleusercontent.com/VNPl48tHSfINJbHUrmy7qRrKuL-32l_IeKkjor5EGzzjw9mdl6nLnhVwnWQn_i7svlzSJGTMyTMWT1ep6eENzEJMenByQhxfeC_G0I1jTtWdBgvgpVUWV5LoUn-M-s9vXjz1YURKWM9A2DUVew)

Of course, there are limits to what we are able to do compared with a normal week. However, we try our best for our offsites to be a gentle and positive experience, with dedicated _free time_ for people to spend as they wish and a room for each person. Our HR team takes care to apply the Meilisearch touch even when scheduling an offsite.

The offsite itself is not strictly mandatory: though we believe meeting and working in real life with the team has immense value, if someone at Meilisearch has a personal priority, we either find alternatives for them to be able to attend on slightly different days or let them out.

We do not think it is our role to enforce presence at any cost: if an employee tells us something in their private life is more important this year, we believe them no questions asked. If our colleagues do not want to board a plane or just don't feel like getting away at this time, we follow the same principle.

Similarly, the team-building activities are meant to be accessible to every team member present at the offsite, but we do not insist on participation. This year, we had a fantastic time walking all around the old town of Dalt Vila on a scavenger hunt. We did our best to find clues and take pictures in small groups. The views were breathtaking, and we collectively took far too many pictures of animals. (Although there were some debates about whether dragons counted as animals.)

![Picture shows two iron dragon sculptures on a balcony](https://lh5.googleusercontent.com/wD5Gr6kuyy5RrQqzYQPsy2qmSHSgxjizzvGDvBjEUhV-qBRrU60BynQGhQOnPUDhgDAt3KlBYwGwEN-P3t4k6TlZMDNXEtHOWilx5rLpgASBTnaSme1MLNcta_VT20ypzrxWWtFXROsBw1Bvbw)

On a different afternoon, some of us went biking alongside the coast and through the countryside, while others stayed at the hotel to enjoy the pools and spa. We were delighted to use electric bikes that afforded us all ten brand new muscles (disclaimer: no biology textbook was consulted during the writing of this blog post) and all the more serenity with which to admire the clear and sparkling sea.

At Meilisearch, we can strive together with different approaches and activities. Our initiatives and needs are valued, and we believe this frame of mind creates a space in which people feel confident to chat with their coworkers and build our projects together.

Learning communication: a skill rather than a talent
----------------------------------------------------

During the offsite, we participated in two workshops on considerate communication.

One morning, we practiced listening without interrupting: in pairs, we listened to the other person speak without saying anything for seven minutes. Another day, we worked the other way around and formed small groups who could ask as many questions as they liked on a given subject (_”How to make sure our recruitment process is diverse?”_ or _“How can we communicate better in the Product Team?”_), while the person who was officially in charge took notes without responding. It was a whole new way to brainstorm for us!

We were also quite surprised to be reminded through a practical case just how many ways there are to interpret one message.

Communication is essential in any company or, for that matter, any kind of relationship. We believe communication can be impeded when people don't dare to reach out or do not have the tools or safety to express themselves. That is why we are very attached to a company culture in which we can publicly disagree, yet still commit to finding solutions together.

In another blog post, I explained [how we were building informal communication within the team at Meilisearch](/blog/how-we-create-space-for-casual-conversation-within-our-remote-team/)he offsites are a cornerstone of that strategy: it's one of the only times of the year in which we have an opportunity to directly observe other colleagues and pick up on some of their behaviors through osmosis. As we cannot rely on nonverbal communication or context much in writing, it's essential for all of us working remotely to communicate well.

We believe that communication can be learned. Although it's sometimes seen as a somewhat vague or innate concept, there are indeed skills that come with being able to express an idea, listen to someone, take or give feedback with grace, and work well together. And what better way to learn these skills than to experiment together?

![Picture shows a view of the coastline with blue transparent sea and a blue sky](https://lh5.googleusercontent.com/F-y2dEkpbzPChexYeylQEPylnJwuUdPLP0I1HCddleVorqo-husmq4UH9UQTcj1OVqSb7RefHzNyjxeRw3xz177fI9873s6oWP3MlwymAyAmawRisD_18KPZlDnjdfsoR80jMAP7zK4mtcwHow)

We are very excited to continue improving our offsites as Meilisearch grows. After each offsite, we send a survey to everyone in the team to get their input and make the next ones closer to their needs.

As more people join us, we will continue to experiment with the formula. This could mean one all-staff offsite a year in addition to a team-specific offsite. We also want to work on sustainability and offer still more freedom regarding food and downtime.

In the end, though, there is one thing we will never change: that our offsite is not about discovering our colleagues' height, but how interesting they are as human beings.

![Picture shows a sunset over the port from a rooftop](https://lh5.googleusercontent.com/ONk_QHJh95N2K2c1cKQiYCNA732gzXEFNwMlyhmwGTHwtCI406YsOY-nPOG4phmTKpiTnI7igywDbivwsZVRq1U2ayRVhCvp6bnr-XpjsZhlChbkvN9Yqm04XpJ8jfiL92nKp1NcvqQoKGHj4Q)

Meilisearch Offsite 2022 in Ibiza, Balearic Islands

Oyez, oyez! A new version of Meilisearch is out and brings you a bunch of cool new features including a long-requested one: typo tolerance customization!

We have been receiving feedback from users on wanting to disable or fine-tune typo tolerance for some time. Meilisearch v0.21 introduced phrase search, which returns documents containing the exact query terms if they are enclosed within double-quotes like: `“african-american poet”`.

It was a big step towards meeting our users’ needs, but it was not enough. After carefully studying the matter, the time has come: **the customization of typo tolerance** is a reality 🎉

But hang on, what does custom typo tolerance really mean? And even more important, what does typo tolerance mean?

The good old default behavior
-----------------------------

Meilisearch is typo tolerant, meaning it understands your search even if there are typos. But with great power comes great responsibility, which means setting boundaries to keep results relevant. This translates into the following three rules:

1. No typo is allowed if the query word is less than 5 characters long
2. Only 1 typo is allowed if the query word is between 5 and 8 characters long
3. 2 typos are allowed if the query word is more than 8 characters long

So if you are looking for `lost` but accidentally type `last`, you wouldn't get the desired result because it’s 4 characters long.

But, typing `greeec`instead of `greece` would retrieve the expected documents because it’s 6 characters long, so one typo is allowed.

These rules are applied by default and are part of the out-of-the-box configuration of Meilisearch, providing a powerful and relevant search. Yet, as they say, rules are meant to be broken...

Customization: a new horizon of possibilities
---------------------------------------------

We know every project is different, and some users need to configure typo tolerance to suit their projects’ particularities. We hear you!

Let’s take a look at the new typo tolerance settings:

```json
"typoTolerance": {
 "enabled": true, 
 "minWordSizeForTypos": {
 "oneTypo": 5,
 "twoTypos": 10
 },
 "disableOnWords": [],
 "disableOnAttributes": []
}

```

Looking at the `typoTolerance` object above, you can now:

* Disable typo tolerance entirely by setting `"enabled": false` 😱
* Disable typo tolerance partially on a set of specific terms using `"disableOnWords"`
* Disable typo tolerance on desired document attributes `"disableOnAttributes"`

You can also fine-tune the typo tolerance settings by modifying the minimum size of a word to accept one or two typos.

In sum, you have complete control of the feature.

<Callout>
 For more in-depth information on typo tolerance customization, you can read the [dedicated section](https://docs.meilisearch.com/learn/configuration/typo_tolerance.html) of the documentation.
</Callout>

Try it out and see
------------------

They say a picture is worth a thousand words (I can't stop with the catchphrases, sorry); that’s why I’ve created a demo to show how different typo tolerance configurations can impact the returned search results. **You can test it [here](https://typo-tolerance.meilisearch.com/).**

We will be using [Hakan Özler](https://github.com/ozlerhakan)'s [dataset of books](https://github.com/ozlerhakan/mongodb-json-files/blob/master/datasets/books.json). I made some changes to the original dataset for demo purposes, you can find the [transformed dataset](https://github.com/meilisearch/demos/blob/main/src/typo-tolerance/setup/books.json) on GitHub. You can search a book by its title, [ISBN](https://en.wikipedia.org/wiki/ISBN) (the ID of the book), author, or by the words in its description.

I have created two identical indexes with different typo tolerance settings. One index uses the out-of-the-box typo tolerance settings, whereas the other uses the following:

```JavaScript
const customTypoTolerance = {
 disableOnAttributes: ['isbn'],
 minWordSizeForTypos: {
 oneTypo: 2,
 twoTypos: 4
 }
}
```

Typo tolerance is disabled on `isbn`, and typos are allowed on shorter words: one typo for words that are 2 and 3 characters long, two typos for any longer word.

![Meilisearch returns different search results depending on the typo tolerance configuration for the same query](https://unable-actionable-car.media.strapiapp.com/typo_tolerance_1_gif_c23f105edf.gif)

It's usually better to provide the end-user with some results than with none. That’s why I set the threshold to the [minimum recommended](https://docs.meilisearch.com/learn/configuration/typo_tolerance.html#minwordsizefortypos). Try typing `flx` and see what happens!

Sometimes, however, it is preferable to return only exact matches. For example when searching documents by their unique identifier. The ISBN is precisely that: the ID of a book. Therefore, I disabled the typo tolerance on the `isbn` attribute.

Let’s try to find a book called “Well-Grounded Rubyist” by its ISBN; type `1933988657` into the search bar.

![When searching for an ISBN, Meilisearch returns only one document when typo tolerance has been disabled on the isbn field](https://unable-actionable-car.media.strapiapp.com/typo_tolerance_2_gif_0119353162.gif)

As you can see, we get the desired book with both settings. However, we get more than one result when typo tolerance is enabled. Searching for an invalid ISBN like `1933988676` still returns results when typo tolerance is enabled; this can be confusing and misleading.

Conclusion
----------

I didn’t disable the typo tolerance on any word because I did not deem it necessary given this dataset, did you? If you want to make some modifications and try to get more relevant results, be my guest: you can find [the code on GitHub](https://github.com/meilisearch/demos/tree/main/src/typo-tolerance).

But, if you like real challenges, I've got one for you. [Literal](https://literal.club/), an online platform for book readers, uses Meilisearch to search through bookshelves. They have been kind enough to share the recipe they've been using to deliver relevant search results:

```json
{
 "displayedAttributes":[
 "id",
 "title",
 "workId",
 "authors",
 "categories",
 "popularity"
 ],
 "searchableAttributes":[
 "authors",
 "title",
 "categories"
 ],
 "filterableAttributes":[
 "isbn10",
 "isbn13",
 "language"
 ],
 "distinctAttribute":"workId",
 "rankingRules":[
 "words",
 "typo",
 "popularity:desc",
 "proximity",
 "attribute",
 "sort",
 "exactness"
 ]
}

```

Can you come up with a better configuration? Can you think of the perfect typo tolerance settings to enhance the relevancy?

As you may have noticed, we take user feedback very seriously. Please don’t hesitate to check our [public roadmap](https://roadmap.meilisearch.com/) and upvote for any feature you'd like to see in future versions or submit a new feature idea. You can also check our [product repo](https://github.com/meilisearch/product/discussions) and make a suggestion or join an existing discussion on improving the product.

If you like Meilisearch and want to support us, a star on [GitHub](https://github.com/meilisearch/meilisearch) means a lot 🥰

Take control of Meilisearch's typo tolerance

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

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

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

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

```

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

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

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

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

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

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

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

```

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

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

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

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

```

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

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

```

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

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

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

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

```

Meilisearch v0.27 returns:

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

```

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

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

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

```

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

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

```

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

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

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

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

What's new in v0.27

Meilisearch is an independent publication launched in May 2022 by Ferdinand Boas. If you subscribe today, you'll get full access to the website as well as email newsletters about new content when it's available. Your subscription makes this site possible, and allows Meilisearch to continue to exist. Thank you!

### Access all areas

By signing up, you'll get access to the full archive of everything that's been published before and everything that's still to come. Your very own private library.

### Fresh content, delivered

Stay up to date with new content sent straight to your inbox! No more worrying about whether you missed something because of a pesky algorithm or news feed.

### Meet people like you

Join a community of other subscribers who share the same interests.

* * *

### Start your own thing

Enjoying the experience? Get started for free and set up your very own subscription business using [Ghost](https://ghost.org), the same platform that powers this website.

About this site

When my two co-founders and I finally took the plunge, quit our day jobs, and started Meilisearch, we immediately decided to open source the code of our search engine.

We did it because it felt natural: we were accustomed to using and contributing to open source projects, and had started working on Meilisearch with the hope that it could be useful to other developers. We didn't expect that working in open source would quickly become a monumental force that now drives the company's strategy and our entire way of working.

We went from nothing to a community of almost 30k developers—with over 90k unique users every month—in less than two years.

In this article, I'll explain our vision for improving the user-facing search experience and why it can only be accomplished through open source.

**Why did we create Meilisearch?**
----------------------------------

Before creating Meilisearch, my co-founders and I worked in an innovation team at a big-name French e-commerce company. Our last mission there was to reinvent their site navigation through search.

> We were fed up with seeing second-rate search bars on the sites and products we loved.

We quickly understood the high cost and complexity of configuring and maintaining existing search solutions, all for less-than-great results. Even the most successful solution on the market, Algolia, was positioned mainly for large e-commerce accounts where a good search experience could translate directly to increased revenue. We were fed up with seeing second-rate search bars on the sites and products we loved.

That's why we decided to create a search engine that could suit all types of products and companies to end the mediocre search crisis. Search, welcome to the 21st century!

**Why our vision can't happen without open source**
---------------------------------------------------

### Open source attracts developers

It’s well known that search experiences on the web are often dissatisfactory. But what is a search engine in the first place?

I would argue that a search engine is, above all, a tool for developers—much like a database. And if we look at the history of databases, open-source options are among the most popular. Access to the code, ease of deployment and modification, being part of a community—these are just some of the points that attract developers to open source tools.

Thanks to our decision to go open source, developers can try out Meilisearch as a side project, as part of their education, or—if they are lucky—during their work. Moreover, if they need help, they know that thousands of other developers like them are ready to answer their questions. If they have a problem, they can easily report it and even help fix it.

### Open source generates feedback

Developers can have a **direct impact** on the direction of an open-source project by giving feedback and creating issues on GitHub.

> We don't need to go looking for feedback anymore; it comes naturally to us.

Whether coming from our many [GitHub repositories](https://github.com/meilisearch/MeiliSearch), our [Slack community](https://slack.meilisearch.com), or our [public roadmap](https://roadmap.meilisearch.com), we get hundreds of bits of feedback every week—not to mention some great conversations with developers. We don't need to go looking for feedback anymore; it comes naturally to us.

This co-design process is vital to all of our product development, and it doesn’t stop with feedback: we also receive a lot of direct code contributions, helping us to improve and maintain our search engine, SDKs, and dev tools.

### Open source helps us build quickly

Using search to improve user experiences on the web is not an easy task. It is impossible for a company of our size to tackle the problem from all sides at once. On our own, we have to take the problems one by one.

However, we are not on our own. In addition to helping us prioritize our roadmap, our community also helps us tackle more problems at once—including many that are not our priority.

For example, if tomorrow several community members need an integration with Shopify, we can help them develop it and then share it with the rest of the community. Our product is able to grow gradually, procedurally, according to our user’s needs.

If today we have [20 libraries](https://github.com/meilisearch/awesome-meilisearch#integrations) updated every month, it's thanks to our community!

### Open source influences our design

Improving the search experience for all is not only about distributing a good search engine; it is also and above all about designing a good search engine. And once again, open source brings its own set of advantages. Public development naturally pushes us towards the most straightforward, intuitive solution possible so that developers can use and test it quickly.

> Today, we can confidently say that we have the most convenient search engine on the market.

Since day one, simplicity of use has been at the heart of the Meilisearch project. Step one was a massive investment in the project [documentation](https://docs.meilisearch.com). Then, thanks to the community and our completely public product management, we made sure that each new feature was understandable by everyone and very easy to access. Today, we can confidently say that we have the most convenient search engine on the market.

Conclusion
----------

You will have understood by now: open source is part of our DNA. Thanks to it and with it, we intend to grow our solution and change the world of search. That's why we will continue to work hand in hand with our community and together improve the search experience for internet users across the globe.

If you also feel concerned about the state of search, please help us in our fight by [joining the community](https://slack.meilisearch.com). If you want to show your support, you can star or “watch” our [GitHub repository](https://github.com/meilisearch/MeiliSearch) to receive updates.

Glad to have you with us on this journey,

Quentin de Quelen

PS: If you are already using Meilisearch and are looking for a hosted version, check out our new [Cloud offering](https://www.meilisearch.com/pricing). Don't have time for the waiting list? Reach out on our [community Slack](https://slack.meilisearch.com) and tell us about your situation so we can give you access as soon as possible.

How open source drives our strategy

This tutorial will show you how to integrate Meilisearch with Strapi v4 to create a search-based web app. We are going to use Strapi’s quick start guide to create a restaurant collection, and then use Meilisearch to search through our collection data.

Introducing our tools
---------------------

### What is Strapi?

[Strapi](https://strapi.io/) is a headless CMS. It provides a quick way to create a back-end where we can add and store data. The data is then available through a REST or GraphQL API without having to code anything or configure our database.

### What is Meilisearch?

[Meilisearch](https://www.meilisearch.com/docs/learn/what_is_meilisearch/overview#what-is-meilisearch) is a fast, open-source search engine that's easy to use and deploy. The aim of Meilisearch is to create an out-of-the-box relevant search experience in very few steps, with no configuration needed.

Pre-requisites for integrating Meilisearch and Strapi
-----------------------------------------------------

To be able to follow this tutorial on Strapi and Meilisearch integration, you'll need the following:

* An open [terminal or command prompt](https://www.ionos.com/help/email/troubleshooting-mail-basicmail-business/access-the-command-prompt-or-terminal)
* [Node.js](https://nodejs.org/en/download/) {">= 14 <= 18"}
* NPM and NPX (v6 only) (installed with Node.js): package managers that help you access and use JS libraries

Create a directory for our app
------------------------------

Let’s create a directory called `my-app` where we will add our back and front-end parts of the application.

```bash
mkdir my-app
cd my-app

```

Create a back-end using Strapi
------------------------------

Our first step is to generate a back-end API using Strapi. Go to your open terminal window and run the following command:

```bash
npx create-strapi-app@latest back --quickstart

```

This command creates a Strapi app in a new directory called `back` and opens the admin dashboard. Create an account or log in so that you have access to it.

![Strapi signup form](https://unable-actionable-car.media.strapiapp.com/Capture_d_e_cran_2022_04_08_a_11_27_18_1_3e4dd92cf4.png)

Once you have created your account, you should be redirected to Strapi's admin dashboard. This is where we will configure our back-end API.

Our next step is to create a new collection type. A collection is like a blueprint of your content—in this case, it'll be a collection of restaurants. We will create another collection called "Category" to organize our restaurants later.

![Strapi dashboard with side menu 'Content-Type Builder' option circled](https://unable-actionable-car.media.strapiapp.com/Capture_d_e_cran_2022_04_08_a_11_34_17_2_1_2b9259cf7e.png)

To follow along, complete the first 4 steps of "Part B: Build your content" from [Strapi's quick start guide](https://docs.strapi.io/developer-docs/latest/getting-started/quick-start.html). These will include:

* creating collection types
* creating new entries
* setting roles & permissions
* publishing the content

After finishing step 4 of Strapi's quick start guide, two new collections named `Restaurant` and `Category` should have appeared under `Content Manager` > `Collection Types`. If we click on `Restaurant`, we can see that there is only one. Let's add more by clicking the `+ Create new entry` button in the upper-right corner of the dashboard!

![Strapi dashboard: Content manager side menu, arrow indicating the location of the Restaurant Collection Type ](https://unable-actionable-car.media.strapiapp.com/Capture_d_e_cran_2022_04_08_a_18_27_41_copie_1_1_70c8af5070.png)

We’ll add three restaurants, one by one. For each restaurant, you need to press `Save` and then `Publish`.

* Name: `The Butter Biscotte.` Description: `All about butter, nothing about health.` 
 Let’s add the `French food` category on the bottom right corner of the page 👇

![Strapi dashboard: create an entry form, arrow indicating the location of the categorie's location in the right side menu](https://unable-actionable-car.media.strapiapp.com/Capture_d_e_cran_2022_04_08_a_18_33_44_2_9695c0fc90.png)

Name: `The Slimy Snail` Description: `Gastronomy is made of garlic and butter.` Category: `French food`

Name: `The Smell of Blue` Description: `Blue Cheese is not expired, it is how you eat it. With a bit of butter and a lot of happiness.` Category: `French food`

Once the three restaurants have been added, you should end up with the following page:

![Strapi dashboard: list of the existing restaurant entries in the Restaurant Collection Type page](https://unable-actionable-car.media.strapiapp.com/Capture_d_e_cran_2022_04_08_a_18_42_35_1_0d0b1abef2.png)

Our Strapi back-end is now up and running! Strapi automatically creates a REST API for our `Restaurants` collection. Check out Strapi's documentation for all available [API endpoints](https://strapi.io/documentation/developer-docs/latest/developer-resources/content-api/content-api.html#api-endpoints).

Now, it's time to bring Meilisearch into the mix.

Install and launch Meilisearch
------------------------------

To integrate Meilisearch into our Strapi-based web app, you first need to install Meilisearch. There are multiple ways to [download and run a Meilisearch instance](https://www.meilisearch.com/docs/learn/getting_started/installation#download-and-launch), we will be using [Docker](https://www.docker.com/) here.

If you want to avoid a local installation, **[try Meilisearch Cloud](https://www.meilisearch.com/pricing)**, a hosted and fully‑managed version of Meilisearch with a **free** 14-day trial, **no credit card required**.

**Open a second terminal window** and move to the `my-app` directory. This window will be used to run Meilisearch. Execute the command below to download and [install Meilisearch with Docker](https://www.meilisearch.com/docs/learn/cookbooks/docker). If Docker doesn't work for you, consider trying one of the [many other methods](https://www.meilisearch.com/docs/learn/getting_started/installation#download-and-launch).

```bash
# Fetch the latest version of Meilisearch image from DockerHub
docker pull getmeili/meilisearch:latest

# Launch Meilisearch
docker run -it --rm \
 -p 7700:7700 \
 -e MEILI_ENV='development' \
 -v $(pwd)/meili_data:/meili_data \
 getmeili/meilisearch:latest

```

You should see a big chunk of text (including some ASCII art) confirming that Meilisearch is up and running.

![Meilisearch startup message, arrow pointing the location of the address](https://unable-actionable-car.media.strapiapp.com/Screenshot_2023_02_23_at_15_02_41_e904f789b5.png)

Find the line titled `Server listening on`. This lets us know where Meilisearch is being served. Once you've found it, open this address in your browser.

![Meilisearch search preview, aka, mini-dashboard](https://unable-actionable-car.media.strapiapp.com/Screenshot_2023_02_23_at_15_08_38_b0c8b8b2a8.png)

This is the Meilisearch [search preview](https://www.meilisearch.com/docs/learn/what_is_meilisearch/search_preview). It will remain empty until we add some data to our Meilisearch instance.

It’s time to connect Strapi and Meilisearch and start searching through our data.

Connect Strapi and Meilisearch
------------------------------

In order to add the Meilisearch plugin to Strapi, we need to quit our Strapi app. Go to the terminal window running Strapi (_make sure it's not the one running Meilisearch!_) and push `Ctrl+C` to kill the process.

Once you've done that, install the plugin in the `back` directory.

```json
cd back
npm install strapi-plugin-meilisearch

```

After the installation, we have to rebuild our Strapi app before starting it again in development mode, since it makes configuration easier.

```json
npm run build
npm run develop

```

At this point, our Strapi app should be running once again on the default address: [http://localhost:1337/admin/](http://localhost:1337/admin/). Visiting it in your browser, you should see an admin sign-in page; enter the same credentials as before.

Once connected, you should see the new `meilisearch` plugin on the left side of the screen.

![Strapi dashboard with plugins side menu: arrow pointing at the 'meilisearch' option](https://unable-actionable-car.media.strapiapp.com/Capture_d_e_cran_2022_04_08_a_19_01_53_1_a30c95c406.png)

To add your Meilisearch credentials, click on the `Settings` tab on the meilisearch plugin page so that Strapi knows where to send our data.

For example, using the credentials from the **Launch and start Meilisearch** section above, add the address serving Meilisearch in the `Meilisearch Host` field, then click the `Save` button.

![Strapi dashboard with Meilisearch plugin selected: arrow pointing to the location of the settings tab](https://unable-actionable-car.media.strapiapp.com/Screenshot_2023_02_23_at_15_30_11_c882741ba9.png)

Note that we leave `Meilisearch API Key` blank because we launched Meilisearch without a [master key](https://www.meilisearch.com/docs/learn/configuration/instance_options#master-key).

Now it's time to add your Strapi collection to Meilisearch. In the `Collections` tab on the `meilisearch` plugin page, you should see the `restaurant` and `category` content-types.

By clicking on the checkbox next to `restaurant`, the content-type is automatically indexed in Meilisearch.

![GIF showing the mouse clicking on 'restaurant' in the Meilisearch collections tab](https://unable-actionable-car.media.strapiapp.com/strapi_gif_ce383289e9.gif)

As you can see in the GIF above, the word “Hooked” appears when you click on the restaurant's checkbox in the `Collections` tab. This means that each time you add, update or delete an entry in your restaurant content-types, Meilisearch is automatically updated!

Once the indexing finishes, your restaurants are in Meilisearch. We can now go back to our Meilisearch host address: [http://localhost:7700](http://localhost:7700). After refreshing, you should observe that the page is no longer empty. Try typing “butter” in the search bar and see what happens 😉

![GIF showing the word 'butter' being typed in the search bar and search results appearing instantly](https://unable-actionable-car.media.strapiapp.com/butter_1_72fa85eb2f.gif)

As you can see, your Strapi entries are sent to Meilisearch as is. You can modify the data before sending it to Meilisearch, for instance by removing a field. Check out all the customization options on the [strapi-plugin-meilisearch](https://github.com/meilisearch/strapi-plugin-meilisearch/#-customization) page.

Next steps after integrating Strapi and Meilisearch
---------------------------------------------------

Now that you have successfully added your Strapi collections in Meilisearch, you can start using the [search capabilities](https://www.meilisearch.com/docs/learn/what_is_meilisearch/overview#features) to their full extent.

Learn how to [set up instant-meilisearch](/blog/instant-meilisearch/ to integrate a search-as-you-type experience into your front end in no time at all!

If you have any questions about integrating Meilisearch with Strapi, please join us on [Discord](https://discord.gg/meilisearch). If you like Meilisearch, [a star on GitHub](https://github.com/meilisearch/meilisearch) means a lot.

How to integrate a relevant search into Strapi v4 using Meilisearch

We founded Meilisearch with a simple idea: what if we could take the top-of-the-line instant search experience found only in the most expensive websites and apps, make it affordable and accessible, and bring it to the rest of the internet?

Over time, this dream transformed into a mission and then into reality. We hired developers, partnered with investors, and, before we knew it, we had an effective, flexible, and—most importantly—_convenient_ search solution.

Our code was open-source from the beginning—this was an obvious decision since we were already open-source contributors. What was less obvious then was that open-source would become one of our greatest strengths as a software company and significantly accelerate Meilisearch's adoption. However, to become a truly accessible and widespread project capable of reshaping the world of search, Meilisearch needed high-quality SDK wrappers, libraries, tools, documentation, and support—all of which came with a price tag. It was clear that we needed to come up with a monetization solution, one that wouldn’t compromise the trust we’ve built with our open-source community.

There are many ways to monetize around open source software development, but one immediately stood out: **a cloud offering**. It appealed to us not just because some Meilisearch users were already asking for it, but because it would enable us to keep improving our open-source search engine. Unlike some options that provide a parallel paid product with access to exclusive features, this approach allows us to build a product _on top_ of the open-source project.

For businesses and individuals that want to quickly create a best-in-class search experience, we can offer the convenience of Meilisearch Cloud; for everyone else, we can offer our fully open-source search engine with all the features funded by our paid clients. This follows our bottom-up approach and helps us make sure we are constantly catering to a larger audience.

This is what we’ve been hard at work on over the past few months: **[Meilisearch Cloud](https://cloud.meilisearch.com/)**, our Software-as-a-Service offering.

The development of Meilisearch Cloud  

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

The road to Meilisearch Cloud started eight months ago when we gave [Samuel—whom you might have seen on GitHub](https://github.com/eskombro) or Slack— [Léna](https://github.com/lpinot) and [Nico](https://github.com/nicolasvienot) a mission to make a proof-of-concept application pushing the limits of what we could technically build. They created a [sandbox](https://sandbox.meilisearch.com/) that allows anyone to try Meilisearch for free for 48 hours.

Using this first experience, we began working on our cloud offering. Along the way, we onboarded a few users, did some UX testing, improved the UI, and added features to make it easy to update and manage Meilisearch instances.

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

Managing your Meilisearch instances from your browser

We designed [our pricing](https://www.meilisearch.com/pricing) for simplicity and based costs on the amount of resources allocated to the Meilisearch instance. We quickly understood that this model wouldn’t fit everyone’s needs, so one of our next steps will be to develop a “serverless” offering with pricing based on API consumption.

The private launch  

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

Throughout February and March we have been quietly onboarding people and taking them off the waiting list.  Today, some companies are already running Meilisearch Cloud in production, and we are now onboarding all the remaining companies registered on the waiting list.

If you are one of them, we ask for just a bit more patience. We have more than a thousand applications to get through, and we want to make sure we maintain the same great experience you already have with Meilisearch. We’ll try to onboard everyone in the next four weeks.

Open-source vs. Cloud  

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

We could not be more excited to announce Meilisearch Cloud and bring our search engine to a whole new group of users. Still, this process hasn’t been without its challenges.

We care deeply about accessibility, transparency, collaboration, and learning. Open source values have become a part of our company and the way we work in a way we never imagined. At the same time, something that’s not often talked about is that open-source development is not free:  the labor of developers, technical writers, support engineers, and myriad other contributors must be fairly compensated so these people can continue maintaining and improving a project.

By creating Meilisearch Cloud, we have chosen to position ourselves in the middle of the open-source and corporate worlds. We want the best of both: the impact and growth rate allowed by a paid product, with the transparency, accessibility, and strong ethical core provided by open source.

Conclusion  

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

This is a big step for Meilisearch as this will be our first paid offering. If you would like to try it, you can [still register on the waiting list](https://meilisearch.typeform.com/to/FtnzvZfh?typeform-source=www.meilisearch.com) or wait for the public release planned a few weeks from now.

You can always star our repositories or share our work if you want to support us. See you on [Slack](https://slack.meilisearch.com) or [GitHub](https://github.com/meilisearch/meilisearch); always happy to answer your questions regarding what we are building :)

  
PS: [We are recruiting a full stack software engineer](https://jobs.lever.co/meili/) to help us with our cloud offering!

Our first SaaS product: the history behind Meilisearch Cloud

### \***\*What is multitenancy?\*\***

In software development, multitenancy means that multiple users - also called tenants - share the same computing resources but have different access to system-wide data. In Meilisearch, you might have one index containing data belonging to many distinct tenants. In such cases, your tenants must only be able to search through their own documents.

You can achieve this using tenant tokens.

### **Tenant Token**

Tenant tokens are small packages of encrypted data presenting proof a user can access a certain index. They contain security credentials and instructions on which documents within that index the user is allowed to see.

The primary use case for tenant tokens is to enforce restrictions based on user permissions.

A user can generate a tenant token using [Meilisearch SDKs](https://docs.meilisearch.com/learn/security/tenant_tokens.html#generating-tenant-tokens-with-an-sdk) or [custom code](https://docs.meilisearch.com/learn/security/tenant_tokens.html#generating-tenant-tokens-without-a-meilisearch-sdk).

**Tenant tokens** do not require you to configure any specific instance options or index settings. They are also meant to be short-lived—Meilisearch does not store nor keep track of generated tokens.

When using an SDK to generate a tenant token, you need four parameters:

- **Search rules**: Search rules are a set of instructions defining search parameters that will be enforced in every query made with a specific tenant token.
- **API key**: A token has access to the same indexes as the API key used to generate it.
- **API key uid**: The uid of the API key used to generate the token allows checking that the API key used is valid.
- **Expiration date**(optional): The expiration date of the tenant token

You can read more about the tenant token payload in the [documentation](https://docs.meilisearch.com/learn/security/tenant_tokens.html#tenant-token-payload-reference).

### \***\*Requirements\*\***

1. [Node.js](https://nodejs.org/en/download/)
2. [npm](https://www.npmjs.com/)
3. [Meilisearch JavaScript SDK](https://github.com/meilisearch/meilisearch-js)

### \***\*Creating a tenant token\*\***

A **tenant token** can be created using the `generateTenantToken` function available in the Meilisearch Javascript SDK.

Here’s a simple example for creating a **tenant token** using the Meilisearch SDK

```jsx
client = new Meilisearch({
 host: "<http://localhost:7700>",
 apiKey: "masterKey",
});
// We have created a Meilisearch instance in JavaScript and we will use this to create the tenant token.

const apiKey =
 "rkDxFUHd02193e120218f72cc51a9db62729fdb4003e271f960d1631b54f3426fa8b2595";
const apiKeyUid = "85c3c2f9-bdd6-41f1-abd8-11fcf80e0f76";
const expiresAt = new Date("2025-01-01");
// Now we have declared the API Key, its uid, as well as the expiration date for the token.

searchRules = {
 "*": {
 filter: "user_id = 1",
 },
};
// Here we have defined the search rules that will apply restrictions on the search results.

tenantToken = client.generateTenantToken(apiKeyUid, searchRules, {
 expiresAt: expiresAt,
 apiKey: apiKey,
});
// Now the generateTenantToken function will create a tenant token and Meilisearch can validate this token with the apiKey.
```

When Meilisearch gets a search query with a tenant token, it decodes it and applies the search rules to the search request.

### **Application Usage**

Let's say we have a medical record system in a Meilisearch instance with the `patient_medical_record` index. This index contains a list of patients along with their details. We can use tenant tokens to restrict access to this data.

Sample dataset:

```json
[
 {
 "patient": "John",
 "description": "John is in room number 2 and is suffering from Covid",
 "roomNumber": 1,
 "isDoctorAppointed": true
 },
 {
 "patient": "Zia",
 "description": "Zia is in room number 3 and is suffering from Dengue",
 "roomNumber": 2,
 "isDoctorAppointed": true
 },
 {
 "patient": "Kevin",
 "description": "Kevin is in room number 4 and is suffering from Typhoid",
 "roomNumber": 3,
 "isDoctorAppointed": false
 }
]
```

In the above dataset, we have three patients: John, Zia, and Kevin. The aim is to restrict Zia from accessing Kevin and John's data. To achieve this, we need to create a **tenant token** for her with a set of search rules.

For this case, the search rules can be specified as:

```jsx
"searchRules": {
 "patient_medical_record": {
 "filter": "patient = Zia"
 }
 }
```

Zia's tenant token will be applied at the time of the search request, which returns:

```json
[
 {
 "patient": "Zia",
 "description": "Zia is in room number 3 and is suffering from Dengue",
 "roomNumber": 2,
 "isDoctorAppointed": true
 }
]
```

This is a simple use case, but we can modify the rule to meet more complex requirements.

### \***\*Integrating the multitenancy feature in your application\*\***

We will use the above example to create an [application](https://tenant-token.meilisearch.com/) for displaying patients in a Meilisearch index. We will then use multitenancy to restrict access to this data.

1. **Download the application**

 Clone the boilerplate code for the demo application from the Meilisearch tutorials repository on Github.

 Use the following command:

```bash
git clone https://github.com/meilisearch/tutorials

```

 The boilerplate code exists in the `src/tenant-token-tutorial` directory.

```bash
cd src/tenant-token-tutorial

```

 This code contains a frontend application built in `React.js` and a backend server in `Express.js/Node.js`.

2. **Start Meilisearch**

 There are multiple ways to [download and run a Meilisearch instance](https://docs.meilisearch.com/learn/getting_started/quick_start.html#download-and-launch). The easiest way to run a Meilisearch instance is using [Meilisearch Cloud](https://cloud.meilisearch.com/), there's a free 14-day trial, no credit card required. Meilisearch is open-source, in this demo, we'll run it locally using Docker:

```bash
 docker pull getmeili/meilisearch:v1.0


 docker run -it --rm \
 -p 7700:7700 \
 -e MEILI_MASTER_KEY='masterKey'\
 -v $(pwd)/meili_data:/meili_data \
 getmeili/meilisearch:v1.0 \
 meilisearch --env="development"
```

 _Don't forget to define a [master key](https://docs.meilisearch.com/learn/security/master_api_keys.html#protecting-a-meilisearch-instance) as shown above when launching Meilisearch. It will create the API keys needed to generate the tenant tokens._

 The Meilisearch instance will run on the IP address: `http://localhost:7700`.

3. **Adding data to Meilisearch**

 There is a `data.json` file in the `seed` folder of the base directory with a list of 10 patients suffering from multiple conditions with 100 entries, each with a room number and some patient details. We'll enter the information into Meilisearch.

 Change the terminal directory to the `seed` folder and add the given data to the Meilisearch instance, using the following command:

```bash
npm install # This command will install node dependencies

npm start # This command will add all the data from data.json to Meilisearch

```

4. **Start frontend server**

 Navigate to the `frontend` folder, and install all the application dependencies, and Meilisearch Javascript SDK

```bash
npm install # To install all the react application dependency

npm install meilisearch # To install the Meilisearch SDK

```

 It can take a while to install all the dependencies of the project.

 Let's get the frontend React server up and running with the command:

```jsx
npm start

```

 The app will run on the IP address: `http://localhost:3000`.

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

1. **Adding the functionality to create tenant tokens**

 Navigate to the `backend` folder and install all dependencies using the following command:

```jsx
npm install

```

 In the `backend` folder, open the `index.js` file. It contains the APIs' route and logic.

 An endpoint is already defined for generating the **Tenant token**:

```jsx
app.get("/create-tenant-token", async (req, res) => {
 const { value: patientName } = req.query;

 /* Add functionality to create Tenant token */
});
```

 Now, we'll add the functionality below the comment in the function.

 We need an API Key, search rules, and an expiration date to generate a tenant token.

 The API Key can be obtained from the `getKeys` method in the Javascript SDK. The `getKeys` method returns a list of API Keys from which we can select one to use in the **tenant token** generation process. To do so, add the following code to the API method stated above:

```jsx
const { results } = await client.getKeys();
const apiKey = results.filter(
 (res) => res.name === "Default Search API Key"
)[0].key;
const apiKeyUid = results.filter(
 (res) => res.name === "Default Search API Key"
)[0].uid;
```

 We can also use the `createKey` function to generate a new API Key.

 You can read more on API keys in the [Meilisearch documentation](https://docs.meilisearch.com/reference/api/keys.html).

 By specifying search rules, we can now generate a payload. Use the following code to define a payload:

```jsx
const payload = {
 patient_medical_record: {
 filter: `patient = ${patientName}`,
 },
};
```

 If we need the token to expire after a year, we can set an expiration date when creating the token, as shown below.

```jsx
const expiresAt = new Date(
 new Date().setFullYear(new Date().getFullYear() + 1)
);
```

 To generate the token, we can now use the `generateTenantToken` function from the Meilisearch Javascript SDK, and return the generated token using `res.json(`) function.

```jsx
const tenantToken = client.generateTenantToken(apiKeyUid, payload, {
 apiKey,
 expiresAt,
});

return res.json({ token: tenantToken });
```

 This is how the endpoint should be implemented:

```jsx
app.get("/create-tenant-token", async (req, res) => {
 const { value: patientName } = req.query;

 /* Add functionality to create Tenant token */
 const { results } = await client.getKeys();
 const apiKey = results.filter(
 (res) => res.name === "Default Search API Key"
 )[0].key;
 const apiKeyUid = results.filter(
 (res) => res.name === "Default Search API Key"
 )[0].uid;

 const payload = {
 patient_medical_record: {
 filter: `patient = ${patientName}`,
 },
 };

 const expiresAt = new Date(
 new Date().setFullYear(new Date().getFullYear() + 1)
 );

 const tenantToken = client.generateTenantToken(apiKeyUid, payload, {
 apiKey,
 expiresAt,
 });

 return res.json({ token: tenantToken });
});
```

 The frontend requested endpoint will look like this:

```bash
http://localhost:5001/create-tenant-token?value=John

```

 A payload containing the search rules is created using the value `John` from the API.

 Let's use the `npm start` command to start the express API server. The server will run at `http://localhost:5001.`

2. **Connect your APIs with the Frontend code**

 Enter the patient's name in the text box. On submitting the input form, an API call is sent to the backend, which should return a tenant token. We can pass this token to the Meilisearch instance when we need data on a certain patient.

 The frontend code must now be configured to request a tenant token from the server. We'll use the [axios library](https://www.npmjs.com/package/axios) to get the token from the `/create-tenant-token` API that we've developed, and we'll pass the patient name in the API's params.

 Open the file `index.js` in the `/src/utils` folder and look for the `getTenantToken` function. This function makes a request to the server and receives a tenant token back.

 Add the following code to the getTenantToken method:

```jsx
export const getTenantToken = async (patientName) => {
 const response = await axios({
 url: `${apiHost}/create-tenant-token`,
 method: "GET",
 params: {
 value: patientName,
 },
 });

 return response.data.token;
};
```

3. **Test out the implemented functionality**

 Let's test the implementation; start by clicking the **`Create a Tenant token`** button.

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

 Type the name `Kevin` in the given text box, and click **`Create a Tenant token` button**. This generates the tenant token.

 ![meili-create-token](https://unable-actionable-car.media.strapiapp.com/meili_create_token_76fc8c30f6.gif)

 Meilisearch will get data based on the tenant token provided by the patient, acting as an authenticator in the process.

### Conclusion

We have restricted access to medical records based on the names of the patients. Using Meilisearch's multitenancy capabilities, we were able to execute all of this with ease. This is a pretty basic use case scenario that comes to mind. The functionality can be as complex as you want it to be. For example, we can implement multitenancy in an e-banking application where the central authority is the bank and the customers are tenants having access to distinct bank accounts.

If you have any questions, please join us [on Discord](https://discord.gg/meilisearch). For more information on Meilisearch, check out our [Github repository](https://github.com/meilisearch/meilisearch/) and our official [documentation](https://docs.meilisearch.com/).

How to use Meilisearch in your multi-tenant application

My weekly 1:1 meetings with my manager (hi [Thomas](/blog/author/thomas/)! aren’t always about the operational aspects of work. They actually more often revolve around how we’re feeling at the moment and getting past certain doubts and challenges: am I handling this correctly? how should I give this person feedback? I feel stuck in this situation, what are your thoughts? Often, one of us would make a joke about how much we could charge as psychotherapists and we’d end the conversation with “that’ll be 90 bucks, thanks”.

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

We thought “there _must_ be other people here that are asking themselves the _exact_ same questions”. Since hiring a full-time shrink for the company wasn’t possible, Laurène, our Employee Experience Manager, started looking into mental health solutions for the people at Meilisearch. Pierre, one of the founders of [Strapi](https://strapi.io/), recommended [moka.care](https://www.moka.care/), and we implemented the solution at the beginning of 2022.

Mental health is just as important as physical health
-----------------------------------------------------

Leaving aside factors that are out of our control, from pandemics to wars to personal events, the world of work is a handful in itself and can have a major impact on our self-confidence and general mental health.

More specifically, the world of startups can be overwhelming. The median age generally isn’t very high, a lot of managers are fulfilling their roles for the first time, it’s common to quickly gain responsibility over a new scope and wear a lot of different hats at once. It’s intense, motivating, and incredibly interesting, but adapting to constant change requires a lot of energy and can be very unsettling for some of us. Because of that, we try to take our time as much as possible, ask ourselves the right questions, and bring a balance to our work environment.

As a software company, we don’t need to purchase machinery, raw materials or distribution solutions. As a remote-friendly startup, we don’t need huge offices that would probably cost a fortune. What we _do_ need is the skills of the people we work with. Supporting their well-being and providing the best possible working conditions is crucial to providing a great product. Our main investment is the people that are part of Meili.

This translates into several initiatives, such as implementing a [4 day work week](/blog/how-we-implemented-the-4-day-work-week/)ffering a fully paid 3 months leave for all new parents, and, more recently, proposing a mental health solution to all coworkers.

A lot of companies offer gym memberships for their team members to feel physically healthy—why not also encourage mental health?

moka.care: a door to mental health
----------------------------------

[moka.care](http://moka.care) is a web platform that offers team members access to sessions with work coaches and professionally trained therapists (psychotherapy, hypnosis, sophrology, etc). By making use of it, we want to put mental health on the same level as physical health.

This seems like a good solution for us because we wanted to offer therapy _and_ coaching solutions to address targeted topics, thus covering different types of needs. In the several subscription options they offer, we chose to start small (4 sessions per person per year) because we didn’t know if people would be open to trying this out. Our idea is to adapt along the way and offer a larger number of sessions if needed.

When using moka.care for the first time, you get an orientation phone call. In it, a trained adviser will ask you questions and assess your situation in order to direct you towards either a coach or a therapist, based on your needs, preferences, and the language you speak. After that, everything can be done through phone, video calls, or in person, depending on your preference.

It’s important to stress that **everything** is confidential. The only data our HR team has access to is the number of people that have created their account and booked a session—that’s it. The names of the employees and types of sessions that were chosen are never disclosed.

All companies play a part in creating work expectations
-------------------------------------------------------

We’re very proud of the search engine that we’re building, for a bunch of reasons. One of those reasons is that we’re open source and therefore able to offer our solution for free to developers and companies who need it. Moreover, as a company mostly populated by software engineers, we strongly believe that the collaborative aspect of open source and the diversity it brings makes for powerful and relevant software.

We’re also thrilled about the company we are building, and the freedom we have to shape our teams and their work experience. We are a tech startup: in this sense we evolve in a fundraising ecosystem that allows for companies like ours to be very visible, giving us the power to influence the world of work in a certain way.

We ourselves have been influenced by several companies: we adapted and implemented [Buffer’s career framework](https://buffer.com/resources/career-framework/), we took a lot of ideas out of [Alan’s](https://blog.alan.com/bien-etre-au-travail/a-quoi-ressemble-un-onboarding-a-distance) and [Payfit’s](https://switch.payfit.com/en/eight-tips-to-guarantee-a-successful-remote-onboarding/) employee onboarding, and our first equipment offer for team members was influenced by [Oyster HR](https://www.oysterhr.com/). We are taking initiatives towards employee well-being with the idea that, as we gain more and more visibility, we might influence other companies to take similar actions.

_And who knows: on top of revolutionizing search, maybe we’ll end up revolutionizing work?_

Meilisearch latest news and company updates