[Bookshop.org](https://bookshop.org/) is an online bookstore based in Brooklyn, New York, with a mission to support local, independent bookstores financially. By design, Bookshop.org gives away over 80% of its profit margin to stores and affiliates of stores: publications, authors, and others who make up the thriving, inspirational culture around books. As more and more people buy their books online, Bookshop.org creates an easy, convenient way for customers to get books and support local bookstores at the same time.

**By partnering with Meilisearch Cloud, the Bookshop.org team can enjoy improved search relevancy, reduce maintenance and operational costs and have its engineering team focus on its core business.**

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

The search experience on Bookshop.org

<Callout>
  _"With our prior search engine (Elasticsearch), **14% of searches resulted in a purchase, and with Meilisearch, 20% of searches currently result in a purchase**. That's a huge improvement without a lot of development time: **1 out of 5 customers found the book they were looking for and purchased it.**"_  
\- _Andy Hunter, CEO at _Bookshop.org__
</Callout>

Challenge
---------

Bookshop.org carries an impressive inventory of over **six million books**. It’s essential for the customer experience that anyone searching for a specific book on the website can find it as fast as possible. A considerable number of books available in the inventory means a proportionally high amount of items that need to be **indexed and ranked in the search** by the internal team.

> You only get one shot at it. We have a lot of visitors that care enough about their communities and ethical consumption - those buyers are specifically choosing to use Bookshop, and **we have to make sure that they can find a book as easily as they could find it in other major bookstores or else we're gonna lose them**.

_\- Mason Stewart, CTO at Bookshop.org_

Prior to switching to Meilisearch, Bookshop.org was utilizing a search engine solution provided by [Elasticsearch](/blog/why-should-you-use-meilisearch-over-elasticsearch?utm_campaign=bookshop_story&utm_source=blog However, with a small team of eight engineers and many unique customers, Bookshop.org needed **a solution that would require less maintenance and fine-tuning**. Additionally, a more streamlined solution would enable workers across the company to contribute to the ranking rules and configurations, improving the search relevancy on a rolling basis.

Why Bookshop.org chose Meilisearch
----------------------------------

**1\. A streamlined process that keeps the decision-makers involved**

For the Bookshop.org team, the advantage of Meilisearch lies in its simplicity and ease of use, making it possible **for decision-makers and non-developers to be very close to the ranking rules**. This was necessary to accommodate the ever-changing book search criteria during the busy holiday period and keep the search results relevant at all times.

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

___\-_ Mason Stewart, CTO at Bookshop.org__

**2\. Quick iterative product cycle**

The Bookshop.org team also highlighted the quick iterative cycle that has enabled them to solve issues faster. Bookshop's team can directly interact with the Meilisearch team whenever they need to resolve issues or introduce quick fixes. According to CTO Mason Stewart, the company values the combined agility of a compact search engine backed up by a highly responsive team.  
  
**3\. Ability to outsource hosting and infrastructure maintenance to the Meilisearch team**

Ensuring stability in search is essential for the success of the Bookshop.org business. After meeting and interacting with the Meilisearch team, the CTO felt confident in **entrusting them to manage their Meilisearch servers** through the Cloud offer.

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

_\- Mason Stewart, CTO at Bookshop.org_

By transitioning from the open-source version of Meilisearch to Meilisearch Cloud, the Bookshop.org team can now concentrate on its primary operations while delegating the management of the search infrastructure to experts.

**4\. Ability to support the scale and business model fit**

The Bookshop.org’s extensive inventory, coupled with a high amount of monthly users, made some pricing models that exist on the market untenable for the bookstore’s distinct business model. For a business with low margins, very high volume searches, very high volume users, and a high number of documents, Meilisearch proved to be a perfect fit.

Implementation
--------------

After reassessing its main challenges with book search, the Bookshop.org team conducted research and evaluated alternative solutions to address their need for a more user-friendly search solution that requires less maintenance. They came across Meilisearch, which was recommended on a popular tech news discussion platform. A quick test environment was set up out of the box, and the team found that Meilisearch was a good fit as the test continued. The CTO and engineers presented the working prototype to the management, and it was decided to implement Meilisearch before the holiday season, which typically starts at the end of the year. **The timing was crucia**l, as the end-of-year seasonal influx in sales brings a lot of increased consumer activity and a significant portion of profits for a bookseller as a result of it.

The initial demo included connecting Meilisearch to a book catalog and was quick and easy. Then followed the process of balancing and ranking the data that should inform the quality of a result internally, weighing different factors such as how recently the book was sold or how long ago it was published. The team acknowledged that the transition to Meilisearch would have been seamless if a clean data catalog had existed beforehand.

The process of changing the ranking rules to keep the book search relevant for shoppers is very streamlined. Suppose they want to rank a book's description higher or lower in the ranking rules. All they need to do is move it up or down, reindexing the entire catalog and making any change easy. Having global ranking rules that apply to the entire database proved healthy for a small team that needs to understand how one change can impact search across the repository.

> ___After a few weeks of tuning the rules, we've introduced almost no changes. It's been just about perfect.___

___\-_ Mason Stewart, CTO at Bookshop.org__

To add to the vision of the future with Meilisearch, the Bookshop.org team mentioned that having a multi-index search would be the next most important thing to improve the search experience of the website visitors. Say, a website visitor searches for a specific _keyword_ in a search bar. Multi-index search allows the engine to perform concurrent searches across multiple sources. To that extent, Meilisearch is happy to announce the release of the [federated search](/blog/whats-new-in-v1-1) in v1.1 as an additional step in boosting user experience and increasing relevancy for Bookshop.org clients.

Results
-------

With an initial Meilisearch deployment, the team could compare the search performance to the metrics they were getting with a previous Elasticsearch configuration.

By bringing Meilisearch to the table, the team introduced a straightforward configuration process, removing the need to increase the team’s bandwidth or expertise. **With Elasticsearch, 14% of searches resulted in a purchase. With Meilisearch, that number jumped to 20%,  increasing overall conversion by 43%**.

Bookshop.org increases search-based purchases by 43% with Meilisearch

Hi 👋 I'm Ingrid. Not that long ago, I was in your position. I was searching for a new job and had to navigate these waters. Job interviews are a difficult reef to get through!

Now I’m a Talent Acquisition Manager at Meilisearch. Though I’m on the other side of the process now, it was my experience as a candidate for Meilisearch that made me want to join the company. During my first interview, it became clear that Meilisearch strives for transparency, openness, and authenticity. As a candidate, I could already imagine what it could be like to work there.

An important part of my role today at Meilisearch is to be the safekeeper of the recruitment process. Our goal is to hire people who are the best possible match for us, in a reasonable amount of time, while providing candidates with a great experience.

I have spent time designing our recruitment process. For us, what you value in work is as important as your technical skills, if not more so. This is why I am iterating more specifically on steps that will help us assess if candidates share our core values.

So how do we assess this crucial, but apparently very subjective characteristic? What does “value-fit” even mean? In this blog post, I will explain this specific aspect of the interview process, how we assess the value-fit generally, and tips on how you can prepare yourself as a candidate.

What does value-fit mean?
-------------------------

You’re probably like me: when you apply for a job, you want your values to be shared by the company. Since joining Meilisearch in October 2022, I have observed that value-fit is mainly about ways of collaborating. When assessing value-fit, we focus on how your work style aligns with our values and culture. Additionally to questions about your experience and technical skills, we ask questions about your communication style, work preferences, and [interpersonal skills](https://www.coursera.org/articles/interpersonal-skills). This will help us clarify your compatibility with the future team and our values.

We defined [our values](https://www.welcometothejungle.com/en/companies/meilisearch/values) in 2020. We chose to put forward characteristics that represent us individually and collectively. These values might mean completely different things in other companies, and we have tried our best to describe our work values at Meilisearch.

Our values serve as the basis for our strategic decision-making and impact our company’s culture and individual behaviors. We use them in our career review process, in the objectives that we set for ourselves, and, as you may have understood, in our recruitment processes.

The term “value-fit” itself can be subject to misconceptions, especially the fact that value-fit in people's minds means recruiting people who look like us or share the same interests. For us, it is rather the opposite. We are looking to hire _outside_ of groups of people who are similar to us.

We acknowledge the importance of inclusivity, and we believe that hiring for value-fit supports diversity. [Studies have shown](https://hbr.org/2019/09/hiring-for-culture-fit-doesnt-have-to-undermine-diversity) that people with similar values and work styles are more likely to collaborate effectively, leading to improve teamwork, communication, and problem-solving.

It doesn't matter if we don't have the same background if we're trying to hit the same goal.

How do we assess value-fit?
---------------------------

As a candidate interviewing for a full-time position, you should expect 4 to 5 steps: meeting with a recruiter, the hiring manager, a skills assessment, a team-fit interview, and reference checks.

Evaluating value-fit is not a question of intuition or feeling, which is why we have integrated value-based questions into every step of the recruiting process.

Value-based questions are behavioral questions, that showcase how you handled different work situations in the past. As a recruiter, when I ask a value-based question, I’m looking to get a better understanding of you as a team member.

Depending on the role you are applying for, we identify different skills and abilities stemming from our values.

Here are a few examples of value-based questions:

*   ___Please tell us about a time when someone took a decision you didn’t agree with, in your previous job. What did you do? Looking back, what do you think about this decision now?___

The goal of this question is to gather a specific example of how you handle disagreement with colleagues. At Meilisearch we value the [disagree and commit](https://handbook.meilisearch.com/guide/values.html#our-values:~:text=We%20disagree%20and%20commit) principle. For example, if you join our engineering team you will see that people thrive on input from everybody and openly share their opinions and objections, without letting this difference become an obstacle and stop the team from moving.

*   _Please tell us about a time when you didn’t have the knowledge/experience to work on a task, what did you do?_

Team members at Meilisearch [find solutions together](https://handbook.meilisearch.com/guide/values.html#our-values:~:text=support%20we%20bring.-,We%20find%20solutions%20together,-One%20thing%20we), and are not afraid to ask for help when they don’t know. With this question, we try to assess your ability to collaborate and share knowledge.

Some preparation is necessary when getting ready for a value-fit interview. We want to give candidates all the information they need to succeed in their interviews. Below are some guidelines to help you.

How can you prepare to answer value-based questions?
----------------------------------------------------

Figuring out how to showcase your soft skills before an interview can be challenging but should not be underestimated. When you’re clear about what you value in work, you can’t lose; this will help you find a company where you’re happy to work, and showing you’ve prepared for these questions can make a big difference in the eyes of interviewers.

Here are a few tips:

*   Before the interview, **research our** [**company's values**](https://www.welcometothejungle.com/en/companies/meilisearch/values); this will help you understand our company’s culture and what we stand for.
*   **Reflect on your values**: take some time to reflect on your own values and what is important to you. This will help you articulate your values and how they align with ours.
*   ******Practice answering value-based questions:** prepare concrete and meaningful examples of your past experiences, such as successful work collaboration or communication with your manager or team, how you received feedback, and what you learned from your mistakes.****
*   To answer behavioral questions, **use the** [**STAR method**](https://capd.mit.edu/resources/the-star-method-for-behavioral-interviews/); find a concrete example, and practice describing it in the following order: Situation, Task, Action, Result.
*   During the interview, **ask questions** about the team, our values, and how they are lived out in the workplace. This will help you understand our company's culture and values better.
*   Keep in mind we are not looking for a 100% match with our values. No one at Meillisearch matches our values 100%. In recruitment, unless we spot really big red flags, what we are ultimately looking for is a good balance between what you value in work, and what you know how to do.

To make sure we get a clear view of what those are, we will do our best to make you feel as comfortable as possible and to give you all the information you need to succeed in your interviews. We truly believe that candidates who are well prepared and in excellent interviewing conditions will better show who they are, which is ultimately what we’re _really_ interested in.

Conclusion
----------

As a recruiter, I can tell you that value-fit is critical in the recruitment process, and it goes beyond technical skills and experience. From my personal experience as a candidate, I know how important it is to assess how your work style aligns with a company's values and culture. That's why, at Meilisearch, we are committed to hiring people who share our core values while promoting inclusivity and diversity.

Interviewing at Meilisearch is a two-way process, it is not only meant for us to get to know you but also for you to understand if our work environment would suit you and a place for you to grow.

Have a look at our [open positions](https://jobs.lever.co/meili)! I’m looking forward to discussing all of this with you in person 😉

A recruiter's advice on how to answer interview questions about values

[Meilisearch v1.1](/blog/whats-new-in-v1-1/?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search) introduces the `/multi-search` [endpoint](https://docs.meilisearch.com/reference/api/multi_search.html?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search#multi-search). With this endpoint, users can now send multiple search queries on one or more indexes by bundling them into a single HTTP request. Essentially, the `/multi-search` endpoint paves the way for [federated search](/blog/what-is-federated-search/?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search)

<Callout>
  [Federated search](/blog/what-is-federated-search/?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search) is available in [Meilisearch 1.10](/blog/release-1-10/?https://blog.meilisearch.com/what-is-federated-search/?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search) and highger.
</Callout>

Multi-index search with Meilisearch
-----------------------------------

With 277 votes, federated search was one of the [most requested features](https://roadmap.meilisearch.com/c/74-multi-index-search?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search). We are glad to finally announce the first stage of the feature.

We have introduced a `/multi-search` route that allows searching in multiple indexes with a single HTTP request. Suppose we have two indexes: `movies` and `actors`. Using the `/multi-search` endpoint, we can search for the name of an actress and retrieve both her biography and movies in the search results.

Take, for instance, the following multi-search request:

```bash
curl \
-X POST 'http://localhost:7700/multi-search' \
-H 'Content-Type: application/json' \
--data-binary '{
  "queries": [
     {
       "indexUid": "movies",
       "q": "Kate Winslet",
       "limit": 1
     },
    {
       "indexUid": "actors",
       "q": "Kate Winslet",
       "limit": 1
    }
  ]
}'
```

The response will include a set of search results for each index searched:

```JSON
{
   "results": [
     {
       "indexUid": "movies",
       "hits": [
         {
           "title": "The Reader",
           "overview": "The story of Michael Berg, a German lawyer who, as a teenager in the late 1950s, had an affair with an older woman, Hanna, who then disappeared only to resurface years later as one of the defendants in a war crimes trial stemming from her actions as a concentration camp guard late in the war. He alone realizes that Hanna is illiterate and may be concealing that fact at the expense of her freedom.",
           "crew": [...],
           "cast": [
		...
             {
               "character": "Hanna Schmitz",
               "name": "Kate Winslet",
               "profile_path": "/e3tdop3WhseRnn8KwMVLAV25Ybv.jpg"
             },
		...
           ]
         }
       ],
// other search results fields: processingTimeMs, limit, ...
     },
     {
       "indexUid": "actors",
       "hits": [
     {
       "name": "Kate Winslet",
       "known_for": [
           "Titanic",
           "Eternal Sunshine of the Spotless Mind",
           "The Reader"
       ],
       "birthday": "1975-10-05",
       "deathday": null,
       "biography": "Kate Elizabeth Winslet (born 5 October 1975) is an English actress. Known for her work in independent films..."
     }
       ],
	// other search results fields: processingTimeMs, limit, ...
     }
   ]
 }

```

As you can see, in the results array, the indexes are sorted in the same order as in the query. The response contains the [usual fields](https://docs.meilisearch.com/reference/api/search?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search#response) that a conventional search returns along with the index UIDs. Note that, we restricted the number of documents returned to just one using the `limit` parameter in this example.

Multi-index search demo
-----------------------

![Searching for 'Kate Winslet' returns both her biography and movies in which she starred, while searching for 'Titanic' returns the movie itself as well as actors who starred in it.](https://unable-actionable-car.media.strapiapp.com/ezgif_com_optimize_1_da861cfac7.gif)

[Try it](https://federated-search.meilisearch.com/?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search) yourself!

This demo uses two datasets: movies and actors. Each dataset is stored in its own index, has its own settings, and, as you can see in the example above, its own schema.

Since the two indexes have different schemas, they have different [searchable attributes](https://docs.meilisearch.com/learn/configuration/displayed_searchable_attributes?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search#the-searchableattributes-list). In the movies index, you can search for a movie by its title, characters, actors, producers, directors, or movie overview.

```JSON
//movies index 
searchableAttributes: [
   'title',
   'crew.name',
   'cast.name',
   'cast.character',
   'overview',
 ]
```

The actors index allows you to search for actors by name, as well as the movies or shows they are most known for, and by keywords found in their biographies.

```JSON
//actors index 
searchableAttributes: ['name', 'known_for', 'biography']
```

The full list of settings, dataset, and code are all available on [GitHub](https://github.com/meilisearch/demos/tree/main/src/federated-search/), so feel free to explore them on your own. Don't hesitate to play around with the settings to customize the behavior to your needs. If you have ideas for improving the demo, like adding facets, don't hesitate to submit a pull request. All contributions are welcome!

Conclusion
==========

We are excited to deliver this first iteration of federated search, and we’ll be working hard to push toward aggregated search results. We couldn't have achieved this without the valuable feedback and insights provided by our developer community. Your feedback has been instrumental in helping us prioritize and shape the feature to meet your needs.

If you're interested in keeping up with our progress, we encourage you to check out our [product roadmap](https://roadmap.meilisearch.com?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search), join our [discussions](https://github.com/meilisearch/product/discussions) on GitHub, or connect with us on [Discord](https://discord.meilisearch.com/?utm_campaign=federated-search&utm_source=blog&utm_medium=introducing-multi-search).

As always, we are committed to providing our users with the best possible search experience and appreciate your help in achieving this goal.

Introducing multi-index search

Let's take a look at some of the most significant changes in Meilisearch's latest update. We’ll go over the main changes in this article, but you can also view the [full changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.1.0) on GitHub.

New feature: multi-search API endpoint
--------------------------------------

With the introduction of the `/multi-search` API endpoint, Meilisearch allows you to send multiple search queries using a single HTTP request. This will allow you to accomplish a number of different things, like federated search and multi-select facets!

### Federated search

Suppose you have two distinct datasets: “brands” and “products”. Wouldn’t it be convenient if you could search for both at once while keeping them separate in their respective indexes? You can perform a federated search, also known as multi-index search, by querying multiple indexes:

```bash
curl \
-X POST 'http://localhost:7700/multi-search' \
-H 'Content-Type: application/json' \
--data-binary '{
  "queries": [
     {
       "indexUid": "products",
       "q": "Nike",
       "limit": 1
     },
    {
       "indexUid": "brands",
       "q": "Nike",
       "limit": 1
    }
  ]
}'

```

The response is a `results` array containing one object for each queried index:

```JSON
{
 "results": [
   {
     "indexUid": "products",
     "hits": […],
     "query": "Nike",
     "processingTimeMs": 1,
     "limit": 1,
     "offset": 0,
     "estimatedTotalHits": 17
   },
   {
     "indexUid": "brands",
     "hits": […],
     "query": "Nike",
     "processingTimeMs": 0,
     "limit": 1,
     "offset": 0,
     "estimatedTotalHits": 7
   }
 ]
}

```

### Multi-select facets

The multi-search requests API is particularly useful when it comes to implementing multi-select facets behavior in a faceted search interface.

Multi-select facets, also called disjunctive facets, allow users to view items that meet multiple criteria at the same time. This type of interface also shows the number of items available for each option, even if these items have not been selected. This allows for fast and efficient exploration of items that meet your users’ specific criteria, ultimately saving time and effort.

![](https://lh5.googleusercontent.com/HMSHnrtzKaXnDTE1Wh2AH3KupbhGTEM7-xIEid8X7oKjgHF30bQfb07gkpMBc9vz0Bb07NfanDCUHWfBhq37sxP_L_KMPem-sUKuhZ2ZNfJQ-z_vmXJPIuVEDB6978G0kYTy76Vvcrqvd6Xp4tvW560)

Since multi-select facets operate according to the inclusive `OR` logic, computing them requires sending several queries to Meilisearch. Sending these queries separately can lead to reduced performance and potentially higher hosting service costs.

Using the `/multi-search` endpoint, you can send multiple queries to the same index in a single request, thereby optimizing performance and reducing hosting costs.

<Callout>
  Prior to v1.1, achieving disjunctive facets behavior with [Instant Meilisearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch) was possible but required making multiple requests to the API. This workaround is no longer necessary since Instant Meilisearch now uses the `/multi-search` endpoint.
</Callout>

Check our documentation to learn more about [multi-search requests](https://docs.meilisearch.com/reference/api/multi_search) and [faceted search](https://docs.meilisearch.com/learn/advanced/faceted_search).

New feature: \_geoBoundingBox
-----------------------------

A bounding box is a rectangular box that completely encloses an area. With the new `_geoBoundingBox` filter expression, you can search for results contained within a rectangular geographic area.

![](https://lh4.googleusercontent.com/YuchesiNXoIqJBYTcBTjVRUkuNiwTTn9xUG0ac7nvq8KDVIJH9sMmsBexIzyfbqfxjxUewijKk5XXIuUjEQPi7uozvu48lrF8XpYg_CC8VR7TU5qzdT2e8S3o06ahx05_THxQR4d0307Qevq9RQLoIQ)

It takes two parameters corresponding to the coordinates of the top right (northeast) and bottom left (southwest) corners of the desired area: `_geoBoundingBox([lat, lng], [lat, lng])`

```bash
curl \
-X POST 'http://localhost:7700/indexes/restaurants/search' \
-H 'Content-type:application/json' \
--data-binary '{ "filter": "_geoBoundingBox([45.472735, 9.184019],[45.473711, 9.185613] )" }'
```

Check our [guide](https://docs.meilisearch.com/learn/advanced/geosearch#filtering-results-with-georadius-and-geoboundingbox) on filtering results based on geographic coordinates.

New feature: introducing facetStats
-----------------------------------

When using the `facets` parameter in a search query, the search results object will now include a `facetStats` object that provides minimum and maximum values for each numerical facet. Any facets without numerical values will be omitted.

Given an index of products, suppose that you want to know the highest and the lowest price to implement a range slider component:

```bash
curl \
 -X POST 'http://localhost:7700/indexes/products/search' \
 -H 'Content-Type: application/json' \
 --data-binary '{
 "facets": ["price"]
 }'

```

You would get the following response with all necessary information ready to use:

```JSON
{
   "hits": […],
   "facetDistribution": {
     "price": {…}
   },
   "facetStats": {
     "price": {
       "min": 1.99,
       "max": 1898.28
     }
   }
 }

```

Experimental feature: systems monitoring with Prometheus
--------------------------------------------------------

This release introduces a new `/metrics` endpoint that provides data compatible with [Prometheus](https://prometheus.io/), an open-source systems monitoring and alerting toolkit. This experimental endpoint gives valuable insights into the behavior and performance of Meilisearch.

To enable it, use the `--experimental-enable-metrics` flag when launching Meilisearch.

Are you planning to use this feature? Tell us about your experience in the [GitHub discussion](https://github.com/meilisearch/product/discussions/625).

Improvement: removing limits on index size and count
----------------------------------------------------

Meilisearch has lifted restrictions on the number and size of indexes per instance, so you can create as many indexes as you need 🥳

The only limit now is the memory address space allocated to a single process by your operating system. Read more about this in the [documentation](https://docs.meilisearch.com/learn/advanced/known_limitations#maximum-number-of-indexes-in-an-instance).

Other improvements
------------------

*   You can now use wildcards (`*`) at the end of index names when managing API keys and tenant tokens. For example, `"medical*"` will match the `medical_records` and `medical_equipement` indexes
*   You can override the default CSV delimiter–a single comma (`,`)– using the `csvDelimiter` parameter of the [add or update documents](https://docs.meilisearch.com/reference/api/documents#add-or-update-documents) or [add or replace documents](https://docs.meilisearch.com/reference/api/documents#add-or-replace-documents) endpoints
*   Interleaved document addition and deletion tasks are now automatically batched together, speeding up the indexing process
*   Our fantastic community has helped us enhance support for Greek and Arabic languages
*   Language detection now happens at indexing time, reducing erroneous language recognition during search and thus improving relevancy

We are really grateful for all the community members who participated in this release. We would like to thank: [@akhildevelops](https://github.com/akhildevelops), [@AymanHamdoun](https://github.com/AymanHamdoun), [@cymruu](https://github.com/cymruu), [@FrancisMurillo](https://github.com/FrancisMurillo) [@GregoryConrad](https://github.com/GregoryConrad), [@gregsadetsky](https://github.com/gregsadetsky), [@james-2001](https://github.com/james-2001), [@MixusMinimax](https://github.com/MixusMinimax), [@waveywaves](https://github.com/waveywaves), and [@ztkmkoo](https://github.com/ztkmkoo) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch).

We also want to send a special shout-out to [@choznerol](https://github.com/choznerol), [@cymruu](https://github.com/cymruu), and [@james-2001](https://github.com/james-2001) for their work on [Charabia](https://github.com/meilisearch/charabia?ref=meilisearch-blog).

And that’s it for v1.1! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.1.0) for the full release notes. If you have any questions or would like to stay updated, you can join us on [Discord](https://discord.gg/meilisearch) or subscribe to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). You can also check out our [roadmap](https://roadmap.meilisearch.com/) and participate in our [Product Discussions](https://github.com/meilisearch/product/discussions) to help us improve.

What’s new in v1.1

Are you wondering if Meilisearch is the right choice for you? Well, don't worry! We're here to help make that decision a bit easier for you. In this article, we'll break down the main strengths and weaknesses of both search engines.

Why should I consider Meilisearch over Elasticsearch?
-----------------------------------------------------

If you are looking for a search engine that attempts to do everything from app search to log analytics, and you don’t mind spending the time and effort necessary to make it work for your search needs, then Elasticsearch might be suitable for you.

But if ease of use, performance, and relevancy are important to you, Meilisearch was made for you. Exhausted from scouring documentation pages to configure an extensive list of parameters just to deliver a decent search experience? We understand your frustration.

Let’s be honest, even if you have the most flexible and powerful tool in the world, it doesn’t count for much if it’s a pain to use and understand. That's why we made Meilisearch: to give developers the tool they need to create remarkable search experiences effortlessly.

Before making your decision, you need to understand the differences between the two engines and what you plan to use them for.

Understanding the key differences and their importance
------------------------------------------------------

Since its creation in 2010, Elasticsearch has quickly become a popular option in the search engine market, finding use in all kinds of applications and datasets. However, while it is undeniably a powerful tool for heavy full-text search, the need for extensive configuration before use means that all that power comes with a high resource cost.

Elasticsearch's open-source nature has played a significant role in its popularity and adoption. And, because historically there haven't been many open-source alternatives, developers continue to go for Elasticsearch as the default solution and wind up losing a disproportionate amount of time on setup and training.

This is where Meilisearch comes in. It’s an open-source, easy-to-use, fast, relevant, and typo-tolerant search engine that fits effortlessly into any app, website, and workflow. It works out-of-the-box with default settings that meet the needs of most projects, while also being highly customizable to meet individual needs.

What is Elasticsearch made for?
-------------------------------

Shay Bannon created Elasticsearch, a distributed search and analytics engine based on the [Apache Lucene library](https://lucene.apache.org/core/). Elasticsearch is now developed alongside other tools for data collection, analysis, and visualization. These products are designed to be used as an integrated solution called the "Elastic Stack".

### Key strengths

Elasticsearch’s main strengths lie in its flexibility and scalability, as well as its capabilities for aggregation and analysis.

**Flexibility**

Elasticsearch provides search and analytics for all types of data. It has extensive use cases spanning everything from simple site search, management and analysis of log data to endpoint security.

**Scalability**

Elasticsearch’s distributed architecture enables scalability by adding or removing nodes from the cluster, making it a suitable choice for managing large volumes of data.

**Aggregation and analysis**

Elasticsearch provides advanced aggregation and analytics capabilities that enable users to extract insights from their data and perform sophisticated analysis operations.

### Challenges

Elasticsearch is a very powerful tool, but it’s also a very complex one. It can be arduous to set up and maintain. Since there are no defaults for implementing a basic site or app search, it needs to be configured. While Elasticsearch has extensive documentation; there is a lot to learn before jumping into implementation, which can be daunting, especially for new users.

Before you can perform your first search, there are several parameters you'll need to set up, including relevancy or typo tolerance, a must-have in a modern app or site search. It can take some time to become familiar with the process.

Let's look at an example. Given [a dataset of news headlines](https://www.kaggle.com/datasets/rmisra/news-category-dataset), the request below asks for results containing “Khloe Kardashian Kendall Jenner” in the headline:

```JSON
GET news_headlines/_search
{
 "query": {
   "match": {
   "headline": {
       "query": "Khloe Kardashian Kendall Jenner"
   }
   }
 }
}
```

Here is Elasticsearch’s default response:

```JSON
{
   "_index": "news_headlines",
   "_type": "_doc",
   "_id": "E9CoJ3cBwsjPafpAr39g",
   "_score": 17.15928,
   "_source": {
       "_date": "2015-05-16",
       "short_description": "",
       "@timestamp": "2015-05-16T00:00:00.000-06:00",
       "link": "https://www.huffingtonpost.com/entry/kendall-jenner-kourtney-kardashian-height-difference_n_7297968.html",
       "category": "ENTERTAINMENT",
       "headline": "Kendall Jenner And Kourtney Kardashian Are Not Quite Twins In Hilarious Instagram Photo",
       "authors": "Lily Karlin"
   }
}
```

Contrary to what one might expect, the first result returned by Elasticsearch is not the most relevant; it only contains some of the search terms. As you can see in the \`headline\` field: it contains “Kendall Jenner”, which is expected, but instead of “Khloe Kardashian”, we find “Kourtney Kardashian”.

When a query contains multiple terms, users typically expect the search engine to prioritize results that contain all the terms rather than just some of them. In other words, users generally expect an "AND" operation rather than an "OR" when searching for multiple terms.

Elasticsearch’s match query uses the "OR" logic by default. If a document contains one of the search terms, Elasticsearch will consider that document as a hit. If we want all the query terms to be present, we have to add the [“AND” operator](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html#query-dsl-match-query-boolean) to the query, but we’ll get far fewer results.

The other option Elasticsearch provides to tweak the relevancy is to specify the minimum number of terms a document should have to be included in the search results with the \`minimum\_should\_match\` parameter.

That’s a lot of effort for something that should be quick and painless. And we are only talking about the very basics of search.

Moreover, querying for “Kardasian”—without the \`h\`— returns no results. This is because Elasticsearch doesn’t allow any typos unless we set an [extra parameter](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-match-query.html#query-dsl-match-query-fuzziness) called \`fuzziness\`.

We sent the same query—with a typo—to Meilisearch:

```JSON
POST /indexes/news_headlines/search
{ 
   "q": "Khloe Kardasian Kendall Jenner" 
}
```

With zero configuration, the first result returned by Meilisearch was:

```JSON
{
   "link": "https://www.huffingtonpost.com/entry/khloe-kardashian-licks-kendall-jenner-abs_us_559d7e27e4b05b1d028f98cf",
   "headline": "Khloe Kardashian Licks Kendall Jenner's 'Irresistible' Abs In New Instagram Photo",
   "category": "ENTERTAINMENT",
   "short_description": "Khloe and Kendall shared quite the intimate moment at the gym!",
   "authors": "Julia Brucculieri",
   "date": "2015-07-08",
   "id": 94869
}
```

As we saw earlier, achieving this level of relevancy with Elastic required adjusting several search parameters. So, just because you can do anything with Elasticsearch, doesn’t mean you should. In many cases, Elasticsearch might just be overkill.

What is Meilisearch made for?
-----------------------------

Meilisearch is an open-source, user-focused search engine written in Rust. It was created in 2018 to provide an accessible search solution designed to meet a vast majority of needs, with zero configuration required and a high degree of customization.

Meilisearch delivers an instant search experience, including powerful built-in capabilities such as [search-as-you-type](https://www.meilisearch.com/docs/learn/what_is_meilisearch/overview?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch&utm_content=search-as-you-type#features), [typo tolerance](https://docs.meilisearch.com/learn/configuration/typo_tolerance.html?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch), [faceted search](https://www.meilisearch.com/docs/learn/what_is_meilisearch/overview?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch&utm_content=faceted-search#features), [geo search](https://docs.meilisearch.com/learn/advanced/geosearch.html?utm_source=release-post&utm_id=v1-announcement&utm_content=geosearch), and [multi-tenancy](https://www.meilisearch.com/docs/learn/security/tenant_tokens?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch). Its [first major version was released](/blog/v1-enterprise-ready-stable/?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch)n early 2023, making it completely stable, forward-compatible, and enterprise-ready.

### Key strengths

Meilisearch focuses on simplicity, relevancy, and performance.

**Simplicity**

Meilisearch aims for a simple and intuitive experience for developers. It works out of the box with no configuration needed. But you can easily tailor it to your needs in just a few minutes, so you don't have to be a search expert to get the most out of Meilisearch.

**Relevancy**

Meilisearch provides a pre-configured set of ranking rules, delivering high relevancy right out of the box. These default settings were developed iteratively by working directly with the community and are suitable for most use cases. These rules can be customized to suit individual requirements.

**Performance**

Meilisearch aims to provide a search-as-you-type experience, returning results within a maximum of 50 milliseconds.

Challenges
----------

While it can handle a considerable amount of data, the open-source version of Meilisearch (self-hosted) may not be the best fit for applications requiring a distributed architecture to handle massive amounts of data across multiple nodes or clusters.

Meilisearch Cloud, on the other hand, already provides scalability and high availability with its [Pro and Enterprise plans](https://www.meilisearch.com/pricing?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch).

However, our team is currently [gathering feedback](https://github.com/meilisearch/product/discussions/617) to implement a distributed open-source Meilisearch in the near future.

Meilisearch is primarily designed to deliver performant instant-search experiences aimed at end-users and does not provide comprehensive data analysis features. While Meilisearch can help you search through your data and retrieve relevant results instantly, it has yet to offer advanced data analysis capabilities such as data visualization or statistical analysis. Meilisearch Cloud plans to provide similar features down the line, as you can see in its [roadmap](https://roadmap.meilisearch.com/c/129-search-analytics).

Meilisearch or Elasticsearch?
-----------------------------

Hopefully, it’s clear by now that one search engine is not better than the other. The most important factor lies in the purpose you are using it for. Both search engines have their strengths and weaknesses, and it is essential to understand them to make the right choice for your particular use case.

Meilisearch is not made to search through billions of large text files or parse complex queries. This kind of searching power would require a higher degree of complexity and lead to slower search experiences, which runs against our instant search philosophy. For those purposes, look no further than Elasticsearch; it’s an excellent solution for companies with the necessary resources, whether that be the financial means to hire consultants or the time and money required to implement it themselves.

Meilisearch is a perfect choice if you need a developer-friendly tool to effortlessly deploy a typo-tolerant search, intuitive for users and return results instantly with excellent relevance out of the box. It's ideal for on-site and in-app search, including [e-commerce](/blog/minipouce-top-grade-customer-experience/) [documentation](/blog/symfonys-solution-for-documentation-search/) and [content search](/blog/hugging-face-democratizes-ai/) * *

Learn more about what Meilisearch can bring to your business

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

* * *

Conclusion
----------

To recap, we have addressed both search engines' main strengths and weaknesses, but we have only scratched the surface. The capabilities of both search engines go far beyond what this article has covered. For a comprehensive comparison of Meilisearch with Elasticsearch and other search engines, please refer to the [dedicated section](https://docs.meilisearch.com/learn/what_is_meilisearch/comparison_to_alternatives.html?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch#comparison-table) in our documentation.

Do you want to see Meilisearch in action? Try our [demo](https://where2watch.meilisearch.com/?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch). You can also run it and start searching through your data in less than five minutes by following our [quick start guide](https://www.meilisearch.com/docs/learn/getting_started/cloud_quick_start?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-elasticsearch).

We continuously collaborate with the open-source community to develop new features and provide the best developer and search experience. See what's next on our [public roadmap](https://roadmap.meilisearch.com/)!

If you have any feedback or suggestions, please join our [Discord server](https://discord.gg/meilisearch) and have a chat with us!

Meilisearch vs Elasticsearch

A step by step guide to adding site search to your Nuxt ecommerce

We have just released our new version which development has been driven by our desire for simplicity of use.

We realized that some features were not easy to use because of design choices. The whole team gathered around the table and debated the API routes and their RESTfulness until everyone agreed on a proposal. We hope to strike a good balance between simplicity and customization.

So what is new in the v0.9?

*   Schema deletion!
*   Included web interface to try out your search
*   New settings handling
*   Simplified custom ranking rules
*   Added primary key
*   New built-in ranking rule names
*   Simplified authentication
*   Production and development mode
*   Bug fixes, syntax changes and, improvements

Schemaless
----------

The schemaless idea was in our mind for quite a while. When getting started, the user shouldn’t be required to specify how Meilisearch should handle every field, but only when their needs are really specific and out of the ordinary.  
Now, by default, Meilisearch will display every documents field, make them all searchable and will infer the document's primary key based on the provided documents structure.  
This solution causes way less friction when starting using Meilisearch.

Web interface
-------------

In the previous version, once you had started your Meilisearch engine and inserted some documents into it, the smooth experience stopped there. In order to try out the search, you had to either submit requests using curl or an SDK, either creating a front-end search bar connected to Meilisearch.

Now that a web interface is shipped with Meilisearch, all you need to do is open your web browser and enter Meilisearch’s address to visit it locally. This will lead you to a web page with a search bar that will allow you to search in a selected index.

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

Since the production environment requires an API-key for searching, the web interface is only available in development mode.

Settings
--------

Anything that isn’t necessary to make your Meilisearch instance up and running can now be configured in the settings.

For each setting there is a route, thus making it possible to only update a specific setting. The global setting route gives you the possibility to post a configuration file describing your customizations, which will facilitate the creation of similar Meilisearch instances based on the same settings.

#### Example

```json
{
  "rankingRules": [
      "typo",
      "words",
      "proximity",
      "attribute",
      "wordsPosition",
      "exactness",
      "desc(release_date)"
  ],
  "distinctAttribute": null,
  "searchableAttributes": [
      "title",
      "description",
      "uid"
  ],
  "displayedAttributes": [
      "title",
      "description",
      "release_date",
      "rank",
      "poster"
  ],
  "stopWords": null,
  "synonyms": {
      "wolverine": ["xmen", "logan"],
      "logan": ["wolverine", "xmen"]
  },
  "indexNewFields": false
}

```

[All the settings can be found here](https://docs.meilisearch.com/reference/api/settings.html)

Simplified custom ranking rules
-------------------------------

In the previous version, creating your own rules could be confusing. We simplified this task! All you have to do now is add an ascending (`asc()`) or descending (`desc()`) rule on one of your fields in the ranking rules list.

```json
 "rankingRules": [
      "typo",
      "words",
      "proximity",
      "attribute",
      "wordsPosition",
      "exactness",
      "desc(release_date)"
  ]

```

If you update your ranking rules following this example, you will note that your changes have been taken into account by Meilisearch immediately. This means that once all the other rules have been applied, Meilisearch will consider documents with more recent release\_date's more relevant than older ones.

Primary key
-----------

Meilisearch will try to infer the primary key from the documents you upload. This inference will search for the first field containing the string `id` in its attribute.  
Sometimes, it may happen that no key can be found. In such a case, Meilisearch is not able to infer it.

Since Meilisearch needs a primary key to store the documents, if the latter cannot be inferred, we have set up two alternative ways to communicate the primary key to Meilisearch.

*   By giving it on index creation :

```json
{
  "uid": "movies",
  "primaryKey": "movieUniqueName"
}
```
    
*   By giving it on document addition

```bash
curl -X POST 'http://localhost:7700/indexes/movies/documents?primaryKey=movieUniqueName' --data @movies.json
```



New ranking rules names
-----------------------

In the previous versions, ranking rules names were too long and could contain unnecessary special characters. From now on, they have been simplified. Here is the list of the new built-in ranking rules:

*   `typo`
*   `words`
*   `proximity`
*   `attribute`
*   `wordsPosition`
*   `exactness`

[Follow this guide to know more about what each ranking rules does](https://docs.meilisearch.com/learn/core_concepts/relevancy.html).

Simplified authentication
-------------------------

When adding a master key to Meilisearch, a private key and a public key are generated on launch.  
The public key only grants permission to the routes that execute searches and get documents.  
The private key grants access to every other route in Meilisearch except for the `GET /keys` route. As it returns both the public and private keys, this route is accessible only with the master key.

[Read this to learn more about authentication in Meilisearch](https://docs.meilisearch.com/reference/features/authentication.html).

Production and development mode
-------------------------------

When launching your Meilisearch instance, setting the environment is now available as an option.  
By default, the environment is set to development mode.

While in development mode, you don't have to provide a master key. In that case, every route is accessible without requiring any API key. You are also able to **access the web interface**.

While in production mode, if no master key is given, the instance will be considered unsafe for production and will not start.

Bug fixes, syntax changes, and improvements
-------------------------------------------

*   Removed dead-lock in the update system
*   Settings can be added even when no primary key is known
*   `POST /documents/delete` changed to `POST /documents/delete-batch`
*   Speed up the reindexing system
*   When no highlight is prompted during search there will be no `_highlighted` field in the returned documents
*   Removed `searchableAttributes` from the search query parameters.
*   To know the stats of an index the route is now: `GET /indexes/:index_uid/stats` and not `GET /stats/:index_uid`
*   Documents ids' can only contain the following characters: `A-Z a-z 0-9`, `-`, and `_`

Some adjustments on routes’ design we made are temporary choices we took in order to release a working version. The `/key` route, for example, although functional, is too simple and not tailored to developers’ common needs. We are currently thinking about how to handle it better, and we are open to any advice!

This version took us about three months to finish, taking into account that the v0.8.5 has not been officially released but added to the v0.9 release. We did a lot of work on process organization to ensure that everything would be ready at the same time: the core Meilisearch, the documentation, and the SDK.

We are thrilled about how these latest changes will improve the users' experience with Meilisearch. This release is the result of a lot of discussions among our contributors and us. We are eager to hear about your experience with Meilisearch. Any suggestion or feedback is more than welcome since those are the premises of a long-term and ambitious project that will be built upon the decisions we make today.

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

Meilisearch v0.9: What’s new?

This year, we’ve launched Meilisearch's very first contributors program: the Meilistars. The aim of a contributors’ program is to gather top community contributors and foster our relationship, highlight the fantastic work they produce, and maybe even help create connections. We won’t go much in-depth on this topic at the moment as we’re hoping to share more in a dedicated blog post, so watch this space!  
  
As an initiative to bring the spotlight to our amazing community members, we’ve asked if they would be interested in participating in a series of interviews so that we can get to know them better.  
  
And we’re kick-starting our interviews with Minoru Osuka. You may have already met him on GitHub as [Mosuka](https://github.com/mosuka) or on Twitter as [@minoru\_osuka](https://twitter.com/minoru_osuka).

Let’s hear all together a bit more from him!

Meet Minoru
===========

First things first, we’ve asked him to introduce himself in his own words!

> “I'm Minoru Osuka. I work as a software engineer and tech lead for a company that provides a job search engine in Japan. I'm mainly involved in search platform development. My hobby is software development, and I've released some of the software I developed as OSS on GitHub.”

So not only does Minoru work in tech, but he also considers it his hobby! We were very curious to know how he got into the tech field.

Minoru explains that he started in a technical school as a programming instructor, but he wished to increase his practical experience and decided to join a software development company.

> “This was the start of my career as a software developer. As I used search engines in my work, I became interested in how they work, so I moved to an Internet portal site and have worked in the search engine field ever since.”

Minoru + Meiliseach: it was meant to be
=======================================

Hearing that Minoru actually worked with search engines, we couldn’t help but ask when he heard about Meilisearch and how he started using it.

> “It was about May 2022 when Meilisearch started supporting the Japanese language. Meilisearch used the Japanese morphological analyzer [Lindera](https://github.com/lindera-morphology/lindera) as their Japanese tokenizer. I maintain Lindera, so it was a very fortunate event.”

Minoru is very grateful to [Kination](https://github.com/kination) and [Miiton](https://github.com/miiton), who respectively created the [first pull request](https://github.com/meilisearch/charabia/pull/70) to add Japanese language support in Meilisearch and implemented it. It is thanks to their combined work that the Japanese support of Meilisearch has become what it is today.

> “I have yet to actually use Meilisearch in my work, but [voluntas](https://github.com/voluntas) introduced [a case study using Meilisearch](https://zenn.dev/voluntas/scraps/77ae77d06deadc) for their Japanese document search service, which attracted a lot of attention.”

Open source to the bone
=======================

Minoru's frequent references to other members of the Meilisearch community during the interview were too significant to overlook. He expressed great satisfaction at having had the opportunity to connect with fellow community members.

> “Ever since Meilisearch adopted Lindera, my Twitter followers have increased. I am happy to have met them. I'm very grateful to Meilisearch.”

It's truly remarkable how deeply involved Minoru is in the open-source community. In addition to contributing to Meilisearch and maintaining Lindera, he has also built his own [distributed search server](https://github.com/mosuka/bayard).

> “I had been using Elasticsearch and Solr for a long time, but using them was not enough for me, so I decided to build a distributed search server while also learning Rust. It was tough, but I learned a lot.”

Oddly, it was this project that led him to maintain Lindera:

> “I started working on Lindera because I developed a distributed search server on my own. \[...\] My friend, who is developing a full-text search library, also developed a Japanese morphological analyzer, but it was not registered on [crates.io](https://crates.io/). When I contacted him to see if he would register it on crates.io, he gave me a surprising answer: ‘I want you to take over this project.’ I was also interested in morphological analyzers, so I decided to take over the development.”

Minoru also thanked [fulmicoton](https://github.com/fulmicoton), the developer of [kuromoji-rs](https://github.com/fulmicoton/kuromoji-rs), the original software that eventually evolved into Lindera, describing it as “a wonderful OSS.”

A vision for the future
=======================

Given his extensive contributions, it's no surprise that Minoru knows Meilisearch inside out. Its immediate usability is what Minoru values most about it. In fact, he particularly values a specific feature that contributes to this accessibility.

> “Meilisearch's automatic detection of what language the indexed documents are written in is great. This is a very helpful feature for users unfamiliar with search engines.”

During our conversation with Minoru, we couldn't pass up the chance to ask him about any improvements he'd like to see in Meilisearch's near future. Unsurprisingly, his suggestions focused on language support. Specifically, he suggested implementing a mechanism to normalize characters **before** they are tokenized.

For those unfamiliar with the process, it currently happens the other way around. A text is tokenized—segmented into words—and then, each word is normalized based on language particularities. For a romance language like French, this process includes lowercasing and removing diacritical marks such as accents or anything that doesn’t impact the meaning of the text. To those interested in the subject, you can join the discussion on [GitHub](https://github.com/meilisearch/product/discussions/532#discussioncomment-3812425) or [read more](/blog/improving-meilisearchs-language-support/)bout how we handle language support.

Minoru's suggestions for language support included customizing the normalizer for each field. Suppose there is a document with an address field, and he would like to be able to instruct Meilisearch to convert the Kanji numbers in the address field into Arabic numbers. In his words:

> "Right now, Meilisearch does not have a normalizer for Japanese, but it would be nice to be able to customize it for each field \[…\] I would also like to contribute to Japanese normalizers."

We look forward to working on improving our language support with Minoru, and any language aficionados that would want to support our efforts!

It was a real pleasure talking with Minoru, getting to know him better, and understanding his insight on Meilisearch, his usage, and the people he managed to meet through it.

As a reminder, you can find [Minoru on GitHub](https://github.com/mosuka) or contribute to [Lindera](https://github.com/lindera-morphology/lindera).  
We hope you found this interview as interesting as we did and look forward to meeting all of our incredible Meilistars.

Minoru Osuka: POV of a main language contributor

<Callout>
  Due to the recent documentation site migration, our documentation doesn't currently use Vale. You can still view our style guide on [GitHub](https://github.com/meilisearch/documentation/tree/b6837449f09587f9d6df92e1eea0c44cc394f398/.vale/styles/Meilisearch).
</Callout>

Writing is a time-consuming process. Depending on the writer and the review process, it can take a while to get content ready for publication. Whether you’re a solo writer or a big team, prose linters can help ensure a consistent tone and style.  

Similar to code linters, prose linters automatically check your text for errors. Unlike grammar checkers, which highlight violations of grammatical rules, prose linters focus on how you can make your text better by addressing common usage problems like extra spaces, repeated words, excessive use of jargon, sexist language, and incorrect capitalization.  

Prose linters can also provide a framework for creating and enforcing an [editorial style guide](https://www.writethedocs.org/guide/writing/style-guides/). This helps with the review process as you can now focus on reviewing the content itself instead of pointing out typos and preferred usage patterns. This is particularly important when working in open-source projects like Meilisearch, where you have many contributors unfamiliar with your style guide.  

What is Vale?
-------------

[Vale](https://vale.sh/docs/vale-cli/overview/) is an open-source, highly customizable, syntax-aware prose linter. It supports documents written in many different formats such as Markdown, HTML, reStructuredText, AsciiDoc, DITA, and XML.  

Vale isn’t your only option when it comes to prose linting. There are many other open-source tools available, including [proselint](http://proselint.com/), [textlint](https://textlint.github.io/), and [alex](https://alexjs.com/).  

At Meilisearch, we decided to go with Vale because it’s fast, easy to set up, flexible, and comes with existing rules to help you get started.

Where do I start?
-----------------

Though it may seem daunting, setting up Vale can be fairly straightforward if you start small and keep things simple. In this post, we’ll go over how to use Vale in a project much like [Meilisearch’s documentation](https://github.com/meilisearch/documentation).

### Step 1: Style guide

The first step is to create a style guide. A style guide ensures a consistent tone and style regardless of how big your team gets. It establishes standard practices when people may have different opinions, such as whether or not to use the oxford comma.  

If you don’t have an in-house style guide, you can check out [Google’s](https://developers.google.com/style) or [Microsoft’s](https://learn.microsoft.com/en-us/style-guide/welcome/) to help you get started. Over time you will memorize most of the rules, but it’s possible to overlook mistakes and sometimes forget the rules altogether. We’re only human.  

And that is where Vale comes in. It allows you to “codify” a style guide and checks your text against all the rules in that style guide. If it detects any issues, it displays suggestions, warnings, or errors on the console.

![](https://lh4.googleusercontent.com/jqa7GUDjATPh8UaNybvMrcuCURAdHu1mMrrm_M6T9MdKq_M3CPf0i8Gs60_yEt08zZGrCd43ZxsrdRDQ3nP8EBEXitjEeqFdDHYlD6HZ19CcGhkvpHHlR6NwZxbjkOMl6IpzUR1RCJ9P6myZoEHIOhs)

### Step 2: Install Vale

I’m using macOS and ran `brew install vale` in my console to install Vale.

If you’re using a different operating system, check out Vale’s documentation for [installation instructions](https://vale.sh/docs/vale-cli/installation/).  

Verify the installation by typing  `vale -v` in your console. If this command returns Vale’s version number, the installation was successful.  

Finally, create the following files and folders:

```json
├── .vale.ini
│   ├──  styles
│   │	    ├── Style guide
│   │       └── Vocab
```

### Step 3: Configuring Vale - vale.ini

Create a `vale.ini` file at the root of your repository. This is the Vale configuration file where you define what you want Vale to do and what files to lint. Let’s start with a basic setup—you can always add to it later based on your project’s needs.

```json
StylesPath = .vale/styles
MinAlertLevel = suggestion

Vocab = word_list

[*.md]
BasedOnStyles = Meilisearch
```

*   `StylesPath` is where Vale looks for your style guide (more on that in the next step). The path can be relative or absolute to the location of the `vale.ini` file.  
    
*   `MinAlertLevel` specifies the minimum alert level that Vale will report. By default, it’s set to `warning`. The other options are `error`  and `suggestion`.  
    An error indicates you did something wrong, like using extra spaces or making a typo. A warning isn’t as severe as an error, but indicates something you should avoid, like making sure your sentences don’t become too long. A suggestion is a recommendation to do something that is usually—but not always—a good idea, like breaking your sentence into two instead of using a semicolon.  
    If a rule is set to `suggestion`, you will see suggestions, warnings, and errors. If it is set to `warning`, Vale will only show errors and warnings, no suggestions.  
    
*   `Vocab`: This is where you create a directory containing the `accept.txt` and `reject.txt` files. Both files accept words, phrases, and [regular expressions](https://ubuntu.com/blog/regex-basics). If your text contains words that do not exist in the dictionary (e.g. “Meilisearch”), you can add them to `accept.txt` and Vale won’t angrily scream at you for making a “typo”. Vale will flag all occurrences listed in `reject.txt` as errors. This can be useful when you want writers to avoid a specific word—if you are writing about search engines and databases, for example, using “indexation” can be confusing.  
    
*   `[*.md]` tells Vale to only lint markdown files. If you want to lint plain text files, use `[*.txt]`.  
    
*   `BasedOnStyles` specifies the style guide Vale should use for linting.  
    

You can specify other settings, including what tokens and HTML tags to ignore and what Vale should consider an individual word. You can read more about the `vale. ini` file in [Vale’s documentation](https://vale.sh/docs/topics/config/).

### Step 4: Rules and the styles folder

As I mentioned earlier, you need a style guide to use Vale. You then convert this style guide into something Vale can understand: rules.

Rules use different [extension points](https://vale.sh/docs/topics/styles) to perform specific tasks. For example, the `existence` extension point looks for the existence of a particular token, `repetition` looks for repeated tokens, `spelling` implements spell checking, and so on. In Vale, each rule is a YAML file. The `styles` folder contains the individual rules that make up the style guide.  

If you don’t want to create your own style guide or need a starting point to build from, Vale comes with ready-to-use style guides that you can apply to your docs and start linting. Here are some style guides that helped us get started:

*   [Google](https://github.com/errata-ai/Google)
*   [GitLab](https://gitlab.com/gitlab-org/gitlab/-/tree/master/doc/.vale/gitlab)
*   [RedHat](https://github.com/redhat-documentation/vale-at-red-hat/tree/main/.vale/styles/RedHat)

You can find more on [Vale’s GitHub](https://github.com/errata-ai/packages) repository.  

Let’s start with a rule for sentence length. Your style would say something like “Ensure sentences don’t exceed 40 words”. This is what the rule looks like as a YAML file:

```json
# Warning: Meilisearch.SentenceLength

# Counts words in a sentence and alerts if a sentence exceeds 40 words.

extends: occurrence
message: 'Shorter sentences improve readability (max 40 words).'
scope: sentence
link: https://docs.gitlab.com/ee/development/documentation/styleguide/index.html#language
level: warning
max: 40
token: \b(\w+)\b
```

This rule counts the words in a sentence and throws a warning if it exceeds 40 words. The `scope` is set to `sentence`: this ensures that Vale does not apply this rule to other parts of the text, like headings or tables.  

The `level` is set to `warning`. Written text is complicated, and Vale will find false positives. There are no sure-fire ways of deciding when a rule should be a suggestion, warning, or an error. You will need to make decisions and learn as you go.  

I suggest reviewing your rules over time to update and, in some cases, delete outdated rules. Initially, the Meilisearch docs didn’t have a rule on sentence length. When we added it, the maximum length of a sentence was 45. Now it’s 40, and we plan on bringing it down to 35.  

You can also enable or disable specific rules within a style guide by adding them to `vale.ini`:  

```json
Meilisearch.Headings = NO
Meilisearch.Spelling = NO
Meilisearch.Semicolons = NO
```

The above lines disable the Heading, Spelling, and Semicolons rules from the [Meilisearch style guide](https://github.com/meilisearch/documentation/tree/main/.vale/styles).  

### Step 5: Run Vale

Now, when you use the following command on your console to lint your whole project:  

```json
vale .
```

Vale will check all your files against the rules stored in `BasedOnStyles`. If Vale detects any issues, it will display suggestions, warnings, and errors on the console.  

You can also lint individual files using:  

```json
vale {file_path} 
```

### Step 6: Automate Vale checks

All the checks we’ve discussed so far are for your local files. Once you’re confident the rules work as intended, you can automate these checks using the [Vale GitHub action](https://github.com/errata-ai/vale-action)! At the Meilisearch documentation repository, we configured it to run for every pull request. As mentioned before, Vale may find false positives. Since you don’t want a PR blocked because Vale isn’t working as it should, I recommend starting with a few rules, and slowly tweaking them to avoid failing checks.  

### Conclusion

That is all, folks! I hope I was able to help you get started with Vale (and a style guide). This was a quick overview to introduce you to Vale’s features. Tweaking it to your needs takes time and many, _many_ iterations.  

![](https://lh4.googleusercontent.com/zp5NecwV9Bc8pMsSf2QeV8yOMMGWoJR8bENrOuQNNFWat7J0KtzDq1n9oBrEW1lKgJO8utxivJS9UqXuMutCmft2o8x3LIE3bUIQFuqcCTkgQ6H5y6hzVAEXgEPYkGHlwnTZnaJ3r3rEq4LyWGFYOVU)

Once configured, Vale can automate parts of the review process and allow you to focus on the parts of a text that computers are not very good at. At least not yet.  

Oh, and if you’re curious, check out [our style guide on GitHub](https://github.com/meilisearch/documentation/tree/main/.vale/styles) to see how we use Vale!

Meilisearch latest news and company updates