Hey there, here's your monthly recap of everything Meilisearch. Let's dive in!

**🚀 Releasing Meilisearch v1.3**
---------------------------------

[![What's new? v1.3](https://unable-actionable-car.media.strapiapp.com/75_454d2f4f6e.png)](/blog/v1-3-release/)

We released v1.3 which introduces **vector search**, **ranking score details**, **search for facet values**, and **dynamic searchable fields**.

[Read the release blog](/blog/v1-3-release/)*🔢 Vector search is coming to Meilisearch**
---------------------------------------------

[![Empowering search through AI: vector storage is coming to Meilisearch](https://unable-actionable-car.media.strapiapp.com/73_1_1_65f8c54f7d.png)](/blog/vector-search-announcement/)

Vector search is our first step towards **semantic search**. It is an important step toward our long-term goal of providing **hybrid search**: combining the benefits of full-text and semantic search.

[Read the announcement](/blog/vector-search-announcement/)*🤝 Qogita customer story**
----------------------------

[![Qogita success story: simplifying B2B trade with Meilisearch Cloud](https://unable-actionable-car.media.strapiapp.com/78_1_1_ea6d441573.png)](/blog/qogita-simplifies-b2b-trade/)

With **Meilisearch Cloud**, Qogita can ensure high seller exposure and increased relevancy, resulting in an excellent buyer-seller interaction.

[Read the success story](/blog/qogita-simplifies-b2b-trade/)*📰 In the news**
------------------

  
**🦜🔗** [Meilisearch LangChain integration guide](https://python.langchain.com/docs/integrations/vectorstores/meilisearch)

Learn how to integrate the Meilisearch vector store in LangChain.

🏀 [From ranking to scoring](/blog/from-ranking-to-scoring/)ead about our engineers journey to add relevancy scores to search results.

🎮 [Meilisearch SaaS demo](https://saas.meilisearch.com/)

We’ve released a new demo feature using **multi-search**, **multi-tenancy**, **filtering**, and **sorting** using Laravel.

⚡️ [Blazing fast async data loading in Meilisearch using Python](https://thedataquarry.com/posts/meilisearch-async/)

Read this community article how to use Meilisearch with Pydantic.

🍿 [Meilisearch, the open-source search engine with a UX focus](https://www.youtube.com/watch?v=ncnBRrF-e2g)

Watch this talk explaining how to use Meilisearch (in French, subtitles available.)

**🤗 Made with Meilisearch**
----------------------------

Our featured project of the month is [pbvault.com](https://www.pbvault.com/). Paintball Vault is a marketplace where you can easily buy, sell, and trade both your used and new paintball gear.

The main navigation search bar and all the product grids throughout the site and app use Meilisearch to make browsing intuitive and easy.

[![Screenshot of pbvault.com](https://unable-actionable-car.media.strapiapp.com/www_pbvault_com_3cda884404.png)](pbvault.com)

Buy, sell, and trade paintball gear on pbvault.com

_We’re always looking to promote new projects from the community. Post yours in the_ [_#built-with-meilisearch_](https://discord.meilisearch.com/) _Discord channel!_

**🏡 Life at Meili**
--------------------

Remote work is the future of work: find out how we aim to improve inclusivity and work-life balance through remote-working.

[![A forest](https://unable-actionable-car.media.strapiapp.com/remote_work_is_the_future_of_work_cover_2fb7ead2fa.jpg)](/blog/remote-work-is-the-future-of-work/)

[Read the blog post](/blog/remote-work-is-the-future-of-work/)*🦸‍♀️ We’re hiring!**
-----------------------

See our open positions:

*   [Head of Finance](https://jobs.lever.co/meili/14970d91-fb2f-4130-b568-97872eb62b31)
*   [Founding Account Executive](https://jobs.lever.co/meili/92e2ebdc-3023-4fbe-8dd2-c3cfc9ecd7bf)

* * *

Get these monthly updates straight to your inbox by subscribing to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e).

For more things Meilisearch, join our developers community on [Discord](https://discord.gg/meilisearch/?ref=blog.meilisearch.com). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in [product discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).

Until next time.

Meilisearch August updates

In this guide, we'll walk you through implementing promoted search results with Meilisearch. Our goal is to search results prioritizing specific documents when certain keywords match a user's query. These boosted documents should be returned at the top of the search results.

<Callout>
  This guide explains to implement promoted documents on the backend. For a frontend-first implementation, see [implementing promoted search results with React InstantSearch](/blog/promoted-search-results-with-react-instantsearch/)
</Callout>

Overview
--------

Here's a simplified breakdown of how to implement document boosting using a second index for “pinned documents” and the [multi-search feature](https://www.meilisearch.com/docs/reference/api/multi_search#perform-a-multi-search):

1.  **Create Indexes:** Set up two indexes: one for regular search and one for boosted results. The boosted index will have a special attribute, `keywords`, to trigger the boosting.
2.  **Populate the 'games' Index:** Populate a `games` index with your dataset using the provided JSON file. This index will serve as the source for our boosted documents.
3.  **Configure the 'pinned\_games' Index:** Configure the `pinned_games` index to display attributes without revealing keywords. Adjust the searchable and displayed attributes accordingly.
4.  **Boost Documents:** Identify documents you want to boost and assign relevant keywords to them. For instance, you can assign the keywords `fps` and `shooter` to the game `Counter-Strike`.
5.  **Implement the Multi-Search:** Utilize Meilisearch's multi-search feature to perform a search query across both the regular and boosted indexes. This way, boosted documents matching keywords will appear first.
6.  **Display Results:** Present the search results in a user-friendly format, highlighting boosted documents with a visual indicator.

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

### Installation

Before diving in, make sure you have Meilisearch up and running. If you haven't installed it yet, follow these steps:

1.  Launch a Meilisearch instance — you can run [Meilisearch in local](https://www.meilisearch.com/docs/learn/getting_started/installation) or via [Meilisearch Cloud](https://www.meilisearch.com/cloud).
2.  Ensure you have your favorite [language SDK](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks) (or framework integration) installed.

<Callout>
  This guide uses the [Python SDK](https://python-sdk.meilisearch.com/), but it works the same with any other Meilisearch integration. 🎉
</Callout>

### Initializing indexes

For our example, we'll work with a dataset of Steam games. You can adapt this process to your own data:

1.  Download the `steam-games.json` and `settings.json` files for our [Steam games dataset](https://meilisearch.notion.site/Steam-6e6141755a854909b31ba8c8e9e74853)
2.  Load the dataset in your Meilisearch instance by [adding documents](https://www.meilisearch.com/docs/reference/api/documents#add-or-replace-documents) from the `steam-games.json` file.

#### `games` index

```python
import meilisearch
import json
from typing import Callable

client = meilisearch.Client(url="http://localhost:7700")
games = client.index("games")

# helper to wait for Meilisearch tasks
def wait_with_progress(client: meilisearch.Client, task_uid: int):
    while True:
        try:
            client.wait_for_task(task_uid, timeout_in_ms=1000)
            break
        except meilisearch.errors.MeilisearchTimeoutError:
            print(".", end="")
    task = client.get_task(task_uid)
    print(f" {task.status}")
    if task.error is not None:
        print(f"{task.error}")
            
print("Adding settings...", end="")
with open("settings.json") as settings_file:
    settings = json.load(settings_file)
    task = games.update_settings(settings)
    wait_with_progress(client, task.task_uid)


with open("steam-games.json") as documents_file:
    documents = json.load(documents_file)
    task = games.add_documents_json(documents)
    print("Adding documents...", end="")
    wait_with_progress(client, task.task_uid)
```

#### `pinned_games` index

This index will contain the promoted documents. The settings of the `pinned_games` index are the same as the `games` index, with the following differences:

*   the only `searchableAttributes` is the `keywords` attribute containing the words that trigger pinning that document.
*   the `displayedAttributes` are all the attributes of the documents, except for `keywords` (we don't want to show the keywords to end-users)

```python
pinned = client.index("pinned_games")

print("Adding settings...", end="")
with open("settings.json") as settings_file:
    settings = json.load(settings_file)
    settings["searchableAttributes"] = ["keywords"]
    # all but "keywords"
    settings["displayedAttributes"] = ["name", "description", "id", "price", "image", "releaseDate", "recommendationCount", "platforms", "players", "genres", "misc"]
    task = pinned.update_settings(settings)
    # see `wait_with_progress` implementation in previous code sample
    wait_with_progress(client, task.task_uid) 
```

### Updating the promoted documents index

We'll now populate the index with documents from the `games` index that we want to promote.

As an example, let's say we want to pin the game `"Counter-Strike"` to the `"fps"` and `"first", "person", "shooter"` keywords.

```python
counter_strike = games.get_document(document_id=10)
counter_strike.keywords = ["fps", "first", "person", "shooter"]

print("Adding pinned document...", end="")
task = pinned.add_documents(dict(counter_strike))
wait_with_progress(client, task.task_uid)
```

### Customizing search results

Now, let’s create a function to return the search results __with__ the pinned documents.

```python
from copy import deepcopy
from typing import Any, Dict, List
from dataclasses import dataclass

@dataclass
class SearchResults:
    pinned: List[Dict[str, Any]]
    regular: List[Dict[str, Any]]

def search_with_pinned(client: meilisearch.Client, query: Dict[str, Any]) -> SearchResults:
    pinned_query = deepcopy(query)
    pinned_query["indexUid"] = "pinned_games"
    regular_query = deepcopy(query)
    regular_query["indexUid"] = "games"
    results = client.multi_search([pinned_query, regular_query])
    # fetch the limit that was passed to each query so that we can respect that value when getting the results from each source
    limit = results["results"][0]["limit"]
    # fetch as many results from the pinned source as possible
    pinned_results = results["results"][0]["hits"]
    # only fetch results from the regular source up to limit
    regular_results = results["results"][1]["hits"][:(limit-len(pinned_results))]
    return SearchResults(pinned=pinned_results, regular=regular_results)
```

We can use this function to retrieve our search results with promoted documents:

```python
results = search_with_pinned(client, {"q": "first person shoot", "attributesToRetrieve": ["name"]})
```

The `results` object should look like:

```json
SearchResults(pinned=[{'name': 'Counter-Strike'}], regular=[{'name': 'Rogue Shooter: The FPS Roguelike'}, {'name': 'Rocket Shooter'}, {'name': 'Masked Shooters 2'}, {'name': 'Alpha Decay'}, {'name': 'Red Trigger'}, {'name': 'RAGE'}, {'name': 'BRINK'}, {'name': 'Voice of Pripyat'}, {'name': 'HAWKEN'}, {'name': 'Ziggurat'}, {'name': 'Dirty Bomb'}, {'name': 'Gunscape'}, {'name': 'Descent: Underground'}, {'name': 'Putrefaction'}, {'name': 'Killing Room'}, {'name': 'Hard Reset Redux'}, {'name': 'Bunny Hop League'}, {'name': 'Kimulator : Fight for your destiny'}, {'name': 'Intrude'}])
```

Tada 🎉 You now have a search results object that contains two arrays: the promoted results and the “regular” ones.

<Callout>
  Got stuck? Don’t hesitate to ask for help in our [Discord community](https://discord.meilisearch.com/).
</Callout>

Going further
-------------

This tutorial explored one approach for implementing promoted results. An alternative technique would be implementing documents pinning in the frontend; take a look at our [React implementation guide](/blog/promoted-search-results-with-react-instantsearch/)his different approach has the benefits of being [compatible with InstantSearch](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch).

Both techniques can achieve similar results. We also plan to integrate [promoted documents](https://portal.productboard.com/meilisearch/1-meilisearch/c/98-promoting-documents?utm_medium=social&utm_source=portal_share) in the Meilisearch engine. Give your feedback on the previous link to help us prioritize it.

For more things Meilisearch, you can subscribe to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). You can learn more about our product by checking out the [roadmap](https://roadmap.meilisearch.com/) and participating in our [product discussions](https://github.com/meilisearch/product/discussions).

For anything else, join our developers community on [Discord](https://discord.meilisearch.com/).

Cheers!

How to implement document boosting with a second index

## What is bucket sort?

Bucket sort is a sorting algorithm that distributes elements from an array into several buckets. Once divided, each bucket is sorted individually, either using a different sorting algorithm or by applying the bucket sort method itself.

## What is recursive bucket sorting?

**Recursive bucket sort** is a specific application of the bucket sort algorithm, where the bucket sort algorithm is used to sort the individual buckets. It is named "recursive" because the same method is used repeatedly to sort sub-buckets until the entire array is sorted.

## What is bucket sorting used for?

Bucket sort is used for efficiently organizing data. By distributing the data into different buckets, it makes the later stages of sorting more efficient. **It also allows to use different sorting algorithms within individual buckets**. This flexibility allows for potential optimizations and makes bucket sort adaptable to various scenarios and data distributions.

## What is the best and worst-case of bucket sort?

Bucket sort's performance varies greatly, with the best and worst cases depending on factors such as data distribution, size, and the choice of sorting algorithm used within individual buckets.

### The best case of bucket sort

The best case for bucket sort happens when the data is spread evenly across the buckets. This uniform distribution minimizes the complexity of sorting each bucket, leading to an overall time complexity of *O(n+k)*, where *n* represents the number of elements and *k* refers to the number of buckets.

### The worst case of bucket sort

The worst case for bucket sort arises when all the elements end up in a single bucket, losing the advantage of distributing them across multiple buckets. This scenario leads to a time complexity determined by the sorting algorithm used for that single bucket. It can result in a worst-case time complexity of *O(n2)*, depending on the algorithm. 

## How does a bucket sort algorithm work?

To better illustrate how it works, let's take the example of [Meilisearch](https://www.meilisearch.com/). Meilisearch is a  search engine that uses bucket sort to sort search results on a set of consecutive rules called [ranking rules](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#built-in-rules)**.** 

For example, the [\`words\` ranking rule](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#1-words) sorts documents based on the number of words from the query found in the document.

Given the query “Badman dark knight returns”, the \`words\` rule will sort the returned documents into 4 buckets. These range from documents that contain all the words (possibly with a typo) to those that only contain the word “Badman”.

If \`words\` is the last ranking rule, or if the buckets only contain one document, then Meilisearch returns the buckets from the “best” (matching all words) to the “worst” (matching only one word). Documents matching 0 words are never returned as they have 0 relevancy to the search query. 

![buckets of documents after applying the `words` ranking rule on the query `Badman dark knight returns`](https://unable-actionable-car.media.strapiapp.com/image2_dd7457e68e.png)
_Diagram illustrating bucket sorting using the `words` ranking rule._

Sorting documents using only a single ranking rule would force Meilisearch to either have a very complicated ranking rule or to perform a simplistic ranking. Meilisearch uses multiple ranking rules sequentially. 

If a bucket from the first ranking rule contains multiple documents, the second ranking rule is used on that bucket to “break the tie” between documents. This technique could qualify as “recursive bucket sorting”. The sorting finishes when all the “innermost” buckets contain a single document, or after applying the last ranking rule.

## How does a recursive bucket sort algorithm work?

To illustrate recursive bucket sorting, let’s imagine that we now added the [\`typo\` ranking rule](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#2-typo) after the [\`words\` ranking rule](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#1-words) from the previous example. The \`typo\` ranking rule differentiates between documents that match the query directly and documents that would match if we were correcting one or two typos in the query. The former are better ranked than the latter.

Continuing with our sample query “Badman dark knight returns”, the \`typo\` ranking rule helps us further differentiate between documents from the last bucket. Note that it has no effect on the three other buckets, because they only contain documents such that the query has the typo “Badman \-\> Batman”. 

![buckets of documents after applying the `words` and `typo` ranking rules on the query `Badman dark knight returns`](https://unable-actionable-car.media.strapiapp.com/image1_04ad01e3b3.png)
_Diagram illustrating the application of recursive bucket sorting using the `words` ranking rule followed by the `typo` ranking rule._

By applying recursive bucket sorting to our query on the [sample movies.json dataset](https://www.notion.so/meilisearch/Movies-Demo-97ea014ca2034e64b8497425b972aedb?ref=blog.meilisearch.com), Meilisearch returns the ranking below. For simplicity, we have configured the dataset so that only \`title\` is a searchable attribute, which makes the results easier to grasp. 

| Rank | Query words | Typo correction | Resulting documents |
| --- | --- | --- | --- |
| 1	| "Badman dark knight returns"     	| "badman" → "batman" | Batman: The Dark Knight Returns, Part 1 <br/> Batman: The Dark Knight Returns, Part 2 |
| 2	| "Badman dark knight"             	| "badman" → "batman" | Batman Unmasked: The Psychology of the Dark Knight\<br/\>Legends of the Dark Knight: The History of Batman |
| 3	| "Badman"                         	| No typo         	| Angel and the Badman                                  	|
| 4	| "Badman"                         	| "badman" → "batman" | Batman: Year One <br/>Batman: Under the Red Hood       	|

<Callout intent="tip">

💡See bucket sort-powered relevancy in action in this [Meilisearch demo](https://where2watch.meilisearch.com/).

</Callout>

If you want to try it yourself, you can create an account on [Meilisearch Cloud](https://meilisearch.com/cloud) and easily add and set up the movies dataset used to illustrate bucket sort. You can start searching in just a few minutes\! Alternatively, you can use our open-source version and [run Meilisearch locally](https://www.meilisearch.com/docs/learn/getting_started/quick_start?ref=blog.meilisearch.com). You just need to follow the instructions of our [quick start guide](https://www.meilisearch.com/docs/learn/getting_started/quick_start). 

<Callout intent="tip">

🧪Experiment with bucket sorting by [changing the order](https://www.meilisearch.com/docs/reference/api/settings#update-ranking-rules) of the [built-in ranking rules](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#built-in-rules) and adding your [custom](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#custom-rules) ones.

</Callout>

## Conclusion

Bucket sort is a powerful and flexible algorithm, but its workings can be complex to understand without a concrete example. We hope this article has helped you gain a better understanding of what bucket sort is and how it functions.

[Meilisearch](https://meilisearch.com/) is an open-source search engine that not only provides state-of-the-art experiences for end users but also a simple and intuitive developer experience.

For more things Meilisearch, you can join the community on [Discord](https://discord.gg/meilisearch/?ref=blog.meilisearch.com) or subscribe to the [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e&ref=blog.meilisearch.com). You can learn more about the product by checking out the [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in [product discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).


A practical guide to understanding bucket sort

From ranking to scoring

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.3.0) on GitHub.

v1.3 is now available on [Meilisearch Cloud](https://www.meilisearch.com/cloud), including all experimental features. Upgrade your Meilisearch instance in one click without downtime.

Experimental feature: vector search
-----------------------------------

<Callout>
  Using LangChain? You can now use the [Meilisearch vector store](https://python.langchain.com/docs/integrations/vectorstores/meilisearch) to benefit from powerful search features!
</Callout>

We are excited to introduce [vector storage](https://www.meilisearch.com/docs/learn/experimental/vector_search)! Now, you can index and search documents using vector embeddings—numerical representations of data. For the first iteration of this feature, you need to use an external tool such as [Hugging Face](https://huggingface.co/), [Cohere](https://cohere.com/), or [OpenAI](https://openai.com/), to create such embeddings. Check out the [announcement post](/blog/vector-search-announcement/ to discover the extensive possibilities and potential applications of this feature.

<Callout>
  This feature is experimental, you can enable it using the new [experimental-features endpoint](https://www.meilisearch.com/docs/reference/api/experimental_features).
</Callout>

To search documents based on their vector proximity, make sure they contain a `_vectors` field:

```bash
curl -X POST -H 'content-type: application/json' \
  'localhost:7700/indexes/songs/documents' \
  --data-binary '[
      { "id": 0, "_vectors": [0, 0.8, -0.2], "title": "Across The Universe" },
      { "id": 1, "_vectors": [1, -0.2, 0], "title": "All Things Must Pass" },
      { "id": 2, "_vectors": [[0.5, 3, 1], [-0.2, 4, 6]], "title": "And Your Bird Can Sing" }
  ]'
```

Once stored, you can search your vectorized documents by using the new `vector` search parameter in combination with the [search](https://www.meilisearch.com/docs/reference/api/search) and [multi-search](https://www.meilisearch.com/docs/reference/api/multi_search) routes.

```bash
curl -X POST -H 'content-type: application/json' \
'localhost:7700/indexes/songs/search' \
--data-binary '{ "vector": [0, 1, 2] }'
```

👉 Note that you need to generate the vector in your query using a third-party tool.

The returned documents include a `_semanticScore` field indicating the semantic similarity—or relevancy—of each document with the query.

```JSON
{
  "hits": [
    { "id": 0, "_vectors": [0, 0.8, -0.2], "title": "Across The Universe", "_semanticScore": 0.6754 },
    { "id": 1, "_vectors": [1, -0.2, 0], "title": "All Things Must Pass", "_semanticScore": 0.7546 },
    { "id": 2, "_vectors": [[0.5, 3, 1], [-0.2, 4, 6]], "title": "And Your Bird Can Sing", "_semanticScore": 0.78 }
  ],
  "query": "",
  "vector": [0, 1, 2],
  "processingTimeMs": 0,
  "limit": 20,
  "offset": 0,
  "estimatedTotalHits": 2
}
```
<Callout>
  This feature is experimental and we need your help to improve it! Share feedback on [this GitHub discussion](https://github.com/meilisearch/product/discussions/677).
</Callout>

New feature: display ranking scores at search
---------------------------------------------

Use the new `showRankingScore` search parameter to see the [ranking score](https://www.meilisearch.com/docs/reference/api/search#ranking-score) of relevancy of each document:

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "Batman Returns", "showRankingScore": true }'
```

Each document in the response will include a `_rankingScore` property, which represents a score between 0 and 1:

```JSON
"_rankingScore": 0.8575757575757575,
```

The higher the `_rankingScore`, the more relevant the document is.

Experimental feature: ranking score details
-------------------------------------------

For every document returned, Meilisearch provides a [detail of the ranking score](https://www.meilisearch.com/docs/learn/experimental/ranking_rule_score_details) of each ranking rule. This feature is a perfect example of [how community engagement can enrich the design process](/blog/from-ranking-to-scoring/ at Meilisearch.

<Callout>
  This feature is experimental, you can enable it using the new [experimental-features endpoint](https://www.meilisearch.com/docs/reference/api/experimental_features).
</Callout>

Set the `showRankingScoreDetails` search parameter to `true` to view the ranking score details:

```bash
curl \
  -X POST 'http://localhost:7700/indexes/movies/search' \
  -H 'Content-Type: application/json' \
  --data-binary '{ "q": "Batman Returns", "showRankingScoreDetails": true }'
```

  
The response should include the relevancy score of each rule:

```JSON
"_rankingScoreDetails": {
  "words": {
    "order": 0,
    "matchingWords": 1,
    "maxMatchingWords": 1,
    "score": 1.0
  },
  "typo": {
    "order": 1,
    "typoCount": 0,
    "maxTypoCount": 1,
    "score": 1.0
  },
  "proximity": {
    "order": 2,
    "score": 1.0
  },
  "attribute": {
    "order": 3,
    "attributesRankingOrder": 0.8,
    "attributesQueryWordOrder": 0.6363636363636364,
    "score": 0.7272727272727273
  },
  "exactness": {
    "order": 4,
    "matchType": "noExactMatch",
    "score": 0.3333333333333333
  }
}
```
<Callout>
  This feature is experimental. You can help us improve it by sharing your feedback on [this GitHub discussion](https://github.com/meilisearch/product/discussions/674).
</Callout>

New feature: search for facet values
------------------------------------

Once you have defined your [filterable attributes](https://www.meilisearch.com/docs/reference/api/settings#filterable-attributes), you can use the new endpoint `POST /indexes/{index}/facet-search` to [search for facet values](https://www.meilisearch.com/docs/learn/fine_tuning_results/faceted_search#searching-facet-values).

```bash
 curl \
  -X POST 'http://localhost:7700/indexes/movies/facet-search' \
  -H 'Content-Type: application/json'  \
  --data-binary '{
    "facetName": "genres",
    "facetQuery": "a"
  }'
```

  
As facet search is typo tolerant and supports prefix search, the above query will return de following results:

```JSON
{
    "facetHits": [
        {
            "value": "Action",
            "count": 5403
        },
        {
            "value": "Adventure",
            "count": 3020
        },
        {
            "value": "Animation",
            "count": 1969
        }
    ],
    "facetQuery": "a",
    "processingTimeMs": 0
}
```

To test this feature, check out our updated [ecommerce demo](https://ecommerce.meilisearch.com/).

  

![](https://lh5.googleusercontent.com/AvwqKTkbB0RfTYrWL4xeBUZEdzRwrEjgL0yKllbM5AZu0aXkpmO-peqP7y-5SC-O30TsAdaiXEMdOck4hiS44UvF8UFV-MwsM-mvtdRmxEeKtPowTUXQThTlqlP5yqz2p_5WohLCIgOtydEvK33TdAY)

  

New feature: sort facet values by count
---------------------------------------

By default, facets are sorted in ascending alphanumeric order. Now, you can sort facet values in descending order based on the number of matched documents containing each facet value.

To order facets by count, you can use the new `sortFacetValuesBy` property in the  [faceting index settings](https://www.meilisearch.com/docs/reference/api/settings#faceting).

To modify the order for all facets, you can use the asterisk (\*) wildcard:

```bash
 curl \
  -X PATCH 'http://localhost:7700/indexes/movies/settings/faceting \
  -H 'Content-Type: application/json'  \
  --data-binary '{
    "sortFacetValuesBy": {"*": "count"}
  }'
```

Alternatively, you have the flexibility to order a single facet by count while maintaining alphanumeric ordering for other attributes:

```json
 curl \
  -X PATCH 'http://localhost:7700/indexes/movies/settings/faceting \
  -H 'Content-Type: application/json'  \
--data-binary '{
    "sortFacetValuesBy": {"*": "alpha", "genre": "count"}
  }'
```

You can also try it in the [ecommerce demo](https://ecommerce.meilisearch.com/).

![](https://lh4.googleusercontent.com/s7qTls-ayHQpaIASqAQjNX0AnGUfc5TkZu6r83XvZBJyyyxU54qpeAXvjgofCgEbiMs72wwmVQF5m-LnLNkiQVkQFJULEvqgSYdtVh_dxGufHr8FC7zxag9PMsSXb0YbsjysSqBQuRRiSSFWcqNqyKc)

New feature: searchable attributes at query time
------------------------------------------------

With the new `attributesToSearchOn` search parameter, you can now [restrict the search](https://www.meilisearch.com/docs/reference/api/search#customize-attributes-to-search-on-at-search-time) to a subset of the [searchable attributes](https://www.meilisearch.com/docs/learn/configuration/displayed_searchable_attributes#the-searchableattributes-list) at query time. It accepts an array of strings indicating one or more document attributes:

```JSON
{
  "q": "adventure",
  "attributesToSearchOn": ["genre"]
}
```

Given the following documents, the above query will only return document with id 1.

```JSON
{
    "id": 0,
    "name": "An Adventure in Space and Time",
    "genre": ["drama"]
},
{
    "id": 1,
    "name": "A Strange and Stubborn Endurance",
    "genre": ["adventure"]
}
```

Relevancy change: attribute ranking rule
----------------------------------------

With v1.3, the [attribute ranking rule](https://www.meilisearch.com/docs/learn/core_concepts/relevancy#4-attribute) assigns higher relevancy to documents where the query words appear closer to their position in the query, compared to documents where the query words are farther from their position in the query.

Before, this rule measured relevancy based on the position of the words in the attribute rather than on their position in the search query. Documents with attributes containing the query words at the beginning of the attribute were considered more relevant.

Consider the following query: "Batman the dark knight returns" and the corresponding documents:

```JSON
{ 
    "id": 0, 
    "title": "Batman the dark knight returns" 
},
{ 
    "id": 1, 
    "title": "Dark the Batman knight returns" 
},
{ 
    "id": 2, 
    "title": "Batman returns: a retrospective", 
    "description": "The Dark knight is analyzed in this new Batman documentary" 
}
```

Prior to version 1.3, the attribute ranking rule placed document 2 at the top of the list, followed by documents 0 and 1, ranked in a tie.

Since version 1.3, the order is strictly: document 0, document 1, document 2, which provides a more natural ranking.

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

*   The `/tasks` route now shows the total number of tasks in the queue using the `total` property. It also displays the total number of tasks based on specific filters
*   Enhanced Japanese support and segmentation
*   Improvements in the Prometheus `/metrics` experimental feature

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

We are really grateful for all the community members who participated in this release. We would like to thank: [@vvv](https://github.com/vvv), [@jirutka](https://github.com/jirutka), [@gentcys](https://github.com/gentcys), [@cuishuang](https://github.com/cuishuang), [@0xflotus](https://github.com/0xflotus), and [@roy9495](https://github.com/roy9495) for their help with [Meilisearch](https://github.com/meilisearch/meilisearch?ref=blog.meilisearch.com).

We also want to send a special shout-out to our Meilistar, [@mosuka](https://github.com/mosuka), for his continuous Japanese improvements on [Charabia](https://github.com/meilisearch/charabia?ref=meilisearch-blog).

Conclusion
----------

And that’s it for v1.3! Remember to check the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.3.0) for the full release notes, and see you next time!

You can stay in the loop by subscribing to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e&ref=blog.meilisearch.com). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and come participate in our [Product Discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).

For anything else, join our developers community on [Discord](https://discord.gg/meilisearch?ref=blog.meilisearch.com).

What’s new in v1.3?

Today we're diving into a complex, yet essential, topic: utilizing Meilisearch in a multi-tenant application. By the end of this guide, advanced and intermediate developers will have a clear understanding of how to configure Meilisearch to manage multi-tenancy effectively.

Multi-tenancy: what is it?
--------------------------

In a multi-tenant architecture, a single instance of a software application serves multiple customers or "tenants". Each tenant's data is isolated and remains invisible to other tenants.

### Multi-tenancy use cases

A typical use case for [multi-tenancy](https://www.meilisearch.com/docs/learn/security/tenant_tokens#what-is-multitenancy) is in [Software as a Service (SaaS) applications](https://saas.meilisearch.com/), where multiple companies share the same database. Each company becomes a tenant with data that should not be accessible by others. In such scenarios, you're likely already implementing this specificity in your primary data store.

Multi-tenancy with Meilisearch: the ultimate approach
-----------------------------------------------------

While it's possible to [create one index](https://www.meilisearch.com/docs/learn/core_concepts/indexes#index-creation) per company with Meilisearch, it's not recommended due to [performance](https://www.meilisearch.com/docs/learn/advanced/indexing) reasons. Meilisearch processes [tasks](https://www.meilisearch.com/docs/learn/async/asynchronous_operations) one index after another and cannot maximize the indexation throughput, as cannot process tasks on different indexes in parallel.

Instead, the best way is to put all tenants in the same index and use [Meilisearch's powerful tenant tokens](https://www.meilisearch.com/docs/learn/security/tenant_tokens#tenant-token-payload-reference) to restrict access to a specific user's scope only. For this, stored documents should have not only an [ID](https://www.meilisearch.com/docs/learn/core_concepts/primary_key) but also a company identifier to separate users by their company.

<Callout>
  Experience multi-tenancy in action through our demos:  
\- [SaaS demo](https://saas.meilisearch.com/)  
\- [Tenant tokens demo](https://tenant-token.meilisearch.com/)
</Callout>

### Preparing Meilisearch for multi-tenancy

Let's illustrate this with an example akin to a Slack application. In this application, users belong to a company, and each user can create text messages in different threads. Our goal is to create an index containing all messages but allow only people from a specific company to access their company's messages. Subsequently, we might want to perform a search applying [filters](https://www.meilisearch.com/docs/learn/fine_tuning_results/filtering) on users and threads.

![Database diagram showing the relationships between companies, users, and messages.](https://unable-actionable-car.media.strapiapp.com/DB_diagram_8e2aa6bb68.png)

First, we need to [transform our data](https://www.meilisearch.com/docs/learn/core_concepts/documents#dataset-format) to make it optimal for indexing by Meilisearch. Here's what a sample document could look like:

```JSON
{
	"id": 48735873,
	"user":{
		"id": 5749,
		"name": "bob"
	},
	"company": {
		"id": 838,
		"name": "Acme Inc"
	},
	"thread": "meilisearch-is-awesome",
	"data": "Meilisearch is so easy to use! 🔥",
	"created_at": 1543230000
}
```
<Callout>
  Learn how to [update your settings](https://www.meilisearch.com/docs/reference/api/settings#update-settings) in the documentation.
</Callout>

Next, you'll need to [create a messages index](https://www.meilisearch.com/docs/learn/core_concepts/indexes#index-creation) and add the following settings:

```JSON
{
  "displayedAttributes": [
    "id",
		"user.name",
		"thread",
		"data",
		"created_at"
  ],
  "searchableAttributes": [
    "data"
  ],
  "filterableAttributes": [
		"user.name",
		"company.id",
		"thread"
	],
  "sortableAttributes": [
		"created_at"
	]
}
```

Here's what each setting does:

*   **[`displayedAttributes`](https://www.meilisearch.com/docs/reference/api/settings#displayed-attributes)**: These are the attributes that will appear in your application's search results. We're omitting **`user.id`** and **`company.id`** for security reasons, and **`company.name`** isn't necessary as the user is already aware of their company.
*   **[`searchableAttributes`](https://www.meilisearch.com/docs/reference/api/settings#searchable-attributes)**: These are the attributes that the search function will use. In our case, only the **`data`** (or message text) is searchable.
*   **[`filterableAttributes`](https://www.meilisearch.com/docs/reference/api/settings#filterable-attributes)**: These are the attributes that you can filter by. We've included **`company.id`** for the tenant tokens, **`user.name`**, and **`thread`** for on-the-fly filtering.
*   **[`sortableAttributes`](https://www.meilisearch.com/docs/reference/api/settings#sortable-attributes)**: These are the attributes you can sort by. We've only included **`created_at`** as you might want to sort messages chronologically.

### Creating tenant tokens

With your Meilisearch configuration in place, the next step is to create a new tenant token for each company. If you don't have particular security concerns, you can omit the expiration date to simplify your onboarding process.

<Callout>
  Learn to [generate tenant tokens with an SDK](https://www.meilisearch.com/docs/learn/security/tenant_tokens#generating-tenant-tokens-with-an-sdk).
</Callout>

The crucial part of the tenant tokens is the `searchRules`. In our example, you'll add the following rule:

```JSON
{
  "messages": {
    "filter": "company.id = 838"
  }
}
```

With the generated token, your search will restrict access based on `company.id`, so users will only see messages within their company.

Store this token in your primary data store (Postgres, MySQL, etc.). This mechanism is similar to those used in tools like Stripe.

Each time a user logs into your app, load this key into local storage and use it for the searches, ensuring that each user only has access to data relevant to their company.

Conclusion
----------

[Creating a multi-tenant application using Meilisearch](/blog/multi-tenancy/)s quite straightforward once you understand how to structure your data and configure your search attributes correctly. By following this guide, you can ensure that your application provides a secure, efficient, and user-friendly search experience. If you have any question, you can join us on [Discord](https://discord.gg/meilisearch/?ref=blog.meilisearch.com).

Boost productivity and streamline development with **[Meilisearch Cloud](https://www.meilisearch.com/cloud)**. No more server deployment or manual updates. Try it **free** for 14 days, no credit card needed.

For more things Meilisearch, subscribe to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e&ref=blog.meilisearch.com). You can learn more about our product by checking out our [roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and participating in our [product discussions](https://github.com/meilisearch/product/discussions?ref=blog.meilisearch.com).

_Happy coding!_

Multi-tenancy guide

Welcome everyone to our latest Meilistar interview! To our faithful readers, you already know the gist of it all, but if it’s the first time reading this type of blog post, the [Meilistars](/blog/2023-contributor-program-restrospective/)re Meilisearch’s very own contributors program, populated by some of our most talented or oldest contributors.

Who is Vishal?  

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

Today, we’re sitting down with Vishal Sodani, Mumbai-based freelancer. Not only is he a self-taught polyglot programmer, he’s also been building web-based products, mostly in Django, since 2011. He’s the developer behind learned.vcreation.xyz to which he integrated Meilisearch. Aside from his dev experience, Vishal is an avid reader and a chess enthusiast!

But that’s not all:

> “I love exploring Rust now and then. I built learned.vcreation.xyz (a note taking and bookmarking site) in actix-web and published my only crate for a client [https://crates.io/crates/migamake-api-cloudflare](https://crates.io/crates/migamake-api-cloudflare)”

Not unlike our very own integration manager Bruno, [whose interview you can read here](/blog/hacktoberfest-stories-from-contributor-to-manager/)ishal discovered Meilisearch at the occasion of Hacktoberfest, the yearly celebration of open source!

An October-themed adventure  

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

It is positively thrilling to know Hacktoberfest still remains a source of discovery for open-source enthusiasts year after year! Indeed, [Hacktoberfest 2022](/blog/hacktoberfest-2022-recap/)as far from Vishal’s first participation, but rather his fourth. We consider ourselves lucky to have managed to catch Vishal’s attention last October, especially considering it’s the only time of the year he’s able to contribute to various projects due to his busy schedule, but the developer returned our love tenfold:

> “I love the easy setup and usage of Meilisearch.  
> While searching for open-source projects to participate in Hacktoberfest, I unexpectedly came across Meilisearch. Having already implemented full-text search using Postgres, my curiosity piqued when I learned about Meilisearch, and I became increasingly interested in exploring it.”

This is definitely a point we take great pride in: being able to easily get into the Meiliverse and use Meilisearch right away! We’re glad Vishal got that feeling too!  
  
Coincidentally, we’d also written a blog post about Postgres ([that you can read here if you wish](/blog/postgres-full-text-search-limitations/)o we were curious to know if Vishal agreed with the content we wrote or if he’d had a different experience on his side:  

> “When it came to utilizing Postgres full-text search, I had a rudimentary understanding. Getting started with it involved delving into documentation and articles. Subsequently, I developed code in Golang to execute queries to the back-end for conducting searches. It was a trial-and-error process, but eventually, I managed to make it work. However, in contrast, using Meilisearch for the same use case was a breeze.”

Seeing as Vishal discovered Meilisearch during Hacktoberfest, we were curious to know how his contribution journey went at such a frantic time. Thankfully, he only had good things to share about our maintainers:

> “The experience was smooth. I was able to set up the repository easily. And, during my contribution I was given timely excellent guidance. So, this made my journey enjoyable.”

The battle for constant improvement isn’t over!  

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

As a final point, we were eager to hear about which features were Vishal’s favourite, and which ones could still use some work according to him:  

> “Right now my favorite features are - ease of setup, client library in golang which makes it easy to add documents from my golang web app, documentation is good which makes it easy to know the features available and their usage.  
> I think it would be good to have more complete examples in repository; though I have not looked at repo since sometime; collection of advice/notes from real-world usage shared by other users. Sometimes when I browse issues I find interesting comments by users which helps one to learn.”

Especially valuable feedback as we’re constantly working on improving our [SDK](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks#sdks) documentation!  
  
A big thank you to Vishal for his time, it was lovely hearing about his experience and we hope his story, as well as [Bruno](/blog/hacktoberfest-stories-from-contributor-to-manager/)’s will inspire many more to join us during future events!

Vishal Sodani: POV of a Hacktoberfest contributor

[Qogita](https://www.qogita.com/) is a leading global wholesale B2B platform that is trying to revolutionize how products are discovered and procured. On a mission to simplify B2B trade, Qogita helps its customers generate higher margins and turnover while saving time with the help of its innovative technology.

**By partnering with Meilisearch, Qogita is able to ensure high exposure for sellers and increased relevancy for buyers, resulting in an excellent buyer-seller interaction experience.**

> _"Meilisearch has empowered us to deliver lightning-fast and highly relevant search results tailored to our customers' needs. Its seamless integration with our systems has positively impacted developer experience, making local environment setup, testing, and CI/CD automation significantly more efficient. Additionally, Meilisearch has proven to be a cost-effective solution, resulting in substantial savings for Qogita."_  
> **_\- Ivo Silva, Engineering Director at Qogita_**

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

### Challenge

The wholesale industry of today, due to its size and maturity, remains highly traditional in terms of business practices and procurement methods. This means suppliers are hard to find, hard to work with, and often resistant to even taking on new customers.

Qogita aims to address this challenge by making it incredibly easy for sellers and buyers to connect through its platform, all in one place. By offering innovative solutions such as AI-powered pricing and cost optimization, tailoring product search capabilities to users’ actual needs, and providing an excellent buyer-seller interaction via search.

### Why Qogita chose Meilisearch

Prior to Meilisearch, Qogita used Algolia as their search provider and was satisfied in terms of functionality and performance. However, Qogita's team strove for further optimization when it came to both technology and costs. An evaluation was launched to assess alternatives, and a thorough comparison between Meilisearch, Typesense, and Algolia was performed.

The evaluation primarily focused on relevancy, ensuring that the search results were not significantly disrupted with Algolia's results serving as the baseline for comparison. Key searches were conducted for popular products and categories to determine the sorting order and overall performance. Additionally, the evaluation considered the handling of typos and common misspellings, which frequently occur in user searches.

The other factors that contributed to the choice included:  

1.  ******Cost-effectiveness******  
    All the alternatives performed well in the key areas of evaluation, but Meilisearch emerged as the preferred choice due to its cost-effectiveness. Since Qogita has a relatively lean DevOps team, selecting Meilisearch Cloud for production offered a desirable combination of affordability and provided services, including confidence in terms of infrastructure reliability and the high availability assurance.  
    
2.  ******Developer experience******  
    Throughout the entire internal proof-of-concept (PoC) process, the developer experience was a key aspect for evaluation. Meilisearch proved to be advantageous for Qogita as it provided a convenient Python library which simplified the migration process. Setting up containers on Meilisearch Cloud was also a straightforward task. Additionally, Meilisearch's vibrant and engaged open source community served as a significant advantage, establishing trust within Qogita's team early on.  
    
3.  ******Product cadence and roadmap******  
    Qogita’s team was impressed by the speed with which Meilisearch was able to achieve feature parity with the alternatives, despite being one of the youngest search solutions on the market. Additionally, Meilisearch presented a solid [roadmap](https://roadmap.meilisearch.com/tabs/1-under-consideration) that included several features aligned with the value envisioned by Qogita's team for its search initiatives in the near future.

### Implementation and moving to Meilisearch Cloud

Qogita initially self-hosted to evaluate if Meilisearch fulfilled its requirements in terms of development experience. Following the evaluation, production was migrated to Meilisearch Cloud, providing Qogita's team with peace of mind regarding infrastructure outsourcing. The transition from Algolia and the rollout of Meilisearch production went seamlessly, maintaining a high level of internal developer satisfaction.

### Results and Vision

Qogita highlighted higher developer satisfaction as one of the main benefits of choosing Meilisearch Cloud as their search provider, with ease of integration and out-of-the-box relevancy being key contributing factors.

The engineering department's goal was to ensure accurate data and product delivery, as well as providing the best user experience in connecting buyers and sellers through the platform. Meilisearch empowered Qogita team to deliver lightning-fast and highly relevant search results, tailored to meet the specific needs of their customers.

In terms of their vision for search efforts, Qogita expressed that the upcoming facet value search feature (coming to Meilisearch in v1.3) would enhance the user search experience even further. Facets allow customers to refine search results by multiple categories simultaneously. For a company like Qogita, which carries tens of thousands of brands in its catalog, facet search will enable the display and exposure of a greater number of brands to users, with further improved relevancy.

Globally, AI innovation is gaining prominence, and Qogita's team envisions a future that involves contextual search, meaningful search suggestions, and personalization. Meilisearch's upcoming [vector search release](/blog/vector-search-announcement/ marks an exciting venture into the AI space, aiming to fulfill these requirements and provide fast and relevant search for AI-powered applications.

Qogita simplifies B2B trade with Meilisearch Cloud

Today we’ll learn how to promote results by pinning given documents at the top of search results. This can be used in ecommerce to give more visibility to featured products or in-app search to prioritize user-specific content. We’ll use Node.js and React to implement promoted documents.

<Callout>
  Need promoted documents inside the Meilisearch engine? [Give your feedback](https://portal.productboard.com/meilisearch/1-meilisearch/c/98-promoting-documents?utm_medium=social&utm_source=portal_share)!
</Callout>

This tutorial will use a sample movie dataset. Our objective will be to have “Finding Nemo” at the top of the results when typing “funny”, “children”, or “fish”.

Folder structure
----------------

In this guide, we’ll separate the frontend code from the backend code used to configure Meilisearch.

We’ll organize our project using the following folder structure:

```json
my-app/
├─ node_modules/
├─ data/ <-- Backend code goes there
│  ├─ setup.js
│  ├─ movies.json
│  ├─ promoted-movies.json
├─ src/ <-- React code will go there
│  ├─ App.jsx
│  ├─ main.js
│  ├─ ...
├─ package.json
```

First, create a directory for our application (eg. `my-app`) or use an existing one. In our application directory, let’s create a `data` folder for the backend code.

Download the JSON dataset and store them in our new `data` folder. Download the datasets here:

[Movies](/blog/content/files/2023/07/movies.json) ("Download")

[Promoted movies](/blog/content/files/2023/07/promoted_movies.json) ("Download")

Alright. Let’s code!

Meilisearch setup
-----------------

First, we need to launch a Meilisearch instance. You can do so by following instructions in the [local installation guide](https://www.meilisearch.com/docs/learn/getting_started/installation#local-installation) or creating an account on [Meilisearch Cloud](https://www.meilisearch.com/pricing). We’ll write a setup script to configure our Meilisearch instance and seed the data.

<Callout>
  This setup script uses the JavaScript SDK, but you can use any of [Meilisearch SDKs](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks).
</Callout>

In this tutorial, we're using [Node 18](https://nodejs.dev/en/download/). Let's install the JavaScript SDK:

```bash
npm install meilisearch
```

Then, let's create a `setup.js` file:

```javascript
// data/setup.js

import { MeiliSearch } from 'meilisearch'

// Load the datasets
import movies from './movies.json' assert { type: 'json' }
import promotedMovies from './promoted_movies.json' assert { type: 'json' }

// Load credentials from environment
const credentials = {
  host: 'your Meilisearch host',
  apiKey: 'your Meilisearch Admin API key' 
}

// Configuration
const INDEX_NAME = 'movies'
const PROMOTED_INDEX_NAME = `promoted-${INDEX_NAME}`

const searchableAttributes = ['title', 'overview', 'genre', 'release_date']
const displayedAttributes = ['id', 'title', 'overview', 'genre', 'poster', 'release_date']

const setup = async () => {
	console.log('🚀 Seeding your Meilisearch instance')
	
	const client = new MeiliSearch(credentials)
	
	// Adding searchable attributes to movies index
client.index(INDEX_NAME).updateSearchableAttributes(searchableAttributes)
	// In the promoted movies index, only `keywords` is searchable
client.index(PROMOTED_INDEX_NAME).updateSearchableAttributes(['keywords'])
	
	// Both indexes have the same visible attributes
	// `keywords` is hidden in the promoted movies index
	client
		.index(INDEX_NAME)
		.updateDisplayedAttributes(displayedAttributes)
	client
		.index(PROMOTED_INDEX_NAME)
		.updateDisplayedAttributes(displayedAttributes)
	
	// Adding documents
	await client.index(INDEX_NAME).addDocuments(movies)
	await client.index(PROMOTED_INDEX_NAME).addDocuments(promotedMovies)
	
	// Wait for tasks completion
	await watchTasks(client, INDEX_NAME)
	await watchTasks(client, PROMOTED_INDEX_NAME)
}

// Helper to watch tasks
const watchTasks = (client, uid) {
	console.log(`Watching tasks on index ${uid}`)
	const tasks = await client.index(uid).getTasks()
	console.log(`${uid} index: waiting for tasks`)
	await client.index(uid).waitForTasks(tasks)
	console.log(`${uid} index: tasks finished`)
}

await setup()
```

This script creates our two indexes. Let’s recap what it does:

*   It sets the same [displayed attributes](https://www.meilisearch.com/docs/learn/configuration/displayed_searchable_attributes#displayed-fields) for both `movies` and `promoted-movies`.
*   It sets the [searchable attributes](https://www.meilisearch.com/docs/learn/configuration/displayed_searchable_attributes#searchable-fields); only `keywords` is searchable in the `promoted-movies` index.
*   It adds documents to our Meilisearch indexes.

<Callout>
  To [optimize indexing speed](/blog/best-practices-for-faster-indexing/ always add documents _after_ configuring settings.
</Callout>

We can now run the script with Node.js:

```bash
node setup.js
```

Our Meilisearch instance is now configured and seeded. 🥳 It’s time to implement promoted results using React!

Displaying promoted results
---------------------------

First, we’ll navigate back to the root directory of our application (eg. my-app). We’ll use Vite to create the React app in this folder.

```bash
npm create vite@latest . --template react
```

If the CLI asks to remove existing files from the current directory, answer 'No'.

Then, let’s install the additional dependencies for [integrating InstantSearch with Meilisearch](/blog/instant-meilisearch/):

```bash
npm install @meilisearch/instant-meilisearch react-instantsearch-hooks-web
```

Let’s edit our App component to display search results. We want the promoted results to show up before the rest. Let’s replace the `App.jsx` boilerplate code with our own:

```javascript
// src/App.jsx

import { instantMeiliSearch } from '@meilisearch/instant-meilisearch'
import { InstantSearch, SearchBox, Hits, Index } from 'react-instantsearch-hooks-web';
   
const MEILI_HOST = 'your Meilisearch host'
const MEILI_SEARCH_KEY = 'your Meilisearch Search API key'

const meilisearchClient = instantMeiliSearch(MEILI_HOST, MEILI_SEARCH_KEY)

const App = () => (
	<div>
		<h1>Hello React</h1>
		<InstantSearch searchClient={meilisearchClient}>
			<SearchBox />
			<h2>Results</h2>
			<Index indexName='promoted-movies'>
				<Hits />
			</Index>
			<h2>More results</h2>
			<Index indexName='movies'>
				<Hits />
			</Index>
		</InstantSearch>
	</div>
);

export default App;

```

We can now run the development server using `npm run dev`. In the browser, our app should display something like this:

![HTML output of the code above](https://unable-actionable-car.media.strapiapp.com/Screenshot_2023_07_20_at_12_50_49_f0c190da8d.png)

Displaying promoted results before other results

Congrats. We’ve successfully displayed our promoted results before the rest of the results. 🎉

<Callout>
  Got stuck? Don’t hesitate to ask for help in our [Discord community](https://discord.meilisearch.com/).
</Callout>

Going further
-------------

This tutorial explored one approach for implementing promoted results. An alternative technique would be implementing document pinning in the backend—using one of [Meilisearch SDKs](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks). This approach has the benefit of allowing to merge results in a single response (as if they were coming from a single index).

Both techniques can achieve similar results. We also plan to integrate [promoted documents](https://portal.productboard.com/meilisearch/1-meilisearch/c/98-promoting-documents?utm_medium=social&utm_source=portal_share) in the Meilisearch engine. Give your feedback on the previous link to help us prioritize it.

For more things Meilisearch, you can subscribe to our [newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e). You can learn more about our product by checking out the [roadmap](https://roadmap.meilisearch.com/) and participating in our [product discussions](https://github.com/meilisearch/product/discussions).

For anything else, join our developers' community on [Discord](https://discord.meilisearch.com/).

I’ll see you there.

Meilisearch latest news and company updates