This feature enhances your dashboard experience by offering a comprehensive view of Meilisearch's [asynchronous operations](https://www.meilisearch.com/docs/learn/async/asynchronous_operations?utm_campaign=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/?utm_campaign=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

At Meilisearch, we have long maintained our commitment to simplifying and streamlining the search process by prioritizing intuitive, user-friendly, and human-like search experiences.

In today's search technology landscape, _[keyword search](https://www.meilisearch.com/docs/learn/what_is_meilisearch/overview?utm_campaign=vector-search&utm_source=blog&utm_medium=launch#features)_ continues to play a pivotal role, swiftly locating content via specific keywords. Leveraging advanced algorithms and robust indexing, it ensures users find relevant information across vast data volumes.

However, traditional keyword approaches have inherent limitations in understanding user intent and at times can be overly predictable and simplistic. This is why we are introducing Meilisearch's _[vector search](https://www.meilisearch.com/docs/learn/experimental/vector_search?utm_campaign=vector-search&utm_source=blog&utm_medium=launch),_ which aims to challenge and enhance the familiar keyword search paradigm.

Vector search for AI-enhanced future
------------------------------------

The market-wide introduction of _vector search_ marks the arrival of a new era for search technology, with countless versatile applications. In _e-commerce_, it offers product recommendations based on similarities and multi-modal search capabilities such as image, audio, and video search. The fusion of vector search with conversational AI technologies opens doors for intuitive Q&A applications. Adding user data like geolocation and search history further expands its potential.

New search technology enhances relevancy alongside traditional keywords with semantic understanding going beyond simple keyword matching. It is capable of comprehending intent, returning results like **\[gloves\]** from a **\[warm clothes\]** query. These applications rely on _vector embeddings_—a type of data representation with semantic information that enables AI to gain understanding and maintain long-term memory. Stored in _vector databases_, embeddings represent different data dimensions, essential for understanding patterns and relationships. AI-powered vector database then leverages this information when matching search queries to answers.

Democratizing search
--------------------

In a data-rich world, effective content discovery is not a luxury - it’s crucial. Meilisearch's vision balances ambition with accessibility, aiming to make cutting-edge search technology inclusive. Key Meilisearch partners, such as [Hugging Face](/blog/hugging-face-democratizes-ai/ are already actively testing Meilisearch’s new vector database and storage capabilities.

> **Quentin de Quelen, Meilisearch’s CEO and Co-founder, said:** _“Meilisearch's hybrid search will democratize advanced search technology, focusing on simplicity and open-source customizability.”_

Building the future of search with vector search
------------------------------------------------

This release brings semantic and hybrid search capabilities to enhance applications for image, video, and audio search, product recommendations for e-commerce, precise personalization, and intuitive Q&A interactions.

Here are a few examples of potential applications made possible with the introduction of vector search:

*   **Semantic understanding:** Enable your search engine to act as a human-like assistant, delivering natural, context-aware results in a more conversational manner
*   **Multiformat capabilities:** Cover images, audio, and video, ensuring versatility.
*   **Personalization**: Matches preferences for tailored results, with a deeper understanding of user behavior and preferences,
*   **Precise Recommendations:** Enhance the discovery experience by suggesting similar items that align with users' genuine interests.
*   **Improved accuracy:** Improve relevancy and search accuracy through a deep understanding of each search query's meaning

Search evolution culminates in a hybrid search
----------------------------------------------

Meilisearch's journey leads to _hybrid search_, which combines traditional full-text efficiency with the innovation of semantic search and the adaptability of vector database. The hybrid approach enables search solutions to cater to a broad spectrum of use cases driven by customer-generated data sources. By integrating models from AI solution providers like OpenAI, Cohere AI, or Hugging Face, Meilisearch empowers users to calibrate _vector embeddings_ and infuse their business logic into the search engine.

Getting started
---------------

<Callout>
  For more guidance on how to get started, explore our [step-by-step tutorial on building semantic search with LangChain](/blog/langchain-semantic-search-tutorial/?utm_campaign=vector-search&utm_source=blog&utm_medium=launch)
</Callout>
```json
from langchain.vectorstores import Meilisearch
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.document_loaders import JSONLoader

# Load documents
loader = JSONLoader(
    file_path="./movies.json",
    jq_schema=".[] | {id: .id, title: .title, overview: .overview}",
    text_content=False,
)
documents = loader.load()

# Index documents
embeddings = OpenAIEmbeddings()
vector_store = Meilisearch.from_documents(documents=documents, embedding=embeddings)

# Search
query = "superhero fighting villains in a city corrupted by crime"
results = vector_store.similarity_search(
    query=query,
    k=3,
)

```

If you want to use Meilisearch vector search capabilities without LangChain, choose your favorite language and check out the [relevant SDK documentation here](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks?utm_campaign=vector-search&utm_source=blog&utm_medium=launch).

