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://meilisearch.org.cn/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://node.org.cn/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://meilisearch.org.cn/docs/learn/getting_started/installation#download-and-launch), we will be using [Docker](https://dockerd.com.cn/) here.

If you want to avoid a local installation, **[try Meilisearch Cloud](https://meilisearch.org.cn/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://meilisearch.org.cn/docs/learn/cookbooks/docker). If Docker doesn't work for you, consider trying one of the [many other methods](https://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://node.org.cn/en/download/)
2.  [npm](https://npmjs.net.cn/)
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://npmjs.net.cn/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?_

Our first steps to support the mental health of our team members

[Nikita](https://nikita.js.org/current/guide/tutorial/) is a Node.js toolkit for automating deployment workflows. Even though we think it is great, we noticed Nikita's documentation website doesn’t really give users a way to quickly search and find the information they’re looking for. Nikita's content is open source and the documentation website is built with Gatsby, though, so we decided to take the opportunity to show you how to add a nice search interface to a Gatsby-based project.

In this tutorial we will install Meilisearch together with a few other dependencies. Then, we will clone Nikita’s Gatsby repository and index Nikita’s docs with Meilisearch. Finally, we’ll add a search UI to our local version of Nikita’s docs.

You can check the finalized code, including all content ready to be run in a server, [at this github repo](https://github.com/meilisearch/demos/tree/main/src/gatsby-plugin-guide).

Setup
=====

Before we begin, let’s take a quick look at everything you need to follow this tutorial.

Introducing our Tools
=====================

Gatsby
------

[Gatsby](https://www.gatsbyjs.com/) is a React-based open-source framework used for Static Site Generation (SSG). It combines the functionality of React, GraphQL and Webpack and provides great performance, scalability, and security right out of the box.

Requirements
============

To be able to follow this tutorial, 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://node.org.cn/en/download/) {">= 14.15.X and <= 16.X"}: this makes it possible to run JS outside a browser
    *   You can check your active version with the command `node --version`
    *   If your version of Node is outside this range, we recommend that you [install nvm](https://github.com/nvm-sh/nvm/blob/master/README.md#about) and use it to access Node 14
*   Yarn >= 1.22 : Yarn is a package manager that doubles down as project manager
*   [Docker](https://dockerd.com.cn/): Docker will help us create a working development environment with relatively little effort

Steps
=====

1.  Start Meilisearch
2.  Setup the Gatsby project
3.  Add the Meilisearch plugin
4.  Add the content of the Gatsby app to Meilisearch
5.  Build the frontend

Start Meilisearch
=================

There are multiple ways to [download and run a Meilisearch instance](https://meilisearch.org.cn/docs/learn/getting_started/installation#download-and-launch). For this guide, we'll be using Docker. Want to avoid a local installation? Try our [Meilisearch cloud](https://cloud.meilisearch.com/) with a free 14-day trial!

After installing Docker in your machine, fetch and run the latest Meilisearch container image. To do that, open your terminal and use the following commands:

```bash
docker pull getmeili/meilisearch:latest 

docker run -it --rm -p 7700:7700 getmeili/meilisearch:latest ./meilisearch --master-key=masterKey

```

Meilisearch will start running on [http://localhost:7700](http://localhost:7700/). If everything went well, you should see something like this in your terminal window:

![Screenshot-2023-04-13-at-14.48.31](https://unable-actionable-car.media.strapiapp.com/Screenshot_2023_04_13_at_14_48_31_d715bb8f41.png)

Setup the Gatsby project
========================

With Meilisearch ready, it’s time to download Nikita’s documentation.

In another terminal window, navigate to your working directory, then clone the Nikita project that we will be using for this guide:

```bash
git clone https://github.com/adaltas/node-nikita.git

```

You can find the content of the Gatsby app in the markdown files inside the `docs/content` folder. This is the data Gatsby uses to generate Nikita’s documentation.

| _Directory structure for the node-nikita project_ |

Add the Meilisearch plugin and launch Gatsby
============================================

Alright: both Meilisearch and Gatsby are installed. We will start by installing all the project dependencies. Run the following command in your terminal:

```bash
cd node-nikita/docs/website
yarn

```

Once that is done, we will install the official Meilisearch plugin for Gatsby with Yarn:

```bash
yarn add gatsby-plugin-meilisearch

```

Great! We’re ready to launch Gatsby. To do that, just run the following command on your console:

```bash
yarn develop

```

This is how the UI of the Nikita docs website looks like:  
![nikita1](https://user-images.githubusercontent.com/19529592/161043477-afd719ab-fe45-4f1a-ae0b-5f27e4983df6.jpg)

Add the content of the Gatsby app to Meilisearch
================================================

Now that we have installed the plugin and have both the Gatsby app and the Meilisearch instance running, things start to get interesting! Let's configure `gatsby-meilisearch-plugin` to make the content searchable.

The main code for the docs website lies in the directory `docs/website`.

**Configure the plugin**
------------------------

The first thing we need to do is add your Meilisearch [credentials](https://meilisearch.org.cn/docs/learn/getting_started/quick_start#securing-meilisearch) to the Meilisearch Gatsby plugin. Open `docs/website/gatsby-config.js` and add this bit of code at the bottom of the `plugins` array:

```jsx
{
    resolve: 'gatsby-plugin-meilisearch',
    options: {
      host: 'http://localhost:7700', // your host URL goes here
      apiKey: 'masterKey',   // your API key goes here       
      indexes: [],
    },
  },

```

So far, our configuration tells the plugin where to find our Meilisearch instance and gives it the credentials to read the content inside Gatsby. Now we need to define what data we want to add to Meilisearch and how. This happens in the [indexes field](https://github.com/meilisearch/gatsby-plugin-meilisearch#-indexes). This field can be considered the heart of the Gatsby Meilisearch plugin.

The `indexes` field is an array composed of multiple index objects. Each index object must contain the following fields: `indexUid`, `query`, and `transformer`. Let's examine these fields.

### `indexUid`

This field contains the name of a Meilisearch index. For this guide, we will use `nikita-api-docs`:

```jsx
indexUid: 'nikita-api-docs'

```

### `query`

This field contains the GraphQL query the plugin will use to fetch content from Nikita’s documentation. Gatsby comes with inbuilt support for GraphQL—it even includes a bundled GraphQL tool, accessible on ([http://localhost:8000/\_\_\_graphql](http://localhost:8000/___graphql)). You can read more about GraphQL on the project’s official [documentation.](https://graphql.net.cn/learn/)

Our query looks like this.

```jsx
query: `query MyQuery {
    allMdx {
      edges {
        node {
          frontmatter {
            title
            navtitle
            description
          }
          slug
          rawBody
          id
        }
      }
    }
  }`,

```

In this query, we first say we are only interested in the markdown files by wrapping our query with the `allMdx` statement. We can do that thanks to two very useful tools: `gatsby-plugin-mdx` and `gatsby-source-filesystem`.

Then, we specify which document fields we want to include in our index: `title`, `navtitle`, `description`, `slug`, `id`, and, finally, `rawBody`—that is, the document’s raw markdown content.

### `transformer`

This is the last configuration field. It gets the data we fetched from Gatsby with our `query` and converts it into a format that Meilisearch will understand.

In our case, the data will look a bit like this:

```jsx
data = {
    allMdx: {
        edges: [
          {
            node: {
              frontmatter: {
                title: "Introduction",
                navtitle: "intro",
              },
              body: "Introduction to the Nikita.js",
              slug: "/introduction",
              id: "1",
            },
          },
          {
            node: {
              frontmatter: {
                title: "Architecture",
                navtitle: "architecture",
              },
              body: "Architechture of Nikita.js",
              slug: "/architecture",
              id: "2",
            },
          },
        ],
    },
};

```

This data looks great, but is not in a format that Meilisearch can easily understand. We can change that by adding a parser function to `transformer`:

```jsx
transformer: (data) => {
    data.allMdx.edges.map(({ node }) => {
      // Node property has been destructured here
      return {
        id: node.id,
        lvl0: node.frontmatter.title,
        lvl1: node.frontmatter.navtitle,
        content: node.body,
        anchor: node.slug,
      };
    });
}


```

With that, `gatsby-plugin-meilisearch` will get the raw data we extract with our query and turn the whole object into an array.

```jsx
 // It will return a list of transformed structured object
  
[
    {
      id: "1",
      lvl0: "Introduction",
      lvl1: "introduction",
      content: "Introduction to the Nikita.js",
      anchor: "/introduction"
    },
    {
      id: "2",
      lvl0: "Architecture",
      lvl1: "architecture",
      content: "Architechture of Nikita.js",
      anchor: "/architecture"
    }
]

```

### Putting it all together and finalizing plugin configuration

If you’ve been following along, the `gatsby-plugin-meilisearch`configuration at the end of your `docs/website/gatsby-config.js` should look something like this now:

```jsx
{
  resolve: 'gatsby-plugin-meilisearch',
  options: {
    host: 'http://localhost:7700',
    apiKey: 'masterKey',
    batchSize: 1,
    indexes: [
      {
        indexUid: 'nikita-api-docs',
        settings: {
          searchableAttributes: ['lvl0', 'lvl1', 'lvl2', 'content'],
        },
        transformer: (data) =>
          data.allMdx.edges
            .filter(
              ({ node }) =>
                node.slug.search('guide') !== -1 ||
                node.slug.search('project') !== -1 ||
                node.slug.search('api') !== -1
            )
            .map(({ node }) => {
              // Have to update for versioning
              const currentVersion =
                node.slug.substring(0, 8).search('project') === -1
                  ? '/current'
                  : ''

              return {
                id: node.id,
                lvl0:
                  node.frontmatter.navtitle || node.frontmatter.title || '',
                lvl1:
                  node.frontmatter.title || node.frontmatter.navtitle || '',
                lvl2: node.frontmatter.description || '',
                content: node.rawBody,
                url: `${currentVersion}/${node.slug}`,
              }
            }),
        query: `query MyQuery {
            allMdx {
              edges {
                node {
                  frontmatter {
                    title
                    navtitle
                    description
                  }
                  slug
                  rawBody
                  id
                }
              }
            }
          }`,
      },
    ],
  },
},
```

We began `gatsby-plugin-meilisearch` configuration by adding basic data and credentials to `docs/website/gatsby-config.js.`

We continued configuration by specifying the content we want to search should be added to the `nikita-api-docs` index, used a GraphQL query to select content for indexation, and finally used a `transformer` function to format the data for indexation.

**Build the project**
---------------------

The `gatsby-plugin-meilisearch` will fetch and send data for indexation to Meilisearch during the build process. To get that started, run the following command:

```bash
yarn build

```

You should see a message in the terminal once your content is being indexed:

```bash
success gatsby-plugin-meilisearch - 0.920s - Documents are send to Meilisearch, track the indexing progress using the tasks uids.

```

You can verify this by going to [http://localhost:7700](http://localhost:7700), entering your API key, and checking that Nikita’s documentation has been added to Meilisearch.

Build the frontend
==================

Now that the data is indexed, let’s build the user interface and create a great search experience for our end-users.

For this example, we will use [docs-searchbar.js](https://github.com/meilisearch/docs-searchbar.js). It is a front-end SDK for Meilisearch that provides an easy way of integrating a search bar into our documentation site.

Add the search bar component
----------------------------

Let’s start by installing docs-searchbar.js in the frontend directory of the project.

```markdown
# With Yarn
yarn add docs-searchbar.js

```

With that done, we can import the docs-searchbar module into `website/src/components/shared/AppBar.js` by adding this to the top of the file:

```jsx
import 'docs-searchbar.js/dist/cdn/docs-searchbar.css'

```

Next, we need to add a `useEffect` hook to add the docsSearchBar function to `AppBar.js`. Add this below the other `useEffect` hook:

```jsx
useEffect(() => {
    if(window !== undefined){
      const docsSearchBar = require('docs-searchbar.js').default

      docsSearchBar({
        hostUrl: 'http://localhost:7700',
        apiKey: 'masterKey',
        indexUid: 'nikita-api-docs',
        inputSelector: '#search-bar-input',
        meilisearchOptions: {
          limit: 5,
        },
        enhancedSearchInput: true,
      })
    }
  }, [])

```

The `docsSearchBar` function comes in with a number of different parameters:

*   `hostUrl` and `apiKey` allows the search bar to access your Meilisearch instance.
*   `indexUid` tells the search bar which index it should search through.
*   `inputSelector`is a selector matching the HTML element where our users will type their queries. In our case, that’s `#search-bar-input`. Don’t worry, we’ll add this element to Gatsby in a moment.
*   Finally, `enhancedSearchInput` tells `docs-searchbar` to apply a theme to the search box, improving its appearance and making it a bit more user-friendly.

All that’s left is adding our search element in `website/src/components/shared/AppBar.js`. Remember to use the same `id` we configured as the `inputSelector`. Add the element after `</Link>` tag:

```jsx
<input type="search" id="search-bar-input" />

```

And that’s it! We’re done!

**Test the implementation**
---------------------------

Ready to see all this hard work in action? On your terminal, re-run the following command:

```markdown
yarn develop

```

And then use your browser to access [`http://localhost:8000`](http://localhost:8000/). You should see your local copy of NikitaJS’s docs with a brand new search bar:

![nikitalfinall](https://user-images.githubusercontent.com/19529592/161043686-a34453b0-e155-4f03-8ba2-2a9225190757.jpg)

Conclusion
==========

We hope this article was a pleasant introduction to the new [Meilisearch plugin for Gatsby](https://github.com/meilisearch/gatsby-plugin-meilisearch)!

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/).

Add a search bar to your Gatsby project using Meilisearch

In this article, let's take a look at some of the most significant changes in Meilisearch's latest update. You can check out the [full changelog here](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.26.0).

New feature: tenant tokens
--------------------------

In software development, multitenancy means that multiple users—also called tenants—share the same computing resources but have different levels of access to system-wide data. In Meilisearch, you might have one index containing data belonging to many distinct tenants.

**Tenant tokens** are small packages of encrypted data containing **security credentials** and a set of **search rules**. These search rules effectively limit what documents a search query can return. For example, you might use tokens to ensure users of a healthcare application can only search through their own medical records, even when all records are stored in the same index.

To start using tenant tokens, set up a token generation process in your application's back-end:

```js
const currentUserID = 'aUserID';

const searchRules = {
  'patient_medical_records': {
    filter: `user_id = ${currentUserID}`
  }
};

const apiKey = 'yourApiKey';

const expiresAt = new Date('2025-12-20'); // optional

const token = client.generateTenantToken(searchRules, {
  apiKey: apiKey,
  expiresAt: expiresAt,
});

```

After you have created your tenant token, you can send it to your end-user's front-end and use it to query an index:

```js
const frontEndClient = new MeiliSearch({ host: 'http://127.0.0.1:7700', apiKey: token });
frontEndClient.index('patient_medical_records').search('blood test');

```

You can read more about multitenancy and how to implement tenant tokens in your application in [our dedicated guide](https://docs.meilisearch.com/learn/security/tenant_tokens.html).

Experimental feature: auto-batching
-----------------------------------

When it comes to improving Meilisearch's indexation performance, we have often recommended users to split their documents into batches. However, finding the right batch size can present an additional challenge. On the one hand, large batches use a lot of resources; on the other, small batches are significantly slower. We know we can do better than this.

In this release, we are introducing an experimental auto-batching feature. Auto-batching will help you improve indexing speed by **automatically batching together consecutive document additions**.

You can activate auto-batching by passing the `--enable-auto-batching` flag when launching Meilisearch:

```sh
./meilisearch --enable-auto-batching

```

We are very hopeful that this feature will make Meilisearch indexation faster and easier to use. You can read more about auto-batching on [our documentation website](https://meilisearch.org.cn/docs/learn/core_concepts/documents#auto-batching).

We decided to ship it in an experimental state since this feature may be heavily reworked. We need your [feedback](https://github.com/meilisearch/MeiliSearch/discussions/2070) to measure its success and make it evolve.

Breaking change: new dump behavior
----------------------------------

Importing a dump into an instance with an existing database will throw an error and Meilisearch will not launch. Prior to v0.26 the import only failed silently and gave no indication anything had gone wrong.

```sh
./meilisearch --import-dump path_to_dump_file

```

If necessary for your workflow, you can use two new command-line flags to suppress import errors: `--ignore-dump-if-db-exists` and `--ignore-missing-dump`.

Breaking change: command-line flag behavior
-------------------------------------------

Starting with v0.26, the following instance options no longer accept values when used in the command-line: `-no-analytics`, `--schedule-snapshot`, `--ignore-missing-snapshot`, `--ignore-snapshot-if-db-exists`, `--ssl-require-auth`, `--ssl-resumption`, and `--ssl-tickets`.

```js
# new behavior
meilisearch --no-analytics

# old behavior
meilisearch --no-analytics=true

```

A value is still required when using these options as environment variables.

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

*   Empty CSV cells are now converted to `null` values
*   Valid but empty payloads no longer throw errors when adding and updating documents
*   armv8 binaries are deprecated in favour of aarch64 binaries
*   Improved highlighting for searches containing non-unicode characters
*   Improved `_geoPoint` sorting behavior

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

Thank you very much to the contributors that helped us out! We want to give a special shout-out to [@robjtede](https://github.com/robjtede), [@Thearas](https://github.com/Thearas), and [@Samyak2](https://github.com/Samyak2)—we're humbled by your effort and generosity.

* * *

And that's all folks! Remember to check out the [changelog on GitHub](https://github.com/meilisearch/meilisearch/releases/tag/v0.26.0) for the full release notes and see you soon for v0.27!

What's new in v0.26

The Meilisearch context
-----------------------

We are a French tech startup, founded in late 2019. From our origins with three cofounders, the company expanded following rounds of successful investment bids. Today we number 25 colleagues, including developers, and specialists in developer relations (community), product management, human resources, and documentation.

What is knowledge management?
-----------------------------

Knowledge management (KM) is the systematic management of an organization's **knowledge assets** (information that can be useful) for the purpose of **creating value** and **meeting tactical & strategic requirements**. It consists of the initiatives, processes, strategies, and systems that sustain and enhance the storage, assessment, sharing, refinement, and creation of knowledge. Knowledge management has a strong tie to organizational goals and strategy.

KM is a role that organizations often bring in at a later stage of their development. In recruiting a KM role early on in the company’s development, Meilisearch is choosing to develop positive KM practices in good time, and this has several benefits:

*   showcasing not only our codebase and community but also our knowledge capture and reuse, we increase our attractiveness to future colleagues
*   focusing on collecting, connecting, and creating knowledge allows us to work more efficiently and innovate, as we reduce duplication and learn from past experiences and experiments
*   optimizing our processes and procedures for how we work together makes our jobs more interesting, as we reduce toil (avoidable repetitive effort) and increase autonomy

My job is to help colleagues understand the challenges of knowledge management, and give them the tools and techniques to become effective knowledge managers themselves.

Exploring the KM environment at Meilisearch
-------------------------------------------

In my first couple of months at Meilisearch, I spent time with each team to learn how my colleagues worked together, both within and between teams. I was able to make general recommendations, such as setting up and coaching the Senior Leadership Team, and implementing some changes to the structure and setup of our regular meetings.

Now it was time to explore at a deeper level. To learn more about the KM environment, provide a starting point for measuring improvement, and discover pain points and common themes, I designed a research project.

I sought to combine the benefits of short questions and answers which are quicker for the participants to reply to, and the richer nature of longer responses. To achieve this, I created the KM opportunities survey, which included the option for participants to have a follow-up 1:1 information clinic session with me.

Key KM findings from my research project
----------------------------------------

My colleagues value my emerging role and can see the benefits of taking a step back and reflecting on our KM practices. My recommendations focus on what we should **stop**, **keep**, and **start** doing across the topics of:

*   meetings
*   processes
*   finding information
*   reusing work
*   news and notifications
*   keeping up (information workflows)
*   common goals and shared strategy
*   defining the scope of our roles and responsibilities
*   shifting towards asynchronous working
*   documenting and communicating

As well as being foundational elements for good knowledge management, much of this advice also supports designing for remote-first and asynchronous working, which is essential to Meilisearch’s development as we welcome new colleagues across different time zones. [Read the full report](https://doi.org/10.5281/zenodo.5877236).

Next steps
----------

To put these recommendations into actions, I have set three strategic priorities for KM at Meilisearch for 2022:

1.  Employee **onboarding**: getting colleagues up to speed quickly (reduces business costs and affects our ability to scale the company)
2.  **Strategic alignment**: building a shared roadmap based on a common understanding of our organizational vision, mission, and strategy (and making sure everyone in the organization understands when there’s been a shift in direction and adjust accordingly)
3.  Meilisearch **knowledge base** and its management: starting with making the most of the existing key content repository

I will also be working with each team to help them choose 3-5 aspects that are particularly important to them, and support them to make improvements in these areas. Across the organization, we will be creating a culture of coaching and peer learning to allow all of us to be multipliers of the skills we’re sharing.

As one participant said _“we shouldn’t go on as we are… making some changes would mean we’d all feel better at work. And it’s funny that we can iterate on Meilisearch but not on our ways of working”._

Here’s to an iterative approach to improving our collective culture of knowledge management at the individual, team, and company level! If this work environment inspires you, check out [our open positions](https://jobs.lever.co/meili).

If you’re interested to learn more about KM and small organizations, register for our free webinar “[Start small to move mountains: knowledge management at a start-up](https://us06web.zoom.us/meeting/register/tZwuduqpqDwuGdUEiDxN-N4FlnXFd-hoNIHw)” at 12:00 CET (11:00 UTC) on Friday 25th February 2022.

Kicking off knowledge management at Meilisearch

Today I'm proud to announce that Meilisearch has closed a $5M USD Seed funding round led by [CRV](https://www.crv.com/) with the participation of Robin Vasan ([Mango Capital](http://www.mangocap.com/)), Guillermo Rauch (CEO of [Vercel](https://vercel.com/meili)), and returning investors [LocalGlobe](https://localglobe.vc/) and [Seedcamp](https://seedcamp.com/).

What is Meilisearch?
====================

For more than two years now, we have been working to redefine the world of user-facing search.

We chose to tackle this challenge for a few reasons. From a user perspective, we were tired of seeing great products with terrible search bars. As developers, we also knew how difficult it is to set up a good search experience: there are few tools available, and of those, most are either too complicated, too expensive, or not powerful enough.

From the start, we made several bold choices that empowered us to create Meilisearch as it is today.

First, we chose to make our project open source. We did this primarily because it was our reflex as developers, but also because it was the best way to reach the maximum number of users. From the beginning our goal was to provide a good search engine for developers; why wait until we deemed the product complete to put it in their hands? Instead of building something for our users, we chose to build alongside them.

Secondly, we picked Rust as the main programming language for our engine. This was a difficult choice in 2019, because although it was elected the language of the year, few companies had invested in this technology and the number of dedicated Rust developers was still small. We forged ahead because we believed that its superior performance would more than make up for any potential downsides.

These choices, while counterintuitive at the time, have become our greatest strengths. Starting from our very first public communication, there was an overwhelming response from developers. For several months in a row, we were one of the fastest-growing open-source projects on GitHub. That's when we decided to raise our first round of funding from European investors to double down on our product and growth.

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

In less than two years the project has grown enormously: today we have more than 20k stars on GitHub, almost 100k developers using our engine every month, and thousands of servers in production. Our product managed to strike a chord in the heart of developers who were tired of inadequate search. In doing so, we fulfilled the mission we set ourselves at the beginning.

What's next?
============

Our latest round of funding allows us to invest more heavily in our community. We’ve already created a product that sparks developers’ imaginations; now our mission is to give them the tools and support they need to build amazing sites and apps with Meilisearch. We will do this by building a team whose sole purpose will be managing, feeding, and growing an inclusive community.

Of course, we will also continue to work on our product. We have many new features coming that have been massively requested by users.

In addition, now that we have so many users on our open source project, we are getting more and more requests from companies that would like to use a version of Meilisearch managed by us instead of having to manage the service themselves. That's why we started to develop [Meilisearch Cloud](https://meilisearch.typeform.com/to/FtnzvZfh?typeform-source=admin.typeform.com) a few months ago. With Meilisearch Cloud, we are taking the power and simplicity of our engine, optimizing for it, and managing it for our users. In just a few weeks of beta, we have already received hundreds of requests for access.

If you’ve supported, used, or contributed to Meilisearch in the past: thank you! We are planning to grow the team and will be recruiting all kinds of roles in the coming months. If you want to help us shape the future of website and app search, we're [looking for more talent](https://www.welcometothejungle.com/companies/meilisearch) to help us sustain our vision.

  
Quentin de Quelen - CEO of Meilisearch

Meilisearch raises a $5M Seed to change the world of user-facing search

In this article, we will take a look at some of the main and breaking changes introduced by v0.25. You can also read the [full changelog on GitHub](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.25.0).

Breaking changes
----------------

### API key management

Starting from this release, developers can now create API keys with specific permissions and expiration dates, allowing precise control over which users/applications can access which indexes and endpoints.

As part of this feature, the `private` and `public` keys are deprecated and replaced by two default API keys with similar permissions: `Default Admin API Key` and `Default Search API Key`.

The `X-MEILI-API-KEY: <apiKey>` header is replaced by the `Authorization: Bearer <apiKey>` header.

Let's say that you're creating an application in the medical industry. Here's how to create an API key that only has access to search endpoints on the `patient_medical_records` index:

```bash
curl \
    -X POST 'http://localhost:7700/keys/' \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer [your_master_key]' \
    --data-binary '{
      "description": "Search patient records key",
      "actions": [
        "search"
      ],
      "indexes": ["patient_medical_records"],
      "expiresAt": "2023-01-01T00:00:00Z"
    }'

```

**Response: `201 Created`**

```json
{
    "description": "Search patient records key",
    "key": "d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4",
    "actions": [
        "search"
    ],
    "indexes": [
        "patient_medical_records"
    ],
    "expiresAt": "2023-01-01T00:00:00Z",
    "createdAt": "2022-01-01T10:00:00Z",
    "updatedAt": "2022-01-01T10:00:00Z"
}

```

A user could then supply this key to make search requests on the `patient_medical_records` index:

```bash
curl \
    -X POST 'http://localhost:7700/indexes/patient_medical_records/search' \
    -H 'Content-Type: application/json' \
    -H 'Authorization: Bearer d0552b41536279a0ad88bd595327b96f01176a60c2243e906c52ac02375f9bc4' \
    --data-binary '{ "q": "trypophobia" }'

```

For more information, read our new guide to [securing a Meilisearch instance](https://meilisearch.org.cn/docs/learn/security/master_api_keys).

### Asynchronous operations

With v0.25, we refashioned Meilisearch's asynchronous operations from the ground up, replacing the `updates` API with the new `tasks` API.

In a related change, creating, updating, and deleting indexes are now asynchronous operations. This fix eliminates the potential for race conditions.

Before v0.25, any request handled asynchronously (e.g. adding documents) returned an `updateId` for tracking the status of the operation:

```json
{ "updateId": 1 }

```

After v0.25, asynchronous operations will now return a summarized version of the _task_ object:

```json
{
    "uid": 1,
    "indexUid": "patient_medical_records",
    "status": "enqueued",
    "type": "documentAddition",
    "enqueuedAt": "2021-08-10T14:29:17.000000Z",
}

```

You can get the full _task_ object—and the current status of the operation—using the `/tasks` route.

```bash
curl \
    -X GET 'http://localhost:7700/tasks/1'
    
```

**Response: `200 Ok`**

```json
{
    "uid": 1,
    "indexUid": "patient_medical_records",
    "status": "succeeded",
    "type": "documentAddition",
    "details": { 
            "receivedDocuments": 1,
            "indexedDocuments": 1
    },
    "duration": "PT1S",
    "enqueuedAt": "2021-08-10T14:29:17.000000Z",
    "startedAt": "2021-08-10T14:29:18.000000Z",
    "finishedAt": "2021-08-10T14:29:19.000000Z"
}

```

Here the task has succeeded. Other possible statuses for a task are `enqueued`, `processing`, or `failed`.

When a task fails, Meilisearch returns an `error` object as part of the response:

```json
{
    "uid": 2,
    "indexUid": "patient_medical_records",
    "status": "failed",
    "type": "documentAddition",
    "details": { 
            "receivedDocuments": 1,
            "indexedDocuments": 0
    },
    "error": {
        "message": "Document does not have a `:primaryKey` attribute: `:documentRepresentation`.",
        "code": "internal",
        "type": "missing_document_id",
        "link": "https://docs.meilisearch.com/errors#missing-document-id",
    },
    "duration": "PT1S",
    "enqueuedAt": "2021-08-11T14:29:17.000000Z",
    "startedAt": "2021-08-11T14:29:18.000000Z",
    "finishedAt": "2021-08-11T14:29:19.000000Z"
}

```

For more information, check out the [Asynchronous operations](https://docs.meilisearch.com/learn/advanced/asynchronous_operations.html) article or the [tasks API reference](https://docs.meilisearch.com/reference/api/tasks.html).

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

*   **Cross-version compatibility:** Meilisearch v0.25 and subsequent releases are incompatible with dumps created prior to v0.22.  
    To migrate a dump from pre-v0.22 to v0.25 Meilisearch, first load your dump into v0.24.0, create a dump using v0.24.0, and then import this dump into v0.25.0.
*   We have added several new error messages, most of which are related to managing API keys.
*   `matches` now highlights string and numeric values.
*   We added some new telemetry metrics.

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

A big thank you to all our contributors! This project couldn't get very far without your help.

Thanks to [@Mcdostone](https://github.com/Mcdostone) and [@Thearas](https://github.com/Thearas) for your help with Meilisearch, and to [@datamaker](https://github.com/datamaker) and [@Samyak2](https://github.com/Samyak2) for your help with our Tokenizer library.

* * *

If you want more details on updates we didn’t mention here, check out our [release changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.25.0).

Meilisearch 最新消息和公司动态

如何使用 Meilisearch 将相关搜索集成到 Strapi v4 中

我们的首个 SaaS 产品：Meilisearch Cloud 背后的故事

如何在您的多租户应用程序中使用 Meilisearch

我们支持团队成员心理健康的第一步

如何使用 Meilisearch 为您的 Gatsby 项目添加搜索栏

v0.26 有什么新变化

在 Meilisearch 启动知识管理

Meilisearch 获得 500 万美元种子轮融资，旨在改变面向用户的搜索世界

v0.25 有什么新变化