In today's interconnected world, many applications need to handle content in multiple languages. Meilisearch offers powerful capabilities for multilingual search, combining intelligent language handling with specialized models for optimal relevance. This guide will walk you through setting up multilingual search with Meilisearch, covering both full-text and semantic search approaches.

Why multilingual search matters
===============================

Before we dive into the technical details, let's consider why multilingual search is crucial:

1.  Global reach: Expand your audience by catering to users in their native languages.
2.  Improved user experience: Provide relevant results regardless of the language used in queries or content.
3.  Increased engagement: Users are more likely to interact with content they can easily find and understand.

Now, let's explore how Meilisearch makes multilingual search a breeze.

Full-text search: intelligent language handling
-----------------------------------------------

At its core, Meilisearch excels at handling diverse languages out of the box. Our [advanced tokenizer](https://www.meilisearch.com/docs/learn/indexing/tokenization?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search) is designed to work with:

*   Languages that use whitespace to separate words (like English, Spanish, and French)
*   Languages with different writing systems (such as Chinese, Japanese, and Thai)

### Automatic language detection

When you add documents to your Meilisearch index, the engine automatically detects the language of each field. This means you don't need to specify languages manually in most cases - Meilisearch will handle it for you.

For example, if your documents contain a mix of English and Spanish content:

```json
[
  {
    "id": 1,
    "title": "The quick brown fox",
    "description": "El zorro marrón rápido salta sobre el perro perezoso"
  },
  {
    "id": 2,
    "title": "La luna y las estrellas",
    "description": "A beautiful night sky filled with twinkling stars"
  }
]
```

Meilisearch will automatically detect and properly handle the different languages in each field, ensuring accurate search results across your multilingual content.

### Specifying languages for specific fields

While automatic detection works well in most cases, you might want more control over language handling for certain fields. Meilisearch allows you to [specify languages](https://www.meilisearch.com/docs/reference/api/settings#localized-attributes?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search) for particular attributes using the `localizedAttributes` setting.

Here's how you can set it up:

```json
{
  "localizedAttributes": [
    {
      "locales": ["eng"],
      "attributePatterns": ["title_en", "*_english"]
    },
    {
      "locales": ["spa"],
      "attributePatterns": ["description_es", "*_spanish"]
    }
  ]
}
```

This configuration tells Meilisearch to treat fields ending with `_en` or `_english` as English, and fields ending with `_es` or `_spanish` as Spanish. This approach is particularly useful when you have a consistent naming convention for your multilingual fields or when you want to ensure specific treatment for certain attributes.

Semantic search: Enhancing multilingual relevance
=================================================

While full-text search works well for many multilingual scenarios, semantic search can provide even better results, especially for complex queries or when dealing with nuanced meanings across languages.

Meilisearch supports various embedding models for semantic search, offering powerful auto-embedding capabilities. This means you can easily set up semantic search without having to manage the embedding process yourself. Meilisearch handles the generation and storage of embeddings automatically, seamlessly integrating them into your search experience.

For multilingual applications, we recommend using specialized multilingual models rather than relying on general-purpose models. These models are designed to understand and represent meaning across multiple languages, leading to more relevant search results in multilingual contexts.

One excellent option for multilingual semantic search is the [Cohere Multilingual embedding model](https://docs.cohere.com/docs/multilingual-language-models). It offers a great balance of speed and relevance across a wide range of languages. Cohere's model is particularly adept at understanding context and nuance in different languages, making it an ideal choice for diverse, multilingual content. Follow [the guide](https://www.meilisearch.com/docs/guides/ai/cohere?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search) if you want to do it now.

To explore different models and their performance, you can use the [Meilisearch playground](https://playground.meilisearch.com). This interactive tool allows you to test various embedding models and see how they perform with your specific multilingual queries and content.

Conclusion
----------

We encourage you to experiment with different settings and models to find the optimal configuration for your specific use case. And remember, the Meilisearch community is always here to help - join us on [Discord](https://discord.meilisearch.com/) or check out our documentation for more detailed information and support.

Ready to get started with multilingual search? Try Meilisearch today [with a 14 day trial](https://cloud.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=multilingual_search)!

Searching across multiple languages

How to add AI-powered search to a React app

🦩 Meilisearch 1.10 release
---------------------------

[![Meilisearch 1.10 release notes](https://unable-actionable-car.media.strapiapp.com/meilisearch_1_10_2b7000d5bd.jpg)](/blog/meilisearch-1-10/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

Meilisearch 1.10 introduces federated search and new language settings, and paves the way for AI-powered search stabilization.

[Read release notes](/blog/meilisearch-1-10/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

🚀 Meilisearch Next.js project starter
--------------------------------------

[![Developer Terminal with code: npx create-next-app -e with-meilisearch my-app](https://unable-actionable-car.media.strapiapp.com/GV_6_J_Ld_W_Ws_A_Ar6_Cd_3723955f2a.jpeg)](https://github.com/vercel/next.js/tree/canary/examples/with-meilisearch)

Integrating Meilisearch in a Next.js application just got much easier. Use the create-next-app CLI to scaffold a Meilisearch example in your new Next.js application.

[Learn more](https://github.com/vercel/next.js/tree/canary/examples/with-meilisearch?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

🛍️ Shopify storefront guide for Next.js
----------------------------------------

[![Build your Shopify storefront with Next.js and Blazity](https://unable-actionable-car.media.strapiapp.com/blazity_guide_14d74d3924.jpg)](/blog/next-js-shopify-storefront-with-blazity/utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

Learn to build a Shopify storefront with Next.js and the Blazity commerce starter, using Meilisearch hybrid search to serve all front-end data.

[Read guide](/blog/next-js-shopify-storefront-with-blazity/utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

📰 In the news
--------------

🎮 [Federated search demo](https://saas.meilisearch.com/deals?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

See how federated search can power app-wide search in our example CRM.

🐇 [Integrating Meilisearch Indexing with Directus](https://docs.directus.io/blog/integrating-meilisearch-indexing-with-directus.html)

Learn to build a custom Directus hook extension to index your data in Meilisearch.

🍿 [From Hackathon to Success: The Meilisearch Story](https://thebootstrappedfounder.com/kerollmops-from-hackathon-to-success-the-meilisearch-story/)

Listen to Arvid Kahl's interview of Meilisearch's founder and lead developer, Kero.

📢 [RFC: Query Suggestions](https://github.com/orgs/meilisearch/discussions/740)

Join the discussion to help us shape the future of query suggestions in Meilisearch.

📢 [RFC: Improving the search preview](https://github.com/orgs/meilisearch/discussions/766)

We want your feedback: how can we make it easier to test your search settings?

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

Discover how Symfony implemented search in their documentation with Meilisearch PHP. This enables developers to search for guides across 30 different versions—more than 12 million words.

[![Symfony's search solution for 12M words of documentation with Meilisearch](https://unable-actionable-car.media.strapiapp.com/image_67e9f20ca0.png)](/blog/symfonys-solution-for-documentation-search/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

[Read case study](/blog/symfonys-solution-for-documentation-search/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates)

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

🦸‍♀️ We’re hiring!
-------------------

See our open positions:

*   [Senior Full-Stack Software Engineer](https://www.meilisearch.com/careers?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates&utm_content=senior-full-stack-software-engineer)
*   [Founding Sales & Business Developer](https://www.meilisearch.com/careers?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates&utm_content=founding-sales-and-business-developer)

* * *

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions?ref=blog.meilisearch.com).

For anything else, join our developers community on [Discord](https://discord.meilisearch.com/?utm_campaign=newsletter&utm_source=blog&utm_medium=august-24-updates).

Meilisearch August updates

Searching across disparate data sources can be a real headache. But aggregating information from various databases or indices enables the creation of more relevant search experiences for users. In this guide, we'll explore what federated search is and the use cases it unlocks.

What is federated search?
-------------------------

Federated search empowers you to conduct searches across multiple systems simultaneously. In the context of a search engine, federated search allows querying numerous indices and retrieving the results in a single, consolidated list.

This differs from having a monolithic index that stores various types of resources where documents could be filtered by type. Leveraging multiple indices enables the implementation of specific ranking rules for each index.

Federated search extends the capabilities of [multi-index search](/blog/introducing-multi-search/?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search merging results into a unified, cohesive response. This allows surfacing the most relevant results across the entire dataset, rather than just the top hits for each individual index.

Federated search is a crucial feature for SaaS applications, where users frequently need to search through all available resources regardless of type. An example you might be familiar with is searching in Slack—a single search bar to find users, messages, and shared documents.

What are the benefits of federated search?
------------------------------------------

Integrating federated search into your application can facilitate more convenient search experiences. By supporting searches across multiple sources, you can build one search bar to query all the data. This eliminates the need for multiple menus or lists of results, resulting in a more intuitive and user-friendly interface.

The search experience is further enhanced by the increased relevance of the results. The comprehensiveness of the returned resources will match items that the user may not have initially considered including in their search (e.g., discovering a prospect's email in meeting notes instead of just contact details).

Uncovering the most pertinent result can be transformative for your users and your business. In an internal tool, relevant results enable users to make more informed decisions. However, in customer-facing applications, it can be the pivotal factor between converting a sale or not.

Locating information effortlessly within your application or e-commerce platform leads to higher customer satisfaction and improved retention. This allows users to extract more value from the service, ultimately elevating the overall experience quality.

How federated search improves developer experience
--------------------------------------------------

Implementing federated search leads to a more streamlined search implementation process. With federated search, results are delivered in a single, unified list, simplifying front-end development. This goes beyond [multi-index search](/blog/introducing-multi-search/?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search) because it comes without the added complexity of implementing front-end logic to merge, sort, and paginate the results.

In this setup, the relevance of documents can be further fine-tuned thanks to granular, per-index configuration. This allows tailoring the [relevancy settings](https://www.meilisearch.com/docs/learn/relevancy/relevancy?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search) to specific data types (a specific index) rather than the entire dataset (all indices). As a federated search request comes, the search engine can ensure that the most important results rise to the top.

This also simplifies extending the search functionality if new types of documents need to be included in the future. You'll only need to focus on configuring the relevancy settings for the new document type, instead of revisiting the relevancy for the entire dataset.

Conclusion
----------

Federated search enables performing searches against multiple indices of a search engine and returns a single, consolidated list of results. With a search engine that supports federated search, developers can build more relevant user search experiences without incurring additional complexity.

Federated search is available in [Meilisearch 1.10](/blog/meilisearch-1-10/?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search) and higher. Learn more about implementing federated search with Meilisearch by [reading the documentation](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search#federated-multi-search). Check out which search engines support federated search and other key features via our [comparison of search engines](https://www.meilisearch.com/docs/learn/resources/comparison_to_alternatives?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search).

* * *

[Meilisearch](https://meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=full-text-vs-vector) is an open-source AI-powered search engine enabling developers to build state-of-the-art experiences while enjoying simple, intuitive DX.

For more things Meilisearch, you can join the community on [Discord](https://discord.meilisearch.com/?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search) or subscribe to the [newsletter](https://dub.sh/meili-newsletter?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search). You can learn more about Meilisearch by looking at the [roadmap](https://roadmap.meilisearch.com/?utm_campaign=federated-search&utm_source=blog&utm_medium=what-is-federated-search) and participating in [product discussions](https://github.com/orgs/meilisearch/discussions?ref=blog.meilisearch.com).

What is federated search?

  
[Semantic search](/blog/what-is-a-vector-database/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#what-is-similarity-search) is transforming search technology by providing more accurate and relevant results. However, with many embedding models available, choosing the right one can be challenging. This guide will help you understand the key factors to consider when selecting a model to build semantic search.

Overview
--------

In this guide, we will use the open-source search engine [Meilisearch](https://www.meilisearch.com?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) to perform the semantic searches. For the purpose of the tests, we're using the entry tier of [Meilisearch Cloud](https://www.meilisearch.com/cloud?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) (i.e., the [Build plan](https://www.meilisearch.com/pricing?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) .)

This guide will cover the following models:

| Model/Service | Dimensions | Context Length |
| --- | --- | --- |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | 1024 | 512 |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | 384 | 512 |
| [Cohere embed-multilingual-v3.0](https://docs.cohere.com/docs/embeddings) | 1024 | 512 |
| [Cohere embed-multilingual-light-v3.0](https://docs.cohere.com/docs/embeddings) | 384 | 512 |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | 1536 | 8192 |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | 3072 | 8192 |
| [Mistral](https://mistral.ai/product/embeddings/) | 1024 | 8192 |
| [VoyageAI voyage-2](https://voyageai.com/) | 1024 | 4000 |
| [VoyageAI voyage-large-2](https://voyageai.com/) | 1536 | 16000 |
| [VoyageAI voyage-multilingual-2](https://voyageai.com/) | 1024 | 32000 |
| [Jina Colbert v2](https://jina.ai/news/jina-colbert-v2-multilingual-late-interaction-retriever-for-embedding-and-reranking/) | 128, 96, or 64 | 8192 |
| [OSS all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | 384 | 512 |
| [OSS bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 1024 | 512 |
| [OSS bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 1536 | 512 |

Factors to consider
-------------------

### 1\. Results relevancy

[Relevancy](https://www.meilisearch.com/docs/learn/relevancy/relevancy?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) is crucial for effective search, as it ensures that users find the most pertinent results quickly. In the realm of semantic search, achieving a balance between relevancy and speed is essential to provide a seamless user experience. It's important to consider the tradeoffs of [vector search vs full-text search](/blog/full-text-search-vs-vector-search/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison)

When selecting a model, consider your specific use case, such as the need for multilingual support, handling multi-modal data, or addressing domain-specific requirements. If you have a highly specialized use case or need to support a particular language, it may be beneficial to explore models that can be trained on your data or opt for multilingual models.

The performance difference between a very small model and a large model is not always substantial. **Smaller models are generally less expensive and faster**, making them a practical choice in many scenarios. Therefore, it is often worth considering smaller models for their cost-effectiveness and speed.

Additionally, you should always consider the context you're providing to the model. In Meilisearch, this comes in the form of a [document template](https://www.meilisearch.com/docs/reference/api/settings?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#embedders-object). The more accurately the template describes the data, the better the search results will be, leading to a more satisfying user experience.

### 2\. Search performance

You read everywhere now. Time is money. And the web is no different. Nowadays, [search-as-you-type](https://www.meilisearch.com/docs/learn/getting_started/what_is_meilisearch?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#features) is the baseline for customer-facing applications. Saving users time greatly enhances their satisfaction and keeps them engaged with your platform.

To achieve lightning-fast search performance, **consider using a local model** to minimize latency by eliminating the need for round trips to the embedding service. If you need to use a remote model, then hosting your search service (e.g., your Meilisearch database) in close proximity to the embedding service can significantly reduce latency.

The table below showcases latency benchmarks for various local embedding models and embedding APIs. All requests are originated from a Meilisearch instance hosted on AWS (London datacenter.)

| Model/Service | Latency |
| --- | --- |
| [Cloudflare bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | ±800ms |
| [Cloudflare bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | ±500ms |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | ±170ms |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | ±160ms |
| [Local gte-small](https://huggingface.co/sentence-transformers/gte-small) | ±20ms |
| [Local all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | ±10ms |
| [Local bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | ±20ms |
| [Local bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | ±60ms |
| [Mistral](https://mistral.ai/product/embeddings/) | ±200ms |
| [Jina colbert](https://huggingface.co/jinac/cobert-v1) | ±400ms |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | ±460ms |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | ±750ms |
| [VoyageAI voyage-2](https://voyageai.com/) | ±350ms |
| [VoyageAI voyage-large-2](https://voyageai.com/) | ±400ms |

Here you can see that there are some clear winners in terms of latency. Unfortunately, latency is not the same as throughput, so we also need to take a close look at the indexing time.

### 3\. Indexing performance

Indexing performance is another critical aspect when [comparing search solutions](https://www.meilisearch.com/docs/learn/resources/comparison_to_alternatives?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison). The embedding model performance will directly impact the indexing speed of your search solution. And the speed at which your data can be indexed directly impacts the overall efficiency and scalability of your search solution.

Local **models without GPUs may have slower indexing** due to limited processing power. In contrast, third-party services offer varying speeds and limitations based on their infrastructure and service agreements. It is essential to evaluate these factors to ensure that your chosen model and service can meet your requirements effectively.

Several factors come into play when optimizing indexing. Again, the latency plays a big role: reducing the time taken for data to travel between your application and the model is always going to improve your experience. Additionally, the **maximum size of API calls** the API accepts, the provider's **rate limiting**, and the model's supported **number of dimensions** can all influence the efficiency and scalability of the indexing process.

The benchmark below compares the indexing of a 10k e-commerce documents (with [automatic embedding generation](https://www.meilisearch.com/docs/learn/experimental/vector_search?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison#generate-auto-embeddings)):

| Model/Service | Indexation Time |
| --- | --- |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | 43s |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | 16s |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | 95s |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | 151s |
| [Cloudflare bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 152s |
| [Cloudflare bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 159s |
| [Jina Colbert V2](https://huggingface.co/jinac/cobert-v1) | 375s |
| [VoyageAI voyage-large-2](https://voyageai.com/) | 409s |
| [Mistral](https://mistral.ai/product/embeddings/) | 409s |
| [Local all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | 880s |
| [Local bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 3379s |
| [Local bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 9132s |

### 4\. Pricing

While local embedders are free, most services charge per million of tokens. Here's a breakdown of the pricing for each platform:

| Provider      | Price                                      |
|---------------|--------------------------------------------|
| Cohere        | $0.10 per million tokens                   |
| OpenAI        | $0.13 per million tokens for text-embedding-3-large  |
|               | $0.02 per million tokens for text-embedding-3-small  |
| Cloudflare    | $0.011 per 1,000 Neurons                   |
| Jina          | $0.18 per million tokens                   |
| Mistral       | $0.10 per million tokens                   |
| VoyageAI      | $0.10 per million tokens for voyage-2      |
|               | $0.12 per million tokens for voyage-large-2 |
|               | $0.12 per million tokens for voyage-multilingual-2 |
| Local model   | Free                                       |


As your search needs grow and scale, it may become more cost-effective to invest in your own GPU machine. By having your own hardware, you can have greater control over the performance and scalability of your search solution and potentially reduce costs in the long run.

It is often best to start with a well-known model from the list provided. They are generally easy to setup and you will easily find community resources to help you.. As the need arises, you can consider migrating the model to a cloud provider like AWS. Many services offer this option, allowing you to leverage their infrastructure for improved performance and scalability.

Alternatively, you can choose an equivalent open-source model to self-host, giving you even more flexibility and control over your search solution in the long term. Please note that optimizing local models for performance or high volume may require to scale your infrastructure accordingly.

* * *

Ready to elevate your search experience?

[Talk to a search expert](https://dub.sh/meili-sales?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison)

* * *

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

While this article provides a comprehensive overview, we did not delve deeply into optimization techniques. There are several additional optimizations that can be explored to further enhance the performance of semantic search.

Here is a list of additional areas to investigate when choosing a model for your search experience:

*   Experiment with different presets (query vs. document) for models that offer this option to potentially improve relevancy
*   Evaluate specialized models for specific applications to assess their performance and suitability for your use case
*   Explore models that provide a reranking function to further refine search results
*   Test higher-tier accounts on each platform to check for improved performance and reduced rate limiting
*   Investigate parameters for receiving quantized data directly from the API to optimize data transfer and processing

Conclusion
----------

| Model/Service | Dimensions | Context Length | Latency | Indexation Time | Pricing (per million tokens) |
| --- | --- | --- | --- | --- | --- |
| [Cohere embed-english-v3.0](https://docs.cohere.com/docs/embeddings) | 1024 | 512 | ±170ms | 43s | $0.10 |
| [Cohere embed-english-light-v3.0](https://docs.cohere.com/docs/embeddings) | 384 | 512 | ±160ms | 16s | $0.10 |
| [OpenAI text-embedding-3-small](https://platform.openai.com/docs/guides/embeddings) | 1536 | 8192 | ±460ms | 95s | $0.02 |
| [OpenAI text-embedding-3-large](https://platform.openai.com/docs/guides/embeddings) | 3072 | 8192 | ±750ms | 151s | $0.13 |
| [Mistral](https://mistral.ai/product/embeddings/) | 1024 | 8192 | ±200ms | 409s | $0.10 |
| [VoyageAI voyage-2](https://voyageai.com/) | 1024 | 4000 | ±350ms | 330s | $0.10 |
| [VoyageAI voyage-large-2](https://voyageai.com/) | 1536 | 16000 | ±400ms | 409s | $0.12 |
| [Jina Colbert v2](https://jina.ai/news/jina-colbert-v2-multilingual-late-interaction-retriever-for-embedding-and-reranking/) | 128, 96, or 64 | 8192 | ±400ms | 375s | $0.18 |
| [OSS all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) | 384 | 512 | ±10ms | 880s | Free |
| [OSS bge-small-en-v1.5](https://huggingface.co/Cloudflare/bge-small-en-v1.5) | 1024 | 512 | ±20ms | 3379s | Free |
| [OSS bge-large-en-v1.5](https://huggingface.co/Cloudflare/bge-large-en-v1.5) | 1536 | 512 | ±60ms | 9132s | Free |

Choosing the right model and service for semantic search involves carefully balancing several key factors: relevancy, search performance, indexation performance, and cost.

Each option presents its own set of trade-offs:

*   Cloud-based services like Cohere and OpenAI offer excellent relevancy and reasonable latency, with Cohere's embed-english-light-v3.0 standing out for its balance of speed and performance.
*   Local models provide the fastest search latency but may struggle with indexation speed on limited hardware.
*   Emerging services like Mistral and VoyageAI show promise with competitive pricing and performance.
*   Open-source models offer cost-effective solutions for those willing to manage their own infrastructure.

Ultimately, the best choice depends on your specific use case, budget, and performance requirements. For many applications, starting with a cloud-based service like Cohere or OpenAI provides a good balance of ease of use, performance, and cost. As your needs grow, consider exploring local or specialized models, or contact Meilisearch's sales team for tailored solutions.

* * *

[Meilisearch](https://www.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) is an open-source search engine enabling developers to build state-of-the-art experiences while enjoying simple, intuitive DX.

For more things Meilisearch, you can join the community on [Discord](https://discord.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) or subscribe to the [newsletter](https://dub.sh/meili-newsletter?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison). You can learn more about the product by checking out its [roadmap](https://roadmap.meilisearch.com/?utm_campaign=vector-search&utm_source=blog&utm_medium=models-comparison) and participating in [product discussions](https://github.com/orgs/meilisearch/discussions).

Choosing the best model for semantic search

Today we're announcing Meilisearch v1.10. In this article, we’ll review the most impactful changes. For an exhaustive listing, check out the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.10.0) on GitHub.

<Callout>
  Meilisearch 1.10 is available on [Meilisearch Cloud](https://cloud.meilisearch.com/?utm_campaign=release-v1-10&utm_source=blog), too—upgrade now!
</Callout>

New: federated search
---------------------

We’re excited to announce that [federated search](/blog/what-is-federated-search/?utm_campaign=release-v1-10&utm_source=blog is finally coming to Meilisearch. This feature extends the [multi-search API](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=release-v1-10&utm_source=blog#perform-a-multi-search) to allow you to merge results from multiple queries into a single, unified response. You can now search different indexes and get the most relevant results across the entire dataset, not only the most relevant for each index.

For SaaS platforms that need to search across various types of resources or ecommerce sites with diverse product categories, federated search is a game-changer.

Here is an example payload for making a [federated search request](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=release-v1-10&utm_source=blog#federated-multi-search) against the `movies` and `comics` indexes:

```json
{
  "federation": {
    "offset": 5,
    "limit": 10
  },
  "queries": [
    {
      "q": "Batman",
      "indexUid": "movies"
    },
    {
      "q": "Batman",
      "indexUid": "comics"
    }
  ]
}
```

In this example, the [federated search response](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=release-v1-10&utm_source=blog#response-200-ok-1) will look like this:

```json
{
  "hits": [
    {
      "id": 42,
      "title": "Batman returns",
      "overview": "..",
      "_federation": {
        "indexUid": "movies",
        "queriesPosition": 0
      }
    },
    {
      "comicsId": "batman-killing-joke",
      "description": "..",
      "title": "Batman: the killing joke",
      "_federation": {
        "indexUid": "comics",
        "queriesPosition": 1
      }
    },
 ],
  "processingTimeMs": 0,
  "limit": 2,
  "offset": 0,
  "estimatedTotalHits": 2,
  "semanticHitCount": 0
}
```

### Query weighting

Federated search isn't just about combining results; it's about making those results more meaningful and relevant. Thanks to [query weighting](https://www.meilisearch.com/docs/reference/api/multi_search?utm_campaign=release-v1-10&utm_source=blog#federationoptions), you can prioritize certain queries over others, ensuring that the most important data rises to the top.

The example payload below uses **query weighting** in a federated search to give more importance to documents where the `boosted` field is `true`:

```json
{
  "federation": {},
  "queries": [
    {
      "q": "iphone case",
      "indexUid": "products",
      "filter": "BOOSTED = true",
      "federationOptions": {
        "weight": 3.0
      }
    },
    {
      "q": "iphone case",
      "indexUid": "products"
      // federationOptions.weight defaults to 1
    }
  ]
}
```
<Callout>
  Learn more about [federated search and its use cases](/blog/what-is-federated-search/?utm_campaign=release-v1-10&utm_source=blog)
</Callout>

New: language settings for queries and documents
------------------------------------------------

By default, Meilisearch automatically detects the language used in documents and queries. This comes with some limitations for edge cases. Meilisearch 1.10 introduces new language settings that allow users to manually customize their language preferences.

There are two ways to state the language used in a search:

*   Set the language used in a query
*   Set the language used in a document field

### Setting the search query locale

You can define which language is used in a query in the [search parameters](https://www.meilisearch.com/docs/reference/api/search?utm_campaign=release-v1-10&utm_source=blog#query-locales).

**Example payload for searching with query `locales`:**

```json
{
   "q": "進撃の巨人",
   "locales": ["jpn"]
}
```

### Setting the document attributes’ locales

You can define which language is used in your dataset via the [index settings](https://www.meilisearch.com/docs/reference/api/settings?utm_campaign=release-v1-10&utm_source=blog#localized-attributes).

**Example payload for settings with `localizedAttributes`:**

```json
{
  "localizedAttributes": [
    {
      "locales": ["jpn"], 
      "attributePatterns": ["*_japanese"]
    }
  ]
}
```
<Callout>
  Meilisearch support all [ISO-639-2B](https://en.wikipedia.org/wiki/List_of_ISO_639-2_codes) locales.
</Callout>

Self-hosting: Ubuntu v20 is now required
----------------------------------------

If you’re self-hosting Meilisearch, take note: Meilisearch 1.10 now requires **Ubuntu version 20**. This update ensures compatibility with the latest features and maintains optimal performance and security. We advise reading the documentation on [how to upgrade your Ubuntu release](https://documentation.ubuntu.com/server/how-to/software/upgrade-your-release/).

<Callout>
  This change does not affect [Meilisearch Cloud](https://meilisearch.com/cloud?utm_campaign=release-v1-10&utm_source=blog) users.
</Callout>

Experimental: AI-powered search DX improvements
-----------------------------------------------

### New: custom headers to REST API-based embedders

Meilisearch 1.10 supports sending custom headers to your API-based embedding service. When using the `rest` source for your [embedder settings](https://www.meilisearch.com/docs/reference/api/settings?utm_campaign=release-v1-10&utm_source=blog#embedders-experimental), Meilisearch now accepts an optional `headers` object. These headers will be added to all requests made to the embedder API.

**Example payload for embedder settings:**

```json
{
  "source": "rest",
  "apiKey": "•••••••••••••••••",
  "headers": {
    "Custom-Header": "value"
  }
}
```

### New: quality of life improvements

Additionally, we added some minor changes to make working with Meilisearch AI-powered search API easier:

*   Embedder settings now accept a `url` parameter for OpenAI embedder to access OpenAI through a proxy
*   Embedder settings now accept a `dimensions` parameter for ollama embedder
*   Meilisearch now includes `_vectors` in the response for documents without vectors (only when `retrieveVectors` is enabled)

### ⚠️ Breaking: REST API-based embedders breaking changes

The API for [configuring an embedder based on a REST API](https://www.meilisearch.com/docs/learn/experimental/vector_search?utm_campaign=release-v1-10&utm_source=blog#generate-vector-embeddings) (e.g., OpenAI, Mistral, etc.) has quickly evolved and to avoid confusion, we have decided to reorganize the parameters in dedicated `request` and `response` fields.

In practice, this change:

*   removes `query` , `inputField`, `inputType`, `pathToEmbeddings` and `embeddingObject` fields
*   adds `request` and `response` fields

Take a look at the example below to learn how to migrate to the new syntax.

**Before** — With Meilisearch 1.9

```json
{
   "source": "rest",
   "url": "https://localhost:10006",
   "query": {
     "model": "minillm",
   },
   "inputField": ["prompt"],
   "inputType": "text",
   "embeddingObject": ["embedding"]
}
```

**After** — Starting with Meilisearch 1.10

```json
{
   "source": "rest",
   "url": "https://localhost:10006",
   "request": {
     "model": "minillm",
     "prompt": "{{text}}"
   },
   "response": {
     "embedding": "{{embedding}}"
   }
}
```

#### Upgrade procedure

This procedure is only necessary if you're using REST API-based embedder. To upgrade to Meilisearch 1.10, follow these steps:

1.  Remove embedders with source `"rest"`
2.  Update your [Meilisearch Cloud project](https://www.meilisearch.com/docs/learn/update_and_migration/updating?utm_campaign=release-v1-10&utm_source=blog#updating-meilisearch-cloud) or [self-hosted Meilisearch instance](https://www.meilisearch.com/docs/learn/update_and_migration/updating?utm_campaign=release-v1-10&utm_source=blog#updating-a-self-hosted-meilisearch-instance) as usual

Experimental: `CONTAINS` filter operator
----------------------------------------

Meilisearch 1.10 introduces the `CONTAINS` operator. This is still in the experimental stage due to some performance issues we’re working to resolve. This new [filter operator](https://www.meilisearch.com/docs/learn/filtering_and_sorting/filter_expression_reference?utm_campaign=release-v1-10&utm_source=blog#contains) allows to check if a substring is included in a larger string.

Given the document `{ id: 1, name: "Keffir" }`, you can use the filter as follows:

*   `name CONTAINS kef` — search will match the document
*   `name CONTAINS clifford` — search will not match the document

<Callout>
  Remember all filters used lowercase, normalized strings (all accents are removed).
</Callout><Callout>
  Share your feedback via this [Github discussion](https://github.com/orgs/meilisearch/discussions/763).
</Callout>

Experimental: update documents with a function
----------------------------------------------

Meilisearch 1.10 allows you to edit documents by executing [a Rhai function](https://rhai.rs/). This allows you to update only a part of your dataset using filters. Additionally, using a function allows you to implement dynamic logic based on your documents’ data.

The following payload updates the title of all documents with `id` above 3000:

```json
{
  "filter": "id > 3000",
  "function": "doc.title = `✨ ${doc.title.to_upper()} ✨`"
}
```

This also enables more complex use cases, like [implementing a decaying ranking strategy](https://felx.me/2021/08/29/improving-the-hacker-news-ranking-algorithm.html). Depending on your needs, you might implement a function such as the following that will be run regularly by a Cron job.

```json
{
  "context": { "now": 1715423249 },
  "function": "
    // `posted_at` and `now` are Unix Epoch timestamps in seconds
    // they must be converted to hours.
    let age_hours = (context.now - doc.posted_at) / 60 / 60;
    doc.ranking_score = doc.upvotes ** 0.8 / (age_hours + 2) ** 1.8;
  "
}
```
<Callout>
  Share your feedback via this [Github discussion](https://github.com/orgs/meilisearch/discussions/762).
</Callout>

* * *

And that’s a wrap for v1.10! These release notes only highlights the most significant updates. For an exhaustive listing, read the [changelog](https://github.com/meilisearch/meilisearch/releases/tag/v1.10.0) on Github.

Upgrade with ease using Meilisearch Cloud.

[Open Meilisearch Cloud](https://cloud.meilisearch.com/login?utm_campaign=release-v1-10&utm_source=blog)

* * *

Contributors shout-out
----------------------

This release wouldn’t be possible without [Meilisearch](https://github.com/meilisearch/meilisearch) and [Charabia](https://github.com/meilisearch/charabia) contributors [@Karribalu](https://github.com/Karribalu), [@hanbings](https://github.com/hanbings), [@junhochoi](https://github.com/hunhochoi), [@JWSong](https://github.com/JWSong), [@PeterDaveHello](https://github.com/PeterDaveHello), [@LukasKalbertodt](https://github.com/LukasKalbertodt), and [@phillitrOSU](https://github.com/phillitrOSU).

We also want to extend special thanks to our SDK maintainers working hard to make Meilisearch available across many [languages and frameworks](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks). We’re excited for [@Sherlouk](https://github.com/Sherlouk) and [@Ja7ad](https://github.com/Ja7ad) to join our open-source maintainers. 💪

* * *

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=release-v1-10&utm_source=blog). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=release-v1-10&utm_source=blog) and participate in our [Product Discussions](https://github.com/orgs/meilisearch/discussions).

For anything else, join our developers community on [Discord](https://discord.meilisearch.com/?utm_campaign=release-v1-10&utm_source=blog).

Meilisearch 1.10

This guide will walk you through setting up a Next.js storefront for your Shopify commerce. We will use the open-source [Enterprise Ecommerce](https://github.com/Blazity/enterprise-commerce) starter developed by [Blazity](https://blazity.com/) which comes with a CLI to get started in a snap.

Overview
--------

The diagram below gives an overview of the architecture of our application.

![Architecture of an application developed with Enterprise Ecommerce start](https://unable-actionable-car.media.strapiapp.com/blazity_commerce_architecture_0a30272f59.png)

The application stack is composed of 4 key components:

*   **Data sources** — Shopify admin, personalization tools, etc.
*   **Search engine** — Meilisearch
*   **Full-stack app** — Next.js application
*   **Third-party integrations** — Analytics, CRM, etc.

In this architecture, the Meilisearch database aggregates data from multiple sources to make it accessible by the Next.js application.

Our final application will look like this: [live preview](https://commerce.blazity.com/) ✨

Prerequisites
-------------

This guide requires:

*   [Node.js](https://nodejs.org/en/download/package-manager) ≥ 20.x
*   [Yarn](https://yarnpkg.com/getting-started/install) ≥ 4.x
*   [Meilisearch](https://www.meilisearch.com/cloud?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide) ≥ 1.8
*   A [Shopify](https://www.shopify.com/) store

Setup
-----

This setup phase provides you with the necessary credentials for your application to interact with Meilisearch and your Shopify store.

These credentials match an environment variable that will be needed during the installation phase. For clarity, this guide will indicate with a "✅" emoji each of these variables.

<Callout>
  Thanks to Blazity for the instructions. If you’re running into issues, please consult the [Blazity documentation](https://docs.commerce.blazity.com/).
</Callout>

### Creating a Shopify store

If you don’t have one already, go to [Shopify](https://www.shopify.com/) and create a new store. Shopify associates a unique ID with each store named the _store domain_.

To find your Shopify store domain, go to _Settings_ > _Domains_ . Your store domain looks like this: `your-domain.myshopify.com`.

✅ `Shopify store domain`

### Installing Shopify Headless

In the Shopify Marketplace, find the [Headless application](https://apps.shopify.com/headless) and install it. After installation, click on _Create storefront_.

Then, we will update the API access. In the _Manage API access_ section, click on _Manage_ next to _Storefront API_.

Edit the Storefront API permissions to add the following:

*   `unauthenticated_read_product_inventory`
*   `unauthenticated_read_customer_tags`

After saving the permissions, you can copy the **private access token**.

✅ `Shopify app Storefront API Token`

### Creating a Shopify App

Now, we will create a Shopify App for our store. Shopify Apps allow you to build custom integrations for your store. This app will allow us to get API keys to read and manage data in our Shopify store.

To create a Shopify app:

*   Navigate to your store’s Shopify admin dashboard
*   Open the store’s _Settings_ and navigate to the _Apps and sales channels_ tab
*   Click on _Develop apps_
*   If requested, follow the steps to allow custom app development for your store
*   Create an app and enter a name, e.g., “Next.js App”

After creating your app, navigate to the API credentials tab to find your Shopify app’s API key (not the API secret key!)

✅ `Shopify app API key`

### Configuring the Shopify Admin API key

Shopify apps work with a set of two keys:

*   An **admin API key** — to manage the Shopify admin, e.g., to edit your product catalog
*   A **storefront API key** — to read the product catalog, create carts, etc.

We can configure the access scopes for these API keys in your Shopify app’s _Configuration_ tab. In this section, we will enable the required scopes for our Admin API key.

To configure the scopes for the Admin API key, follow these steps:

*   In the _Admin API integration_ section, click on _Configure_
*   Enable the following scopes:
    *   `write_product_listings`
    *   `read_product_listings`
    *   `read_products`
    *   `write_products`
*   Under _Webhook subscriptions_, select the 2024-01 API version
*   Save :)

<Callout>
  The API version might have changed since this guide was published. We recommend checking out the [Blazity documentation](https://docs.commerce.blazity.com/providers#3-private-admin-app).
</Callout>

With our tokens API scopes defined, we can return to the _API credentials_ tab and install our app. Click _Install app_ to generate your API access tokens.

After installing your Shopify app, you will have access to your Admin API access token. For security reasons, this token will only be revealed to you _once_—**make sure to save it**.

✅ `Shopify app Admin API token`

### Creating your Meilisearch database

Meilisearch is an open-source search engine that provides full-text, vector, and hybrid search capabilities. Our Shopify products data will be synced with Meilisearch, enabling the front-end app to get fast, relevant search results for end users.

If you don’t have one, create a [Meilisearch Cloud](https://www.meilisearch.com/cloud?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide) account. If necessary, you can first learn how to [get started with Meilisearch Cloud](https://www.meilisearch.com/docs/learn/getting_started/cloud_quick_start?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide).

<Callout>
  Prefer self-hosting? Learn how to [install Meilisearch locally](https://www.meilisearch.com/docs/learn/getting_started/installation?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide).
</Callout>

First, create a new _Project_, e.g., Shopify store. This will create a new Meilisearch database and should take a few seconds to complete.

Then, you can navigate to your project’s Settings page to find your _Database URL_ (your host) and _Default Admin API Key_.

✅ `Meilisearch host URL`

✅ `Meilisearch API token`

<Callout>
  We recommend enabling [analytics & monitoring](https://www.meilisearch.com/docs/learn/analytics/analytics?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide) at this step, so you don’t need to change host later.
</Callout>

### Configuring your Meilisearch

After creating your database, we will create the indexes. You can choose any names for them, but you’ll have to configure your environment variables accordingly. Let’s create two indexes:

*   An index for our products, e.g., `products`
*   An index for our product categories, e.g., `categories`

✅ `Meilisearch Products Index Name`

✅ `Meilisearch Categories Index Name`

With our indexes created, we can now configure them. Meilisearch defaults will work well for most settings. For each index, we will only configure the filterable attributes and sortable attributes.

**Product index** — Filterable attributes

```json
[
	"collections",
	"collections.handle",
	"collections.id",
	"flatOptions",
	"handle",
	"minPrice",
	"tags",
	"variants.availableForSale",
	"vendor",
	"hierarchicalCategories",
	"hierarchicalCategories.lvl0",
	"hierarchicalCategories.lvl1",
	"hierarchicalCategories.lvl2",
	"avgRating"
]
```

**Product index** — Sortable attributes

```json
[
	"minPrice",
	"updatedAtTimestamp",
	"avgRating"
]
```

**Categories index** — Filterable attributes

```json
[
	"handle",
	"id"
]
```

You can leave all other attribute settings to their default value.

Installation
------------

With all credentials in hand, we’re ready to launch the installation wizard. Let’s create our project using Blazity’s `commerce` CLI.

```bash
# with NPM
npm create commerce

# with Yarn
yarn create commerce
```

The first prompt will ask you to select the services to enable. For this guide, we’ll only enable the defaults: Shopify and Meilisearch.

Then, the CLI will ask for a series of credentials. If you followed the Setup section, you should already have all the necessary credentials. After providing all the credentials, the CLI will scaffold your project in a new folder.

After creation, navigate to your project directory. Your `apps/web/.env.local` should look like this:

```bash
# apps/web/.env.local

SHOPIFY_STOREFRONT_ACCESS_TOKEN=shpat_a-very-long-token
SHOPIFY_ADMIN_ACCESS_TOKEN=shpat_another-very-long-token
SHOPIFY_STORE_DOMAIN=your-domain.myshopify.com
SHOPIFY_APP_API_SECRET_KEY=a-32-characters-long-api-key
SHOPIFY_HIERARCHICAL_NAV_HANDLE=hierarchical-categories
MEILISEARCH_PRODUCTS_INDEX=products
MEILISEARCH_CATEGORIES_INDEX=categories
MEILISEARCH_ADMIN_KEY=your-meilisearch-admin-api-key
MEILISEARCH_HOST=https://edge.meilisearch.com
LIVE_URL=https://your-domain.myshopify.com
FLAGS_SECRET=randomly-generated-secret
CRON_SECRET=another-randomly-generated-secret
```

Syncing Meilisearch and Shopify
-------------------------------

Blazity provides a CLI for synchronizing the data between your Shopify and Meilisearch. In this section, we will see how to achieve that using `commerce-cli`.

To sync your Shopify data with your Meilisearch, navigate to your project folder and run:

```bash
npx commerce-cli@latest sync
```

This command will pull all the necessary data from your Shopify store and sync it into your Meilisearch database.

<Callout>
  Additionally, the [`commerce-cli` package](https://docs.commerce.blazity.com/features/cli) can assist you in configuring webhooks to keep your Meilisearch in sync at all times.
</Callout>

Starting your app
-----------------

After initializing your application and syncing the data between Shopify and Meilisearch, you are ready to start your application.

To start your application in development mode, run:

```bash
# with NPM
npm run dev

# with Yarn
yarn dev
```

And that’s it! You can visit your application at `http://localhost:3000` 🎉

You can also consult a live example here: [https://commerce.blazity.com/](https://commerce.blazity.com/?ref=blog.meilisearch.com)

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

This guide doesn’t cover all available features in the Blazity template. For more advanced configurations, you can learn how to set up hierarchical categories, implement highly scalable redirects, and more on [Blazity documentation](https://docs.commerce.blazity.com/introduction).

Additionally, here are resources to help you integrate your new Shopify store with Meilisearch and Next.js:

*   [Meilisearch documentation](https://meilisearch.com/docs?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide)
*   [Next.js documentation](https://nextjs.org/docs)
*   [Integrate Meilisearch Cloud with Vercel](https://www.meilisearch.com/docs/guides/integrations/vercel?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide)

* * *

Stay in the loop of everything Meilisearch by subscribing to our [monthly newsletter](https://dub.sh/meili-newsletter?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide). To learn more about Meilisearch's future and help shape it, take a look at our [roadmap](https://roadmap.meilisearch.com/?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide) and participate in our [product discussions](https://github.com/orgs/meilisearch/discussions).

For anything else, join our developers community on [Discord](https://dub.sh/meili-discord/?utm_campaign=blazity&utm_source=blog&utm_medium=shopify-nextjs-guide).

Build your Next.js Shopify storefront with Blazity

🦎 Releasing Meilisearch 1.9
----------------------------

[![](https://unable-actionable-car.media.strapiapp.com/meilisearch_1_9_d1239d3d00.jpg)](/blog/meilisearch-1-9/?utm_campaign=newsletter&utm_source=blog&utm_medium=july-24-updates)

Meilisearch 1.9 brings **similar documents**, **ranking score threshold**, **grouping by attribute**, and **improved AI-powered search**.

[Discover updates](/blog/meilisearch-1-9/?utm_campaign=newsletter&utm_source=blog&utm_medium=july-24-updates)

⚖️ Algolia comparison
---------------------

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

We published a **comparison of the key features** between Meilisearch and Algolia to help you choose search engine that fits your needs.

[Read comparison](/blog/meilisearch-vs-algolia/?utm_campaign=newsletter&utm_source=blog&utm_medium=july-24-updates)

📌 Community picks
------------------

### 📢 [RFC: Database synchronization tooling](https://github.com/orgs/meilisearch/discussions/765)

We're collecting feedback on tooling to synchronize Meilisearch with your database.

### 📢 [RFC: Improving the search preview](https://github.com/orgs/meilisearch/discussions/766)

We want to make testing your search easier, and we need your feedback!

### 🎮 [A better way to build Meilisearch filters in TypeScript](https://levelup.gitconnected.com/a-better-way-to-build-meilisearch-filters-d88846c280d1)

Check out the meilisearch-helper package to build filters with a fluent API.

### ⚡️ [Lightning-fast Laravel search with Meilisearch](https://www.youtube.com/watch?v=FY_x9_eX1AQ)

Watch this video to learn how to build full-text search for Laravel with Meilisearch.

### 📽️ [Product live event](/blog/heres-what-you-missed-q2-2024/?utm_campaign=newsletter&utm_source=blog&utm_medium=july-updates-24#check-out-the-recording-of-the-event-for-more-details)

Watch the replay to learn more about our recent releases and what's coming next.

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

A community member built [RemoteJobs.org](https://remotejobs.org) and shared it with the Discord community. It's a remote jobs board focussing on quality offers. It is, of course,  powered by Meilisearch. 🎉

[![](https://unable-actionable-car.media.strapiapp.com/Screenshot_2024_08_01_at_18_55_39_59f37af3bf.png)](https://remotejobs.org)

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

🦸‍♀️ We're hiring!
-------------------

See our open positions:

*   [Growth Marketing Manager](https://www.meilisearch.com/careers?utm_campaign=newsletter&utm_source=blog&utm_medium=july-updates-24)
*   [Senior Full-Stack Software Engineer](https://www.meilisearch.com/careers?utm_campaign=newsletter&utm_source=blog&utm_medium=july-updates-24)
*   [Founding Sales & Business Developer](https://www.meilisearch.com/careers?utm_campaign=newsletter&utm_source=blog&utm_medium=july-updates-24)

* * *

Get these monthly updates straight to your inbox by subscribing to our [newsletter](https://dub.sh/meili-newsletter?utm_campaign=newsletter&utm_source=blog&utm_medium=july-24-updates). 💌

For more things Meilisearch, join our developers community on [Discord](https://discord.meilisearch.com/?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 July updates

Deciding between Algolia and Meilisearch for your search solution? We're here to help! In this article, we'll compare their features, capabilities, pricing models, and overall strengths and weaknesses.

What is Algolia?
----------------

Founded in 2012, Algolia is a hosted search engine that provides full-text and AI-powered search capabilities. It offers an API that integrates fast, customizable search experiences into websites and mobile applications.

Algolia is known for its remarkable speed and scalability, making it a go-to choice for enterprises looking for sophisticated search functionalities. However, these premium features come with a higher cost, Algolia tends to be more suitable for larger businesses with bigger budgets.

What is Meilisearch?
--------------------

Launched in 2018, [Meilisearch](https://meilisearch.com/?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) is an open-source search engine that features full-text and AI-powered search capabilities Designed to be developer-friendly and plug-and-play, it addresses most common use cases straight out of the box. Built with Rust, it ensures exceptional performance, security, and flexibility.

Known for its lightning-fast search speeds and modern development environment, Meilisearch is an excellent choice for small-to-medium growing businesses seeking high-performance search functionalities.

Unlike Algolia, Meilisearch is [open-source](https://github.com/meilisearch/meilisearch). You can self-host it or use the [managed Meilisearch Cloud service](https://meilisearch.com/cloud?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia), allowing for flexibility and cost-efficiency.

Algolia vs Meilisearch - Key features compared
----------------------------------------------

### Developer experience

Algolia and Meilisearch both prioritize ease of use, offering straightforward setup processes and comprehensive documentation. These search engines work out-of-the-box, providing great relevancy in most cases without the need for additional configurations. They feature intuitive REST APIs and place a strong emphasis on the developer experience. Meilisearch's open-source nature is a significant asset, as it enables better feedback collection and faster implementations.

When comparing Meilisearch Cloud and Algolia dashboards, Algolia’s interface stands out for its advanced and comprehensive UI. This is understandable, given that Algolia is a fully-hosted search engine that has been in the market for over a decade. In contrast, Meilisearch, which launched its cloud offering much more recently, is still developing its dashboard.

Overall, the Algolia dashboard feels more beginner-friendly and integrated, guiding users smoothly from data addition to frontend integration. Meilisearch, on the other hand, partially relies on its [documentation](https://www.meilisearch.com/docs/learn/getting_started/cloud_quick_start?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) to guide users through the process. However, it’s important to note that Meilisearch’s dashboard is continually evolving based on user feedback, showing significant potential for improvement.

### SDKs and integrations

Both Algolia and Meilisearch provide [API clients](https://www.meilisearch.com/docs/learn/what_is_meilisearch/sdks?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) for a variety of popular programming languages, including JavaScript, .NET, Python, PHP, and more, ensuring developers can easily integrate search functionalities into their applications.

Algolia offers a significantly broader selection of SDKs and integrations, particularly in the realm of specialized e-commerce platforms such as Shopify and Adobe Commerce (formerly Magento). This extensive range of integrations makes Algolia a versatile choice for businesses with specific platform requirements.

### Relevance and typo tolerance

Meilisearch and Algolia both deliver excellent relevancy and typo tolerance right out of the box, with options for customization to fine-tune search results. They offer similar features, including synonyms, deduplication, sorting, filtering, faceting, and geosearch.

However, configuring some of these features in Meilisearch can feel more straightforward. Certain functionalities, such as [sorting](https://www.meilisearch.com/docs/learn/fine_tuning_results/sorting#sorting?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia), require fewer configuration steps compared to Algolia. This simplicity makes Meilisearch an attractive option for developers looking for ease of setup and use.

Moreover, unlike Algolia, Meilisearch does not require replicating or copying indexes for each sort criterion, making cost management much more manageable and fair for customers.

Algolia, on the other hand, provides a more extensive feature set with advanced configuration options. Features like filter weighting offer more customization, but this can also add complexity. While Algolia's features can sometimes offer more advanced configuration, Meilisearch is rapidly closing the gap, [regularly launching new features](https://github.com/meilisearch/meilisearch/releases?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) that enhance its capabilities.

### AI-powered search

Both Algolia and Meilisearch offer advanced semantic search capabilities, but with notable differences in accessibility and customization.

Algolia provides NeuralSearch, its approach to hybrid search, which combines neural search and full-text search results. Algolia leverages AI at multiple levels, including search, ranking, and query suggestions. This feature allows you to choose between keyword search and neural search modes. When using Algolia, text embedding is managed by their proprietary model, which is automatically applied to the documents. However, NeuralSearch is not widely available; it is reserved for the highest plan (Elevate) and requires event data from the front end. In practice, many users have yet to see a running instance of NeuralSearch. 

Meilisearch, on the other hand, offers a more customizable [AI-powered search](https://www.meilisearch.com/solutions/vector-search?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) experience. It uses state-of-the-art large language model (LLM) providers such as OpenAI and HuggingFace to generate vector embeddings. Additionally, Meilisearch allows you to configure multiple embedders for an index and supports custom embeddings, ensuring flexibility and adaptability. Its [hybrid search](https://www.meilisearch.com/solutions/hybrid-search?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) approach is highly customizable, enabling you to adjust the semantic ratio for each hybrid search query, ranging [from full semantic to full-text search](/blog/full-text-search-vs-vector-search/?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia Meilisearch's AI-powered search is available both when self-hosting and on Meilisearch Cloud, making it accessible to a wide range of users.

### Analytics & data visualization

Both Meilisearch and Algolia provide robust analytics and data visualization tools to help you monitor and optimize search performance, but they offer these insights in slightly different ways.

Meilisearch offers a [comprehensive set of analytics](https://www.meilisearch.com/docs/learn/cloud/analytics?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia), including metrics such as total searches, user activity, and key search effectiveness indicators like no result rate and click-through rate. You can visualize search trends over time and gain insights into user behavior, including the most searched queries and geographic distribution of searches.

Algolia, on the other hand, provides a more extensive suite of analytics and data visualization tools. Its overview dashboard includes similar key metrics like total searches, user activity, and conversion rates. However, Algolia goes further by offering advanced analytics providing deeper insights into popular filter values and top-performing results.

A notable feature that sets Algolia apart is its A/B testing capability. This allows you to compare an index and its replica with different settings, evaluating metrics like click-through rates and conversion rates. 

In summary, while both Meilisearch and Algolia offer essential analytics tools, Algolia includes more detailed and advanced options, including A/B testing, which can be particularly beneficial for optimizing user interactions in ecommerce use cases. Meilisearch focuses on core metrics and delivers a straightforward visualization of search trends and user behavior.

### Community and support

Algolia offers a dedicated Discord community with 507 members, accessible to all users, providing a platform for discussions, questions, and support. For more personalized assistance, email and website support are available starting from the Grow plan. Additionally, Algolia provides Standard and Extended Support options, though pricing is not disclosed and is only available through sales inquiries.

Meilisearch, being an open-source search engine, has fostered a robust community. Its [Discord community](https://discord.meilisearch.com/?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) boasts 2,441 members, offering a vibrant space for open-source enthusiasts and users to engage, share knowledge, and seek help. For Cloud users, Meilisearch ensures comprehensive support tailored to each plan: the Build plan includes Discord support, the Pro plan offers chat and email support, and the Custom plan provides priority support with dedicated channels. This tiered support structure reflects Meilisearch's commitment to accessible and responsive customer service.

### Pricing and commercial offerings

Algolia offers a mix of free, pay-as-you-go, and custom pricing plans. The Free Plan includes up to 10,000 search requests per month and 1 million records, while the Grow Plan features a clear pay-as-you-go structure with specific costs for additional search requests and records. However, their Premium and Elevate Plans do not have disclosed pricing and require users to request details from sales.  

In contrast, Meilisearch Cloud has fixed monthly pricing for its Build and Pro plans, priced at $30 and $300 per month, respectively, with specified features and resources included. For larger projects, Meilisearch has a Custom Plan that requires a custom quote.

While Meilisearch does not offer a free tier, it starts at a relatively low monthly cost with substantial resources and support. Additionally, it includes a 14-day free trial without requiring a credit card, making it easy for potential users to explore its features. Moreover, Meilisearch being open-source, it can also be [self-hosted for free](https://www.meilisearch.com/docs/learn/getting_started/installation#local-installation?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia).

Although Algolia might save some costs in specific scenarios, its complexity and potential hidden costs can lead to higher expenses in practice. Meilisearch, with its clear and predictable [pricing model](https://www.meilisearch.com/pricing?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia), is often more attractive for businesses that prefer straightforward budgeting and cost transparency.

### Global coverage

Meilisearch Cloud has server regions in major cities such as San Francisco, New York, London, Frankfurt, and Singapore, strategically positioning itself in key commercial hubs across North America, Europe, and Asia. This coverage allows Meilisearch to provide reliable performance and data residency options in these important regions.

Algolia has a much broader network with clusters deployed in 16 regions globally. This extensive coverage spans the US, Europe, Asia, and additional regions like Brazil, Japan, and Australia. Algolia’s expansive network allows for greater flexibility in data localization, enhancing performance and compliance with local regulations.

Looking ahead, Meilisearch plans to expand its reach by adding more server regions to its network. This expansion will broaden its global coverage, further enhancing its service offerings.

Algolia challenges
------------------

Algolia faces several notable challenges, one of which is its high cost. While Algolia does offer a free tier, it is limited, and scaling up can quickly become expensive. Algolia's powerful features are well-suited for large enterprises, but smaller businesses might find these advanced features and the associated costs overwhelming. The lack of transparency for its Premium and Elevate plans further complicates budgeting, as potential customers must engage with the sales team to get detailed pricing information, which can deter smaller businesses that need to understand costs upfront. 

Additionally, fully leveraging Algolia’s extensive features and capabilities often requires significant customization and technical expertise. This can be a barrier for businesses without dedicated technical teams. 

Furthermore, Algolia's reliance on its proprietary models for AI features means users are dependent on Algolia's technology stack. This dependency can limit businesses looking for more flexibility or integration with other AI solutions.

Meilisearch challenges
----------------------

Meilisearch, despite its strengths, also faces its own set of challenges. One notable challenge is the absence of a completely free tier in the managed cloud version, which might deter very small businesses or startups looking to minimize costs. While Meilisearch's pricing is transparent and reasonable, the lack of a free option in the managed cloud version can be a disadvantage compared to competitors like Algolia. However, being open-source, Meilisearch provides a free, self-hosted option that ensures cost savings for those willing to manage their own infrastructure.

While Meilisearch offers essential and robust features, it might lack some of the advanced features and integrations that Algolia provides, particularly for specialized use cases such as advanced e-commerce applications.

When should you consider Algolia over Meilisearch?
--------------------------------------------------

If your business requires sophisticated e-commerce search functionalities, such as merchandising tools, product recommendations, and advanced filtering options, Algolia is currently better equipped to handle these needs. The platform's features are designed to improve product discovery and conversion rates.

For businesses that want to optimize their search configurations through A/B testing, Algolia provides robust tools to compare different search setups. This is especially beneficial in e-commerce, where fine-tuning search performance can significantly impact sales and customer engagement. 

Algolia’s infrastructure is also optimized for global reach, offering high availability and low latency across different regions. If your business operates internationally and requires consistent performance worldwide, Algolia is a strong contender.

In summary, Algolia excels in delivering advanced e-commerce functionalities, comprehensive analytics, and a globally optimized infrastructure. While it may come with higher costs and a steeper learning curve, these features make it particularly suitable for large enterprises and businesses with complex, high-demand search requirements.

When should you consider Meilisearch over Algolia?
--------------------------------------------------

Meilisearch is an excellent choice for businesses that prioritize simplicity, transparency, and flexibility. Its straightforward setup process and developer-friendly design make it ideal for teams seeking a hassle-free implementation. With robust core features that work out of the box, Meilisearch ensures high performance, fast response times, and excellent relevancy without requiring extensive customization or technical expertise.

For organizations that value open-source solutions, Meilisearch is particularly appealing. It benefits from active community contributions and maintenance, fostering a collaborative environment that accelerates innovation. This allows businesses to adapt and extend the search engine according to their specific requirements, providing greater flexibility and control over their search infrastructure.

The open-source model also ensures the search engine remains aligned with user needs, adding a layer of transparency and flexibility. As a result, customers gain better confidence in their ability to shape the product and steer it in the direction they need, enhancing their overall control and adaptability.

Regular updates every two months ensure that Meilisearch users can benefit from the latest advancements and enhancements, keeping the search engine up-to-date with evolving needs and technologies. This continuous improvement cycle makes Meilisearch a strong contender for businesses looking for a dynamic and easy-to-use search solution.

In summary, choose Meilisearch over Algolia if you need a flexible, developer-friendly search engine with transparent pricing and the benefits of an open-source community. Meilisearch’s focus on simplicity, high performance, and continuous innovation makes it a compelling option for businesses of all sizes.

* * *

Learn more about what Meilisearch can bring to your business.

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

* * *

Conclusion
----------

Both Algolia and Meilisearch offer robust search solutions with a developer-friendly experience and high performance.

Algolia is particularly strong in the e-commerce space, offering advanced analytics and features tailored to that use case. Its extensive feature set and flexible scalability options make it a great choice for larger enterprises looking for comprehensive search capabilities.

Meilisearch excels with its advanced AI capabilities, fast development cycle, and transparent pricing, making it an excellent choice for tech teams and app builders who want to be efficient and achieve fast ROI while benefiting from a secure, scalable search solution.

If you're considering making the switch, check out our [Migrating from Algolia to Meilisearch](https://www.meilisearch.com/docs/learn/update_and_migration/algolia_migration?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia) guide for a smooth transition.

You can see Meilisearch in action using this online [demo](https://where2watch.meilisearch.com/?utm_campaign=comparisons&utm_source=blog&utm_medium=vs-algolia). Also, feel free to check out its [public roadmap](https://roadmap.meilisearch.com/?ref=blog.meilisearch.com) and [GitHub community](https://github.com/orgs/meilisearch/discussions?ref=blog.meilisearch.com) to see what new and upcoming features you can look forward to.

Meilisearch latest news and company updates