Want the quality of open-source without the headache of managing your servers and service? [Sign up for a free trial](https://meilisearch.com/cloud?utm_campaign=vector-search&utm_source=blog&utm_medium=launch) with Meilisearch Cloud today.

Introducing Meilisearch's vector search and vector database to navigate the future of search

[HitPay](https://hitpayapp.com/) is a one-stop payment fintech platform from Southeast Asia on a mission to enable small and medium businesses to accept payments easily.

**HitPay chose [Meilisearch Cloud](https://meilisearch.com/cloud) to power its customers' search securely and reliably, all while maintaining a lean engineering team and staying focused on its core offering.**

<Callout>
  ___"Using Meilisearch's open-source version for proof of concept, a single developer was able to quickly implement the complete flow, including UI and backend changes. This validated our use case and confirmed that Meilisearch was the right solution for our requirements. After that, transitioning to the Cloud was effortless."__ - Nitin Muthyala, Co-Founder and CTO at HitPay_
</Callout>

Challenge
---------

As an small and medium business-focused company, HitPay strives to simplify the learning curve for small business owners who lack time to learn and adapt complex payment tools.

Merchants utilizing HitPay often have sizable catalogs and a broad customer base, requiring efficient search functionality for e-commerce and in-store purchases. With search functionality not being within HitPay's core suite of solutions, it was decided to integrate a third-party tool. While searching for a suitable solution, the HitPay team came across Meilisearch.

Why Hit Pay chose Meilisearch
-----------------------------

### 1\. Easy to integrate

Historically, HitPay has been able to maintain a lean engineering team by actively seeking out nimble and adaptive tools to streamline its developers' work. When searching for a search solution to integrate into their existing back-end system built on PHP with the Laravel framework, HitPay prioritized simplicity and compatibility. They discovered that Meilisearch offered a driver for [Laravel Scout](https://laravel.com/docs/master/scout) that perfectly matched their requirements. Additionally, HitPay’s team was well-acquainted with the open-source space, and adopting an open-source search solution seemed like a logical initial step.

Nitin Muthyala, Co-Founder and CTO of HitPay, emphasized: _'We always begin with the open-source version of a solution, which has proven successful for us thus far. After testing Meilisearch's open-source solution on the internal use case, we realized how powerful it is.”_

### 2\. Developer experience

During the initial evaluation, Meilisearch was integrated into HitPay's internal dashboard, which contains a database of all its customers. The dashboard serves HitPay’s own account managers who need to search through their accounts by business owner names, business names, and affiliated emails. This presented challenges with long and repetitive names that included variations in spelling. With the efforts of a single developer, supported by helpful documentation and Meilisearch’s [out-of-the-box relevancy](https://www.meilisearch.com/docs/learn/core_concepts/relevancy), the pilot project didn’t require many tweaks and was successfully completed within a couple of days.

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

After successfully testing the open-source version of Meilisearch, HitPay made the decision to switch to the Meilisearch Cloud. A highly relevant and reliable search solution was crucial for HitPay's customers as it directly impacted their sales. To avoid the additional burden of constantly monitoring the production environment, HitPay transitioned to the Cloud version. This decision provided peace of mind, knowing that the business-critical search activity would be in safe hands at all times.

Nitin Muthyala, Co-Founder and CTO of HitPay, explained: _"Search is a fundamental piece in our production process, and HitPay couldn't afford for it to ever go down. So we opted for Meilisearch Cloud."_

During the transition, other competitors were briefly considered but eliminated early on. Meilisearch Cloud stood out as the ideal choice due to its ease of integration and the ability to check all the boxes right from the start.

Since the implementation of Meilisearch, HitPay's customers have especially appreciated the ability to search for amounts within an order, typo recognition, and the **increase in search API response speed by at least 50%** for free-text searches.

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

Transactions search

Results
-------

Today, Meilisearch is a valuable asset for HitPay’s customers and is integrated into two of HitPay's commerce products. The first is an **[online eCommerce shop](https://www.hitpayapp.com/online-store)**, where businesses can create their own storefronts. The second is **[HitPay's POS](https://www.hitpayapp.com/pos-software)** (point of sale), the product that allows businesses to search, catalog and **sync products across online and offline sales channels, and manage unlimited locations** for brick-and-mortar stores, where sales assistants need to **locate specific products** quickly to ensure the overall customer experience.

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

Meilisearch in HitPay's Point of Sale

To always keep the search relevant, HitPay offers a feature where merchants can pin or favorite specific products, which are then prioritized in search results. For customers who opt-in, HitPay sets up a workflow to automatically update the index with the most recent SKUs (Stock-keeping units) or favorited products, ensuring highly relevant search results that are always up-to-date.

Vision
------

In the future, HitPay aims to provide customizable user-facing analytics that caters to their customer's specific needs. This is particularly important for small and medium businesses, whose analytics requirements vary due to seasonal business patterns. HitPay envisions offering customization options for running analytics on any software, allowing customers to identify their most sought-after products and analyze unsuccessful searches. This aligns with Meilisearch’s product vision and HitPay's mission of powering product search for online shops and simplifying catalog searches for sales assistants in physical stores.

HitPay streamlines customers’ search capabilities while staying laser-focused on its core offering

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

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!

Meilisearch latest news and company updates