How to boost your search results with filter scoring

In this era of information overload, the efficiency of documentation is determined not just by its quality but also by how easily users can find what they're searching for. Enhancing your documentation with advanced search capabilities can significantly elevate user experience.

Meilisearch Cloud's **Documentation crawler** offers just that, bridging the gap between vast content and user-friendly searchability.

What is a crawler?
------------------

A web crawler, sometimes known as a 'spider' or 'bot', is a digital tool that roams the vast expanse of the internet, indexing and cataloging content for search engines. This ensures that the most relevant pieces of information are presented to users during their searches.

What is Meilisearch’s Documentation crawler?
--------------------------------------------

Meilisearch's Documentation crawler is not just a traditional crawler; it also functions as an efficient scraper. While it extracts vital data from web pages, it simultaneously honors the inherent structure of the documentation, ensuring precise and structured indexing.

This system allows users to integrate [search functionality](https://meilisearch.org.cn/docs/learn/what_is_meilisearch/overview#cloud-release&utm_source=blog&utm_medium=crawler-release#features) into their documentation, ensuring that their audiences can swiftly locate the information they need.

How to use the documentation crawler?
-------------------------------------

Using the Documentation Crawler is a breeze; all it requires is a Meilisearch Cloud project and your existing documentation's URL.

### Setting up your project

First of all, you need a running project in [Meilisearch Cloud](https://meilisearch.org.cn/cloud#cloud-release&utm_source=blog&utm_medium=crawler-release). Once you have created a project, navigate to your project's index list and create a new index.

![Step 1 of Create Index form: Enter the index name.](https://unable-actionable-car.media.strapiapp.com/create_an_index_57ca6f70f6.png)

### Crawling your content

When prompted to import your documents, choose 'Documentation Crawler.'

![Step 2 of Create Index form: Import documents via crawler or file upload.](https://unable-actionable-car.media.strapiapp.com/select_docs_crawler_e7c7fcfa52.png)

Then, input or paste your documentation's URL and click on ‘Next’.

![Step 2 of Create Index form: Import documents using a crawler by pasting the website URL](https://unable-actionable-car.media.strapiapp.com/paste_url_2f1c23072e.png)

Click on 'Run' to start crawling your documentation content and push it into a Meilisearch instance. This process may take several minutes.

![Setup interface for the Crawler with a 'Run' button.](https://unable-actionable-car.media.strapiapp.com/click_on_run_eeecb9b7eb.png)

### Post-crawling verification

Once the status updates to 'ready', you can return to your project's overview and access the 'search preview'. Click on the project’s URL or select the 'Preview search' option from the top menu.

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

Perform a few searches to ensure that your documentation has been indexed correctly. This step is especially useful for understanding the schema of your documents.

![Search preview displaying results for the query 'releva' with highlighted matches.](https://lh4.googleusercontent.com/BJ9jNV_RA4q42ONIw54vQXyCSEu41Q_6xKY5W6sMxK02XqufBV8iedNRSZZl6q2NtqKaZEjpOVDLEC7TFQmrj7nci5-FT87gFs8UnqfDa0M1PRrm-NLUD6odr2a4m1bbSIGgwlqxtyIqmEYQ3sI4YIc)

Adding a search bar to your documentation
-----------------------------------------

Once you've successfully indexed your documentation using Meilisearch's Documentation Crawler, the next step to enhancing user experience is integrating a search bar into your documentation.

Return to your project and navigate to your index settings. From there, select the 'tools' tab and then choose 'crawler'. This will reveal the crawler settings and associated resources.

![Setup interface for the Crawler with the 'UI starter kit: Doscsearch' option.](https://lh3.googleusercontent.com/woHfyr-bTDS7fbDTRnpq-GR61IwVq6fvfmCGoRDkiVORf7x6wSjSsXUgXRnmepr7YQ_E3HZHRBW3FScZSE1vS8GIJwvGs6GfUCIh0eJckapWsJViZyaZ-Bqa6Vdj_2EpXgHG4WLQTgUUN9ubYfXCQcA)

The [UI starter kit](https://github.com/tauri-apps/meilisearch-docsearch#cloud-release&utm_source=blog&utm_medium=crawler-release) helps you add a functional search bar to your documentation with just a few lines of code.

You are now fully equipped to add a seamless search experience to your documentation!

\_\_\_\_\_

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

For anything else, join our developer community on [Discord](https://discord.gg/meilisearch#cloud-release&utm_source=blog&utm_medium=crawler-release).

Introducing Documentation Crawler — Meilisearch Cloud

This feature enhances your dashboard experience by offering a comprehensive view of Meilisearch's [asynchronous operations](https://meilisearch.org.cn/docs/learn/async/asynchronous_operations#cloud-release&utm_source=blog&utm_medium=tasks-view-release).

**Core features**
-----------------

*   **Detailed task list**: the Tasks View showcases a list of your tasks, detailing their UID, status, type, index UID, duration, and enqueued date. Moreover, you can sort the list based on these parameters.
*   **JSON panel**: alongside the list, there's a panel displaying the selected task's JSON, which can easily be copied.
*   **Filtering**: you can sift through tasks based on their status, type, and date.
*   **Refresh option**: whenever a task is enqueued, the `Show new tasks` button lets you decide when to view the latest task without disrupting your current view.
*   **Customization**: customize the view further by toggling the columns' visibility according to your preferences.

![Tasks view screenshot](https://storage.noticeable.io/projects/OQ6S6bocohVRzziV6Tlc/publications/BLDwc6IdPRkf5ZsdEOoa/01h821n7ed9mje0m5y9dagk9rt-image.png)

**Compatibility notes**
-----------------------

*   **Version requirements**: this feature is exclusively available for projects that run on Meilisearch v1.0.0 or higher.
*   **Latest version perks**: for those using the [Meilisearch v1.3.0](/blog/v1-3-release/#cloud-release&utm_source=blog&utm_medium=tasks-view-release) or above, the Tasks View also displays the count of fetched tasks.

We hope this addition enhances your project management efficiency. Enjoy exploring!

Introducing Tasks View — Meilisearch Cloud

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://meilisearch.org.cn/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://meilisearch.org.cn/docs/learn/getting_started/installation) or via [Meilisearch Cloud](https://meilisearch.org.cn/cloud).
2.  Ensure you have your favorite [language SDK](https://meilisearch.org.cn/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://meilisearch.org.cn/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

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://meilisearch.org.cn/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://meilisearch.org.cn/docs/learn/core_concepts/indexes#index-creation) per company with Meilisearch, it's not recommended due to [performance](https://meilisearch.org.cn/docs/learn/advanced/indexing) reasons. Meilisearch processes [tasks](https://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/docs/reference/api/settings#update-settings) in the documentation.
</Callout>

Next, you'll need to [create a messages index](https://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/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/#blog.meilisearch.com).

Boost productivity and streamline development with **[Meilisearch Cloud](https://meilisearch.org.cn/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/#blog.meilisearch.com) and participating in our [product discussions](https://github.com/meilisearch/product/discussions#blog.meilisearch.com).

_Happy coding!_

Multi-tenancy guide

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://meilisearch.org.cn/docs/learn/getting_started/installation#local-installation) or creating an account on [Meilisearch Cloud](https://meilisearch.org.cn/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://meilisearch.org.cn/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://meilisearch.org.cn/docs/learn/configuration/displayed_searchable_attributes#displayed-fields) for both `movies` and `promoted-movies`.
*   It sets the [searchable attributes](https://meilisearch.org.cn/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://meilisearch.org.cn/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.

Implementing promoted search results with React InstantSearch

Adding documents to Meilisearch is taking longer than expected? The following tips will help you speed up the indexing process.

<Callout>
  This is a very short guide. For a more comprehensive understanding, you can read our article on [indexing best practices](/blog/best-practices-for-faster-indexing/)
</Callout>

Define searchable attributes
----------------------------

To speed up indexing, review the [searchable attributes](https://meilisearch.org.cn/docs/learn/configuration/displayed_searchable_attributes#searchable-fields) list and ensure it includes only the fields you want to be checked for query word matches. This improves relevance and search speed by eliminating irrelevant data and preventing unnecessary database growth.

Utilize filterable and sortable attributes
------------------------------------------

Some fields may not contain text but can still be vital for [filtering](https://meilisearch.org.cn/docs/learn/fine_tuning_results/filtering) and [sorting](https://meilisearch.org.cn/docs/learn/fine_tuning_results/sorting) results. Evaluate if numeric and boolean field values can be part of the filterable or sortable attributes lists.

Review ranking rules
--------------------

Modifying [ranking rules](https://meilisearch.org.cn/docs/learn/core_concepts/relevancy#ranking-rules) may trigger a reindexing process. Consider the impact and plan accordingly.

Optimize document size
----------------------

Smaller documents are processed faster. Compress your data using methods such as `br`, `deflate`, or `gzip` supported by Meilisearch. Refer to the [documentation](https://meilisearch.org.cn/docs/reference/api/overview#content-encoding) for more details.

Keep up with the latest stable version
--------------------------------------

Regularly update to the [latest Meilisearch release](https://github.com/meilisearch/meilisearch) to take advantage of performance improvements that can significantly enhance indexing speed.

Conclusion
----------

By following these recommendations, you can optimize the performance of Meilisearch and enhance the overall search experience for your users. If you have any question, you can join us on [Discord](https://discord.gg/meilisearch/#blog.meilisearch.com).

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

_Happy coding!_

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/#blog.meilisearch.com) and participating in our [product discussions](https://github.com/meilisearch/product/discussions#blog.meilisearch.com).

Indexing optimization guide

Vector search enables efficient retrieval of objects sharing similar characteristics. This AI-powered search technique uses embedding vectors. These vectors are mathematical representations of objects generated by machine learning models (like LLMs). Starting with the 1.3 release, Meilisearch supports storing and searching vectors.

<Callout>
  Meilisearch v1.3 is out! Read the [release notes](/blog/v1-3-release/#vector-search&utm_source=blog&utm_medium=announcement)
</Callout>

Powering the Future of Search
-----------------------------

Vector search might be the dawn of a new era for search. Its use cases are numerous. In [ecommerce](https://ecommerce.meilisearch.com/#vector-search&utm_source=blog&utm_medium=announcement), it enables offering recommendations for similar products. It also allows building multi-modal search, like image or audio search. Building upon conversational AI technologies enables the creation of Q&A applications. Combining vector search with user-provided information like geolocation and search history can power even more contextual search experiences.

Vector search is also the foundation for [semantic search](https://en.wikipedia.org/wiki/Semantic_search), which aims to understand the query’s meaning. Conversely, traditional lexical search only matches keywords. With semantic search, a `warm clothes` query could give results like `gloves`, `coat`, and more results related to winter clothing.

Vector search unlocks a world of new capabilities for search. Take a look at what some users have already implemented:

*   [similar videos recommendations](https://github.com/adrienpoly/rubyvideo/pull/19) on a site listing Ruby conferences
*   a [documentation chatbot](https://blazy-chat.vercel.app/) proof of concept using [GPT3.5](https://platform.openai.com/docs/models/gpt-3-5) and [LangChain](https://github.com/hwchase17/langchain)

<Callout>
  Meilisearch is available as a [LangChain vector store](https://python.langchain.ac.cn/docs/integrations/vectorstores/meilisearch).
</Callout>

Getting Started with Meilisearch Vector Store
---------------------------------------------

  
Starting with v1.3, you can use Meilisearch as a vector store. Meilisearch allows you to store vector embeddings alongside your documents conveniently. You will need to create the vector embeddings using your third-party tool of choice ([Hugging Face](https://hugging-face.cn/), [OpenAI](https://openai.com/)).

First, spin up a Meilisearch instance. You can [install Meilisearch locally](https://meilisearch.org.cn/docs/learn/getting_started/installation#vector-search&utm_source=blog&utm_medium=announcement#local-installation) or create a [Meilisearch Cloud](https://meilisearch.org.cn/cloud#vector-search&utm_source=blog&utm_medium=announcement) account.

Then, enable the _vector store_ experimental feature:

```Bash
curl \
  -X PATCH 'http://localhost:7700/experimental-features/' \
  -H 'Content-Type: application/json'  \
  --data-binary '{
    "vectorStore": true
  }'
```
<Callout>
  This guide uses \`curl\` to make HTTP requests to communicate with Meilisearch. In practice, we recommend using our [SDKs](https://github.com/meilisearch/integration-guides) instead.
</Callout>

Meilisearch now accepts a `_vector` field in your documents. Use it to store the vector embeddings corresponding to your document in this 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], "title": "And Your Bird Can Sing" }
     ]'
```

After storing your vectorized documents in Meilisearch, you can query them using the `search` or `multi-search` route. To do this, you need to compute the vector of your query (using a third-party tool) and send it in the `vector` field.

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

When using vector search, returned documents include a `semanticScore` field:

```Bash
{
  "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], "title": "And Your Bird Can Sing", "_semanticScore": 0.78 }
  ],
  "query": "",
  "vector": [0, 1, 2],
  "processingTimeMs": 0,
  "limit": 20,
  "offset": 0,
  "estimatedTotalHits": 2
}

```
<Callout>
  This API is experimental. You can help us improve it by sharing your feedback in [this Github discussion](https://github.com/meilisearch/product/discussions/677#vector-search&utm_source=blog&utm_medium=textlink).
</Callout>

A First Step Toward Semantic Search
-----------------------------------

Vector search is our first step towards semantic search. But our long-term goal is to provide hybrid search—combining the benefits of full-text and semantic search to provide the most relevant search experience. Clément Renault, founder and CTO of Meilisearch, shared his thoughts on Github about [exploring semantic search](https://github.com/meilisearch/meilisearch/issues/3838#vector-search&utm_source=blog&utm_medium=textlink) — read for a founder’s perspective. We can’t wait to share more with you!

Drop your email below to learn more about our progress with AI-powered search. We’ll keep you posted on all updates regarding vector search & semantic search.

Get Meilisearch AI updates straight to your inbox 💌
----------------------------------------------------

\* indicates required

Email Address \*

Marketing Permissions

Please select all the ways you would like to hear from Meilisearch:

Email

You can unsubscribe at any time.

We use [Mailchimp](https://mailchimp.com/legal/terms) to send emails.

We’re excited to walk our first steps toward semantic search. We can’t wait to hear your thoughts on integrating Meilisearch as a vector store. You can give your feedback in [this Github discussion](https://github.com/meilisearch/product/discussions/677#vector-search&utm_source=blog&utm_medium=textlink).

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

For anything else, join our developers community on [Discord](https://discord.meilisearch.com/#vector-search&utm_source=blog&utm_medium=announcement).

I’ll see you there.

Vector storage is coming to Meilisearch to empower search through AI

This guide is intended for both advanced and medium-level developers and will provide a clear roadmap to managing data access efficiently in your application.

Understanding Role-Based Access Control
---------------------------------------

Role-Based Access Control (RBAC) is a method of regulating access to computer or network resources based on the roles of individual users within your enterprise. In the context of an application, it refers to controlling which users can access what information, ensuring data privacy and security.

Meilisearch provides an elegant solution to RBAC: [tenant tokens](https://meilisearch.org.cn/docs/learn/security/tenant_tokens#blog.meilisearch.com#what-are-tenant-tokens-and-how-are-they-different-from-api-keys-in-meilisearch). Tenant tokens allow you to easily limit a user's access to the specific data they are permitted to view.

Implementing RBAC in a Notion-like Application with Meilisearch
---------------------------------------------------------------

Let's illustrate this concept using an example inspired by Notion, the all-in-one workspace where you can write, plan, collaborate, and get organized.

In our simplified version of Notion, users belong to a workspace, and each workspace contains pages. Some users may have access to certain pages, while others may not.

A page could be represented as follows:

```json
    {
        "id": "477f110a-848a-4c23-969d-e7ff7a648c65",
        "workspace_id": "c3d3e966-60e2-4390-9d49-0a9d60f8f02d",
        "path": "/knowledge base/hello world",
        "title": "Hello World",
        "content": "#This is the first page",
        "can_view": [
            "ec6dfb90-2e89-4912-8e01-a25bb2a5a524",
            "b315c817-b3c4-4604-bd1f-122e5e452c91",
            "45c233cd-8160-4a38-8347-b13bc4709345",
            "ab58453d-6d56-496d-a5fa-ddb7c76b5a29",
            "d6de8463-5514-4bfe-90ba-471fbe9a23c6",
        ],
        "created_at": 1686512258,
        "updated_at": 1686512329,
    }
 ```

The `can_view` attribute is a list of all `user_id` that have access to this page.

<Callout intent="note">

Learn how to [update your settings](https://meilisearch.org.cn/docs/reference/api/settings#blog.meilisearch.com#update-settings) in the documentation.

</Callout>

Next, you'll need to create a `pages` index and add the following settings:

```json
    {
        "displayedAttributes": [
            "id",
            "path",
            "title",
            "updated_at"
        ],
        "searchableAttributes": [
            "title",
            "content"
        ],
        "filterableAttributes": [
            "workspace_id",
            "can_view"
        ],
        "sortableAttributes": [
            "created_at",
            "updated_at"
        ]
    }
```

Here's a brief explanation of these attributes:

*   `displayedAttributes`: The attributes shown in the search results of your application. In this case, we display the page `id`, `path`, `title`, and `updated_at`

*   `searchableAttributes`: The attributes that can be searched. For a Notion-like app, `title` and `content` of a page would be most relevant

*   `filterableAttributes`: These are the attributes you can filter by. We've included `workspace_id` and `can_view` to control access to pages based on the workspace and user permissions

*   `sortableAttributes`: These are the attributes by which you can sort your search results. We've included `created_at`  and `updated_at` to support sorting pages by creation and modification dates

Creating tenant tokens
----------------------

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

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

```json
    {
        "pages": {
            "filter": "workspace_id = c3d3e966-60e2-4390-9d49-0a9d60f8f02d && can_view = 45c233cd-8160-4a38-8347-b13bc4709345"
        }
    }
```

With the generated token, your search will restrict access based on `workspace_id` and `can_view` (user’s ID), so users will only see pages they have access to.

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

Load this key into local storage each time a user logs into your app, and use it for searches, thereby ensuring that each user only has access to the data they should.

<Callout intent="tip">

Seeking a detailed, step-by-step tutorial? Explore our in-depth [article on multi-tenancy](https://blog.meilisearch.org.cn/multi-tenancy/)

</Callout>

Wrapping up
-----------

Implementing RBAC with Meilisearch allows you to create applications with fine-grained access controls, ensuring that users only have access to the data they are permitted to see. By following this guide, you can improve the data security and privacy of your application while still providing a seamless search experience to your users. If you have any question, you can join us on [Discord](https://discord.gg/meilisearch/#blog.meilisearch.com).

_Happy coding!_

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/#blog.meilisearch.com) and participating in our [product discussions](https://github.com/meilisearch/product/discussions#blog.meilisearch.com).

Meilisearch 最新消息和公司动态

如何通过过滤器评分提升搜索结果

文档爬虫介绍 — Meilisearch Cloud

任务视图介绍 — Meilisearch Cloud

如何使用第二个索引实现文档提升

多租户指南

使用 React InstantSearch 实现提升的搜索结果

索引优化指南

向量存储即将登陆 Meilisearch，以增强 AI 搜索能力

如何使用 Meilisearch 实现 RBAC