### \***\*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?_

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://nodejs.org/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://www.docker.com/): 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://www.meilisearch.com/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://www.meilisearch.com/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.org/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://www.meilisearch.com/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://www.meilisearch.com/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).

What's new in v0.25

When your office changes from a physical place to a virtual space, there comes a time when you realize an important member of your team is missing. It may not be apparent at first—the feeling comes gradually.

After counting everyone twice and checking that we hadn’t mislaid our COO in the wilderness, we had to face the facts.

What we had lost was our coffee machine.

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

The deserted kitchen at Meilisearch's parisian office

With it, we lost the informal discussions we used to have in our kitchen looking out on the rooftops of Paris. The small details of our coworkers' lives we learned day by day, the discoveries—that another team slew a bug, or that someone had a ready-made answer to a question bothering you: all these pouches of intimacy and shared knowledge had to be created anew.

Meilisearch veterans had a structure to fall back on, but **for new arrivals, this level of trust had to be built from scratch, without a physical office**. In this article, we'll take you with us on that journey and explain how we encourage informal discussions at Meilisearch.

We pay special attention to our onboarding process
--------------------------------------------------

**We try to make sure each new member of the team feels welcome on their first day.** We want to take away as much stress and awkwardness as we can to make the first few weeks as smooth as possible.

Before the start of the contract, we schedule meetings with each and every person in the team. **The lineup of the calendar for the first two weeks is already clear**: our priority is for new Meilisearch members to chat with everyone. They typically last 25 to 50 minutes and can be with 1–3 persons at a time. The goal of these meetings is for everyone to explain what they do at Meilisearch of course, but also to break the ice for further discussion down the line: it's the mixing of the coffee beans!

In between chatting with their new coworkers, the new recruits can read our Team Page on Notion. **Each person has a detailed profile** with their communication preferences and their preferred work style, their quirks and the qualities they value, what may drive them nuts and what people might misunderstand about them.

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

To be or not to be, that is the question

Each member can then share anything they like about them. We believe our biographies are a concentrated dose of a few months of small talk, all in one place!

We create dedicated spaces in our chat and schedules
----------------------------------------------------

**We are very proud of our team: it’s a collection of people with diverse interests and backgrounds.** We believe this stems from our roots at Ecole 42, but that’s a subject for our next blogpost! This makes our discussions interesting and sundry.

Our Slack channels reflect some of that range: we have channels dedicated to cats, food, cinema, games, music, books and of course: the #**random** channel! This is where we speak of our travels, share photos of the first snow, and recommend pieces of content that we enjoyed. We even developed an emoji-rating system for movies and cultural experiences!

Any Meilisearch employee who wishes to can join the Random Coffee channel and **be randomly matched with another person for a coffee later that week**. It's a time to chat about anything and everything—the brewing time.

We use huddles on Slack for weeklies and other meetings. But sometimes, we need a [rubber duck](https://en.wikipedia.org/wiki/Rubber_duck_debugging) who talks and listens to us rather than the written chat! Our team is most fond of Discord and coding together with their mics on.

We organise special events
--------------------------

We started doing after-work hangouts on Zoom during the first lockdown in France. Then there was a slight decline… until we realized we really missed them! **These events are not mandatory.** We play games together: Skribbl, Gartic Phone, Codenames… and anything we feel like!

Twice a year, we also have our in-person get-togethers: the offsites! **We strive to make them a comfortable and enjoyable experience for everyone, accommodating people’s needs and leaving plenty of pockets of free time.** We share some experiences and have fun together. These are our coffee add-ons: the milk, cream, glitter, and sprinkles on top!

We're always chasing the perfect blend
--------------------------------------

We believe Meilisearch as an organisation has a responsibility to build and provide the space and tools to make communication possible. **But we also firmly believe that the next step is giving the wheel to our team members and trusting them to have the discussions they want.**

We are always testing and researching ways to give our team members a leg up on the long process of building connections. As such, we expect to release a part two of this blog post as soon as we discover new flavors to add to our coffee mix!

P.-S. The Team Tea of Meilisearch wishes to reassure any future coworker that yes, we do have tea, and no, we aren’t all coffee maniacs.

Let it brew: how we create space for casual conversation within our remote team

For the second year in a row, Meilisearch participated in Hacktoberfest. Find below the recap of the event that was initially shared internally at Meilisearch.

We'll be part of Hacktoberfest 2022! And we hope to see even more contributors getting involved.  
  
Find below the slides of this presentation:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Meilisearch latest news and company updates