[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)

Hacktoberfest 2021 recap

One of the main responsibilities of the developer relations team at Meilisearch is to help our open-source search engine reach as many developers as possible. This involves, among other missions, participating in conferences and events.

Conference organizers usually publish a Call for Papers / Proposals (CFP), which is an open invitation for speakers to apply to their event, usually with a title and an abstract at minimum. Over the last year, I’ve had to submit—or help colleagues submit—numerous talk suggestions to conferences. Being a novice in the field, I set out to discover some of the secrets to successfully responding to a CFP.

I read a lot of articles and even listened to an hour-long presentation about CFPs so you don’t have to 🙌 In this article, I’ll present what I’ve learned based on the most recurrent recommendations.

The abstract
------------

The abstract is your pitch, it’s what is going to be published. You should focus on this first as it is what helps people decide if they want to attend your talk.

### ✅ Do's

**Be direct and concise**

Put yourself in the evaluator’s shoes. If you have 100 submissions to go through, you’ll appreciate the ones which get straight to the point. You should make your abstract easy to skim-read.

**Target your audience**

You need to know your audience,  their needs, and interests. Are you going to talk to developers, designers, executives, or some other audience?

Ok, but if it’s your first time attending a particular conference, how do you get this information?

Well, sometimes conference organizers provide an audience profile. But if it’s not the case, here are some good tips by the great [VM Brasseur](https://twitter.com/vmbrasseur):

*   you can contact them and ask for it

If it’s too late for that:

*   check the sponsorship prospectus: there’s usually information about the audience
*   check the schedule and social media of past editions of the event

**Establish a challenge or a problem**

Your talk should be about something that interests you. It could be a problem you’ve had, or that you’ve helped someone with. It doesn’t matter so much if you have managed to solve the problem or not. You can share your experience and what you’ve learned from it.

It can also be a widespread opinion you disagree with, a tool that has helped you, or something you wish you had known when you started.

Don’t forget, people like hearing stories, so if you think it’s something worth sharing, go for it. If you're not sure, assume that your story may be interesting to others. So go for it, what's the worst that can happen? Either way, try to present it in a way that gets your audience's interest, that’s why it’s important to know who you are going to be talking to.

**Specify the format of the talk you are giving**

The potential audience wants to know what to expect: is it going to be a workshop, a case study, a live demo? We all have different learning styles. Knowing the format beforehand will help the conference participants select the right talk for them.

**Specify the background knowledge the audience should have**

Should the audience know a particular programming language? Is it suitable for beginners? Giving this type of information will avoid wasting the time of the attendees.

**List key takeaways for your audience**

There is a statement from Sarah Mei that stuck with me:

> _People don’t go to talks for the content. People go to talks because they think they’ll become more badass. So help them out with that!_

People want to know what they will learn from your talk, the specific benefits they’ll get from it, what they will be able to do after your talk that they could not do before.

### ❌ Don'ts

**Don’t pitch your company / organization / product**

Nobody wants to hear a sales pitch. Your proposal will be rejected if it looks like a commercial in the slightest.

If you want to talk about something cool your company does, focus on the problem solved.

A little trick is to do what the dotConferences organizers have named the _Steve test_. Imagine an attendee named Steve, seated at the front row. Steve is so stubborn you know he would never use your product. The challenge is to make your talk as engaging and insightful to Steve as to anyone else. It will only work if you focus on the technical insights rather than your product. You can include your product along with alternative solutions and present the benefits and downsides.

**Don’t be aggressive or condescending**

Please have your abstract reviewed by a colleague or friend, preferably a native speaker. Someone who might identify this kind of language or tone you may not have intended to have.

**Don’t present your solution as the perfect one**

Be humble. You may have a great solution, but it cannot fit every need and context. You don’t want to sound arrogant so talk about when your solution is appropriate and when it’s not.

**Don’t include identifying information (name, title, company)**

This information belongs in the bio, not in the abstract. A lot of conferences practice blind reviewing to ensure submissions are reviewed fairly, so if you don’t want your proposal sent back for modifications or rejected, it’s better to avoid sharing these details.

**Don’t deceive the participants**

Don’t make promises you are not going to fulfill. Maybe you will get more people to attend your talk, but at what cost? Leaving the audience with a feeling of disappointment?

#### Standard formula

If you are new to CFPs you may want to stick to the following structure when writing abstracts:

*   Start with a strong introductory sentence that grabs attention (why is your topic important or relevant)
*   Detail paragraph: specific points you are going to address, give people an idea of what to expect
*   List audience takeaways
*   Closing paragraph (if needed)

The title
---------

*   Write it at the end, once you have finished writing the abstract
*   Avoid jokes: you never know how they will be perceived
*   Be polite
*   You can go for clickbait, it works
*   Keep it short, less than 50 characters

In his 2016 “[_Three tips for getting a talk accepted at Fluent_](https://medium.com/@bentlegen/three-tips-for-getting-a-talk-accepted-at-fluent-9eff841efc54)”, Ben Vinegar, gives really good examples of how to modify titles to engage the audience and show your unique perspective:

> '_How to use Angular'_ can be transformed into '_How we use Angular at my organization'_.

> '_How to get involved in open source'_ can be tweaked to become '_How I got involved in open source and you can too'._

Points worth remembering
------------------------

*   You are trying to persuade people to spend X minutes of their time listening to your presentation
*   Bullet points and short paragraphs are your friends
*   Focus on the audience, use “you” sentences
*   People like real experiences about real people: tell a story, create a narrative
*   You don’t have to be an expert on the subject, but don’t suggest subjects you are not qualified to talk about
*   You are the expert on your own experience

Conclusion
----------

I hope you’ll find this article useful. Of course, there is no magic formula for your application to be accepted. There are a thousand reasons why your talk can be rejected, even if you have the best title and abstract in the world. But it’s always better to stack all the odds in your favor!

* * *

_Picture by [Etienne Girardet](https://unsplash.com/@etiennegirardet) on [Unsplash](https://unsplash.com/)_

CFPs: Writing Recommendations

In this new version of Meilisearch, we focused on improving our error handler and reviewing our data collection policy—but don't worry, we still managed to squeeze in quite a few quality-of-life updates. We'll go through the most important bits here, but you can check out the [full changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.24.0) on our GitHub release page.

Breaking change: Improved error handling
----------------------------------------

Our revamp of the error handler started with minor changes to field and value names: `errorCode`, `errorType`, and `errorLink` have been shortened to `code`, `type`, and `link` respectively, and the three possible values for `type` have been shortened to `invalid_request`, `internal`, and `auth`.

```JSON
 {
 "message": "authorization header is missing",
 "code": "missing_authorization_header",
 "type": "auth",
 "link": "https://docs.meilisearch.com/errors#missing_authorization_header"
 }
```

In a related change, the update response in case of an error has been altered.

```JSON
{
 "status": "failed",
 "updateId": 1,
 // ...
 "error": {
	 "message": "Document `:documentId` not found.",
 	"code": "document_not_found",
 	"type": "invalid_request",
 	"link": "https://docs.meilisearch.com/errors#document_not_found"
 },
 }
```

**Instead of being located directly in the body, error fields are now located in a nested error object.**

Most importantly, we added new error codes and changed some old ones to make resolving errors faster and more intuitive. [Take a look at our release changelog for a more detailed list of updates](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.24.0).

Breaking change: `attributesToHighlight` now works on numeric values
--------------------------------------------------------------------

When you use the [`attributesToHighlight`](https://www.meilisearch.com/docs/reference/api/search#attributes-to-highlight) search parameter in your query, returned documents will include a `_formatted` object containing matching query terms wrapped in `` tags.

Starting with v0.24, `attributesToHighlight` works with both strings and numeric values. This means numbers inside `_formatted` will be automatically converted to strings:

```sh
curl \
 -X POST 'http://localhost:7700/indexes/games/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{ "q": "101", "attributesToHighlight": ["id, title, description"] }'
```
```JSON
{
 "id": 101,
 "title": " The Wonderful 101: Remastered",
 "description": "Lead an army of 101 Wonderful Ones from around the world in this Unite Action game!",
 "_formatted": {
 "id": "101",
 "title": " The Wonderful 101: Remastered",
 "description": "Lead an army of 101 Wonderful Ones from around the world in this Unite Action game!"
 }
}
```

Telemetry page update
---------------------

By default, we collect usage data from all Meilisearch instances that do not explicitly opt out.  A few releases ago, we [added an article to our documentation website](https://www.meilisearch.com/docs/learn/what_is_meilisearch/telemetry) describing why and how we collect usage data from Meilisearch instances. With v0.24, we have expanded that article to include [an exhaustive list of all the collected data points](https://www.meilisearch.com/docs/learn/what_is_meilisearch/telemetry#exhaustive-list-of-all-collected-data).

As part of this renewed commitment to data transparency, we have also put in place a process for users to request the deletion of their collected data. Simply drop us a message at [privacy@meilisearch.com](/blog/p/49021b33-6bd0-45b6-b3d8-2b962acbaae9/privacy@meilisearch.com)ncluding your instance's UID and we'll remove everything from our records, no questions asked.

Privacy is a difficult subject in tech and there is no shortage of companies who repeatedly violate it out of carelessness or because they stand to profit from unethical data harvesting. We hope to speak more about this in an upcoming blog post, but the important thing to know is that we believe honest and constant communication about these issues is the only way to ensure your data is safe and properly handled. If at any time you feel something looks odd or suspicious, you can use the [privacy@meilisearch.com](/blog/p/49021b33-6bd0-45b6-b3d8-2b962acbaae9/privacy@meilisearch.com)ddress to contact us and hold us accountable.

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

* Performance improvements related to the \`attribute\` ranking rule
* Maximum attribute size increased from 1000 to 65535 positions
* Fixed erroneous CSV Content-Type error message
* Improved error handling when importing an empty dump
* Fixed indexation performance when using mounted disks

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

Not going to lie, this is our favourite part of the release blog post: thanking everyone who has dedicated their time to improving Meilisearch. You're all wonderful 🤩

This month, we'd like to give a special shout out to [@Jhnbrn90](https://github.com/Jhnbrn90), [@nav1s](https://github.com/nav1s), [@nfsec](https://github.com/nfsec), [@patrickdung](https://github.com/patrickdung), [@sanders41](https://github.com/sanders41), [@CNLHC](https://github.com/CNLHC), [@fumblehool](https://github.com/fumblehool), and [@palfrey](https://github.com/palfrey).

* * *

That's it for this release. If you want more details on updates we didn't have the time to mention here, do check out our [release changelog](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.24.0).

See you next month for v0.25!

Meilisearch latest news and company updates