Search bars are an integral part of browsing the web. Whether we are shopping for clothes, enjoying music, or planning a vacation, there is always a dedicated search engine at work to simplify our lives. Have you ever wondered how these search engines actually work? In this article, we will delve into the inner workings of one of them: [Meilisearch](https://meilisearch.org.cn).

Indexing time: from data to documents
-------------------------------------

Indexing is a fundamental process that encompasses the collection, parsing, and storage of data for subsequent retrieval. It plays a crucial role in enabling search engines to deliver fast and relevant results.

### A performant storage engine

Meilisearch stores data in the form of discrete records called "[documents](https://docs.meilisearch.com/learn/core_concepts/documents.html)," which are grouped together into collections known as "[indexes](https://docs.meilisearch.com/learn/core_concepts/indexes.html)." Under the hood, Meilisearch uses the LMDB ([Lightning Memory-Mapped Database](http://www.lmdb.tech/doc/)) key-value store which has proven stability and extensive usage in database applications. As the name implies, key-value stores are storage systems that organize data as a **collection of key-value pairs**.

![Illustration of a key-value store with 'engine' set to 'meilisearch' and 'language' set to 'rust'](https://unable-actionable-car.media.strapiapp.com/key_value_store_d2a8b6ff55.png)

Example of key-value entries

Key-value stores offer flexibility, fast access times, and efficient performance, contributing to quick and responsive interactions for users. By permitting only a single writing process at a time, LMDB avoids synchronization-related issues. As a result, it enables unlimited concurrent readers to have fast access to up-to-date, consistent data.

Before storing data in its key-value store, Meilisearch must preprocess it thoroughly. That’s where tokenization comes in.

### From words to tokens

**Tokenization** involves two main processes: segmentation and normalization.

**Segmentation** consists in splitting a sentence or phrase into smaller units called tokens.

Meilisearch uses (and maintains) the open-source tokenizer named [Charabia](https://github.com/meilisearch/charabia). The tokenizer is responsible for retrieving all the words (or tokens) from document fields.

<Callout>
  In practice, Meilisearch users can configure which fields should be [searchable](https://meilisearch.org.cn/docs/learn/configuration/displayed_searchable_attributes#searchable-fields), allowing Charabia to know which fields should be tokenized.
</Callout>

Then comes **normalization**. Words are normalized based on each language’s particularities. For a romance language like French, this process includes setting the word in lowercase letters and removing diacritical marks such as accents. For instance, a sentence like “Le café de Nicolas” is transformed into “le cafe de nicolas”.

![The sentence 'Le café de Nicolas,' with a capital 'L' and 'N,' and an accent on the 'é' of 'café,' is first split into words during the segmentation phase. Then, during normalization, each word is lowercased, and accents are removed.](https://unable-actionable-car.media.strapiapp.com/Tokenisation_3_ea1333d3a3.png)

Example of the segmentation and normalization stages in the tokenization process

After segmenting and normalizing words, the engine needs to classify them. Using the appropriate data structure to organize tokens is crucial for performance. This will later allow swift retrieval of the most relevant search results.

### Storing tokens

Modern full-text search engines like Meilisearch come with features such as prefix search, typo tolerance, and geo search. Each data structure has its own advantages and disadvantages. When designing the search engine, our team carefully selected the ones best suited to enable these features without compromising on speed.

Throughout this section, we will explore which data structures powers Meilisearch.

#### Inverted index

First and foremost, we need to talk about inverted indexes. Without a doubt, it’s the data structure that stands out by its importance. Meilisearch uses it to return documents fast upon search.

An **inverted index** maps each word in a document to the set of documents where that term appears along with additional information like their position in the document.

![Given the following documents: `{   “id”: 1   "title": "Hello world!" }, {     “id”: 2     "title": "Hello Alice!" }.  The inverted index would look like this:  "alice" -> [2], "hello" -> [1,2],  "world" -> [1]` ](https://unable-actionable-car.media.strapiapp.com/Inverted_index_3_edcd06ad15.png)

Illustration of an inverted index generated from given documents, showcasing the mapping of keywords to document IDs

By storing words once and associating them with the documents where they appear, inverted indexes leverage the redundancy of terms across documents. Thanks to this, Meilisearch does not need to browse all documents in order to find a given word, resulting in faster searches.

Meilisearch creates approximately 20 inverted indexes per document index, making it one of the data structures with the highest number of instances. Indeed, to provide a search-as-you-type experience, the engine needs to precompute a lot at indexing time: word prefixes, documents containing filterable attributes, and more. For a better understanding of how inverted indexes work read more on [indexing best practices](/blog/best-practices-for-faster-indexing/

<Callout>
  You can find the complete list of Meilisearch inverted indexes [on GitHub](https://github.com/meilisearch/meilisearch/blob/78e611f282d726a604cfbc231666265a37c4d46b/milli/src/index.rs#L103-L157).
</Callout>

#### Roaring bitmap

**Roaring bitmaps** are compressed data structures designed for efficiently representing and manipulating sets of integers.

Meilisearch uses roaring bitmaps widely throughout its inverted indexes to represent document IDs. Roaring bitmaps offer a space-efficient way to store large sets of integers and perform set operations like [union, intersection, and difference](https://en.wikipedia.org/wiki/De_Morgan%27s_laws). These operations play a crucial role in refining search results by allowing the inclusion or exclusion of specific documents based on their relationship with others.

#### Finite-state transducer

A finite-state transducer (FST) is a structured data representation ideal for performing string-matching operations. It represents a sequence of states ordered from smallest to largest, with words arranged in lexicographic order.

<Callout>
  [Lexicographic order](https://en.wikipedia.org/wiki/Lexicographic_order) is a method of arranging or sorting items, such as words or symbols, based on their alphabetical or numerical sequence.
</Callout>

A finite-state transducer is also called a _word dictionary_ because it contains all words present in an index. Meilisearch relies on the utilization of two FSTs: one for storing all words of the dataset, and one for storing the most recurrent prefixes.

FSTs are useful because they support compression and lazy decompression techniques, optimizing memory usage and storage. Additionally, by using automata such as regular expressions, they can retrieve subsets of words that match specific rules or patterns. Moreover, this enables the retrieval of all words that begin with a specific prefix, empowering fast, comprehensive search capabilities.

The FST, with its compact design, presents the added advantage of being a smaller data structure than the inverted index. As we will see later, this contributes to faster and more efficient reading operations. You can learn more about the topic in this [comprehensive article on finite-state reducers](https://blog.burntsushi.net/transducers/).

#### R-tree

R-trees are a type of [tree](https://en.wikipedia.org/wiki/Tree_\(data_structure\)) used for indexing multi-dimensional or spatial information. Meilisearch leverages R-trees to power its geo search functionality.

The **R-tree** associates geographical coordinates with the identifiers of the document to which it belongs. By organizing coordinates this way, it enables Meilisearch to perform spatial queries with remarkable efficiency. These queries allow users to find nearby points, points within a specific area, or points that intersect with other spatial objects.

Search time: query processing
-----------------------------

Modern search experiences only require you to start typing to get results. To achieve this search-as-you-type experience, Meilisearch precomputes a list of the most frequent prefixes.

To be tolerant to typos, Meilisearch uses finite-state transducers in conjunction with the [Levenshtein algorithm](https://meilisearch.org.cn/docs/learn/configuration/typo_tolerance#understanding-typo-calculations). This algorithm calculates the Levenshtein distance which can be thought of as the cost of transforming a string into another. In other words, it quantifies the number of transformations required for a word to be converted into another word.

In the context of the Levenshtein algorithm, possible transformations are:

*   insertions, e.g. hat -> chat
*   deletions, e.g. tiger -> tier
*   substitutions, e.g. cat -> hat
*   transpositions or swaps, e.g. scared -> sacred

FSTs generate all possible variations of a word within a specified edit distance, enabling the engine to calculate the Levenshtein distance and accurately detect typos by comparing user input against a dictionary of valid words.

It becomes apparent that there are many factors to consider when processing a search request. Has the user finished typing? Are there typos in the query? Which documents should appear first in the search results?

Let’s discuss how Meilisearch processes search queries and how it refines and sorts search results.

### Query graph

Each time it receives a search query, Meilisearch creates a query graph representing the query and its possible variations.

To compute these variations, Meilisearch applies [concatenation](https://meilisearch.org.cn/docs/learn/advanced/concat#concatenated-queries) and [splitting](https://meilisearch.org.cn/docs/learn/advanced/concat#split-queries) algorithms to the query terms. The variations considered also include potential typos and synonyms–if the user set them. As an example, let’s examine the query: `the sun flower`. Meilisearch will also search for the following queries:

*   `the sunflower`: concatenation
*   `the sun flowe**d**`: substitution
*   `the sun flower**s**`: addition

Consider now a more complex query: `the sun flower is facing the su`, the query graph should look like this:

![Graph representing interpretations of the search query 'the sun flower is facing the su'. The engine precomputes for each query term word variations, like 'flowed' or 'flowers' and the associated Levenshtein cost ](https://unable-actionable-car.media.strapiapp.com/debuggong_image_e0a6ce757c.png)

Visual generated using our internal debugging tool, powered by [D2](https://github.com/terrastruct/d2), showcasing the execution process of search requests

As illustrated above, the graph represents different interpretations of the search query. The engine precomputes the word variations (and their cost) for each query term. Moreover, it detects whether the last query term is a prefix (not followed by a space), thus signaling the need to consult the prefix database.

So how does the engine utilize a query graph?

As we saw earlier, during the indexing process, Meilisearch identifies all documents that have filterable attributes, such as `genre`. Subsequently, it generates a list of document IDs associated with each attribute value, like `comedy` or `horror`. First of all, when a filter is applied, Meilisearch narrows down the potential results to the document IDs that fulfill the filter criteria.

Next, it uses the query words and the variations generated in the query graph and searches for matching words in the finite-state transducer (that is, our word dictionary). If the word is considered a prefix, it will also look it up in the prefix FST.

When encountering words in a FST, it searches them within the inverted index—which contains a mapping of words to document IDs— to retrieve the corresponding document IDs.

Finally, the engine performs an intersection to identify the documents that contain the words in the query graph and meet the filter criteria.

Let's take an example to better understand query processing: suppose you have a dataset of songs. The search query is `John Lennon`. The user wants to retrieve only songs released between 1957 and 1975.

First, Meilisearch retrieves the document IDs of songs within that time frame. Then, after checking in the FST that the words in the query graph exist, Meilisearch retrieves the IDs of the documents that contain either `John`, `Lennon`, or both. It also retrieves the possible variations, but we are not including them in this example for the sake of simplicity.

![Three Venn diagrams illustrating the process of retrieving songs released based on a user query (John Lennon) with a date filter (between 1057 and 1975).  Diagram 1: Represents songs released between 1957 and 1975. Diagram 2: Represents songs with "John" and/or "Lennon" in the title. Diagram 3: Represents the intersection between the two previous diagrams.](https://unable-actionable-car.media.strapiapp.com/diagrams_2_ac89ed0fa9.png)

Diagrams illustrating the operations involved in retrieving documents based on a user query.

Finally, the intersection of the two sets of document IDs is taken (the purple area in the diagram.) This means only document IDs that appear in both sets are kept. In other words, Meilisearch retains the document IDs of songs released between 1957 and 1975 that contain either `John`, `Lennon`, or both.

What happens when several documents match the search query, how does the engine decide which one to return first? Which one is more relevant? Let's explore the rules allowing Meilisearch to determine how to rank results.

### Relevancy

As we discussed earlier, the query graph includes possible variations of words. As a result, Meilisearch will also return documents with an artist, such as _John_ _Lebon_, as part of the search results.

Fortunately, the query graph not only accounts for word variations but also assigns them the Levenshtein cost, which, among other factors, helps Meilisearch determine the relevancy of the search results.

Meilisearch sorts documents in the search results using [bucket sort](https://en.wikipedia.org/wiki/Bucket_sort). This algorithm allows ranking documents based on a set of consecutive rules. By default, Meilisearch prioritizes rules as follows:

1.  Words: sorts documents based on the number of matched query terms, with documents containing all query terms ranked first
2.  Typo: sorts documents based on the number of typos, with documents matching query terms with fewer typos ranked first
3.  Proximity: sorts documents based on the distance between matched query terms. Documents where query terms occur close together and in the same order as the query string are ranked first
4.  Attribute: sorts documents based on the ranking order of attributes. Documents containing query terms in more important attributes are ranked first. Documents with query words at the beginning of attributes are considered more relevant than those with query words at the end
5.  Sort: sorts documents based on the user-defined parameters set at query time, if active
6.  Exactness: sorts documents based on the similarity of matched words with the query words

Meilisearch applies these rules sequentially, sorting results step by step. If two documents are tied after one rule, it uses the next rule to break the tie.

<Callout>
  Note that these rules are fully customizable, meaning you can add, delete, and reorder them as needed. Read more in the [relevancy documentation](https://meilisearch.org.cn/docs/learn/core_concepts/relevancy#ranking-rules).
</Callout>

By default, Meilisearch returns up to 1000 documents per search, prioritizing delivery of the most relevant results rather than all matching results. In other words, Meilisearch prioritizes efficiency and relevance over exhaustive results to ensure an optimized search experience.

Conclusion
----------

Search engines are complex systems that encompass multiple interconnected components, all working together to deliver a seamless search experience. While the inner workings may differ among search engines, we have explored the underlying mechanisms that power a modern search engine.

Meilisearch is currently exploring the vast realm of [**semantic search**](https://github.com/meilisearch/meilisearch/issues/3838). **AI-powered search** is reshaping the way we understand queries and documents, opening up new possibilities and use cases. If you’re eager to experience it firsthand, we invite you to try our [vector search prototype](https://github.com/meilisearch/product/discussions/621#discussioncomment-6183647)—your feedback would be greatly valuable!

Meilisearch is an open-source search engine that not only provides state-of-the-art experiences for end users but also a simple and intuitive developer experience. Do you want to see Meilisearch in action? Try our [demo](https://where2watch.meilisearch.com/?ref=blog.meilisearch.com). You can also [run it locally](https://meilisearch.org.cn/docs/learn/getting_started/quick_start?ref=blog.meilisearch.com) or create an account [on Meilisearch Cloud](https://cloud.meilisearch.com/login?ref=blog.meilisearch.com).

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

How to deliver the best search results: inside a full text search engine

Full text search refers to matching some or all of a text query with documents stored in a database. Compared to traditional database queries, full text search provides results even in case of partial matches. It allows building more flexible search interfaces for users, thus enabling them to find accurate results more quickly.

From simple in-app search to browsing huge ecommerce catalogs, full text search use cases are numerous. It is so common that Postgres and other relational databases include dedicated APIs for full text search. Unfortunately, Postgres falls short of search-focused databases in multiple areas.

1\. Complex setup
-----------------

To provide relevant results, full text search should tolerate typos, allow synonyms, and allow partial matches. Additionally, results ranking needs to be highly customizable to adapt to a business’s specific needs. Configuring full text search on Postgres comes at the cost of [comprehensive configuration](https://rachbelaid.com/postgres-full-text-search-is-good-enough/) and often requires extensions that can’t be used when using managed Cloud services.

Creating database indexes, writing queries, and ranking algorithms quickly overstep domain knowledge and demand expertise in searching, indexing, and linguistics. Optimizing for performance gets even harder when working around constraints from mixed-and-matched extensions aimed at coping with Postgres full text search limitations.

Conversely, a search-focused database comes with [state-of-the-art features](https://meilisearch.org.cn/docs/learn/what_is_meilisearch/overview#features) like typo tolerance, prefix search, fuzzy matching, synonyms, and customizable rankings out of the box.

2\. Faceted search
------------------

[Faceted search](https://meilisearch.org.cn/docs/learn/fine_tuning_results/faceted_search) allows users to refine search results by broad categories. It’s often used in ecommerce applications. For example, a clothing shop can implement filtering by facets such as brand, size, or rating range.

[![Faceted search on an ecommerce website](https://unable-actionable-car.media.strapiapp.com/ecommerce_demo_4_final_1_48b9d742ac.gif)](https://ecommerce.meilisearch.com/)

Faceted search on an ecommerce website ([see demo](https://ecommerce.meilisearch.com/))

Implementing filtering is tricky enough for a single facet. But facets can take many shapes: category tags, price ranges, or minimum rating. Implementing filtering for all types is very challenging. By all means, the trickiest query to implement is aggregating results to build facet counts. This becomes very resource intensive on large datasets.

The complexity of implementing faceted search with Postgres grows exponentially with the number of facets. Faceted search alone makes a strong selling point for search engines like [Elasticsearch or Meilisearch](/blog/why-should-you-use-meilisearch-over-elasticsearch/)hey come with optimized, first-class APIs to handle facets filtering and counting.

3\. Typo tolerance
------------------

By default, Postgres full text search cannot handle misspellings. Users commonly install the `pg_trgm` extension to work around this limitation. (Again, this solution is not always available in managed Postgres.) This extension notably introduces new operators to compare similarity between strings along with search-optimized GIN and GIST indexes.

The new indexes allow more configuration for full text search, but choosing between GIN and GIST indexes is not always trivial. Moreover, the new operators do not take into account word proximity, space separators, or word size. This, in particular, makes it hard to achieve real fuzzy matching with Postgres.

Ideally, a search-focused database should allow configuring different rules for single versus multiple words queries. It is the case of Meilisearch, which allows disabling typos entirely for specific fields. This enables users to search via unique identifiers like a book’s _International Standard Book Number_ (_ISBN_).

[![Example of typo tolerance](https://unable-actionable-car.media.strapiapp.com/typo_tolerance_2_gif_4409419422.gif)](https://typo-tolerance.meilisearch.com/)

Typo tolerance is disabled for the ISBN field ([see demo](https://typo-tolerance.meilisearch.com/))

4\. Language support
--------------------

Linguistic specificities vary a lot between languages using the Latin alphabet and others like Arabic or Chinese. As of Postgres 15, full text search dictionaries are unavailable for Simplified and Traditional Chinese, Korean, and Japanese, among others. This means resorting to specific implementations for different languages.

<Callout>
  To see the [list of languages supported by Postgres full text search](https://gist.github.com/Strift/3155b9238bac6495d4cd57b83d78415f), you can run the \`\\dFd\` command in Postgres.
</Callout>

Language support constraints are amplified in managed environments like Amazon RDS where users are unable to access the filesystem. This restricted access prevents them from implementing custom dictionaries, stemmers, synonyms, and more.

Meilisearch comes with [optimized language support](https://meilisearch.org.cn/docs/learn/what_is_meilisearch/language) for Chinese, Japanese, Korean, Hebrew and more, on top of all languages using whitespace to separate words.

<Callout>
  Thanks to its vibrant open-source community, Meilisearch benefits from native speakers' contributions to [improve language-specific features](/blog/improving-meilisearchs-language-support/)
</Callout>

5\. Paying the backend price
----------------------------

Postgres is a database intended to communicate with server-side languages. When building a public-facing client application, it means building an API on top of the database to communicate with clients. On top of additional development time, creating such a proxy entails further problems.

First comes the issue of latency: making requests to an API that queries the database before returning results is bound to take some time. This does not affect dedicated search engines, as they come with a public API intended to deliver data to end users.

Now comes the second issue: security. Search engines APIs are designed, from the start, for public consumption. And security’s baked in for that use case. By default, API keys restrict search requests, while advanced features like [tenant tokens enable multi-tenancy](https://meilisearch.org.cn/docs/learn/security/tenant_tokens#tenant-token-payload-reference).

[![Example of tenant tokens usage](https://unable-actionable-car.media.strapiapp.com/meili_create_token_c6fb7330a6.gif)](https://tenant-token.meilisearch.com/)

Using tenant tokens to restrict access to documents ([see demo](https://tenant-token.meilisearch.com/))

6\. Scaling limitations
-----------------------

There is a legitimate motive for wanting to keep all data in a single database. But having search-related data in the main database comes with great technical consequences. Full text search queries on large dataset become costly with Postgres, especially when ranking results and computing facet counts.

Monolithic databases often become the bottleneck of applications that need to scale. Don’t add unnecessary search-related costs to this resource when you can avoid it. These costs are only multiplied when building user-facing applications with high traffic.

Unlike relational databases, full text search engines like [Meilisearch use inverted indexes](/blog/best-practices-for-faster-indexing/)his data structure creates information redundancy to allow quicker information retrieval. It is designed to perform search operations, and will naturally outperform relational databases on large datasets. And, when search usage spikes, there is a single service that needs scaling.

7\. Relevancy
-------------

As we mentioned earlier, relevant search requires typo tolerance, custom rankings, and synonyms. In modern applications, users expect results to update on each keystroke, which requires [prefix searching](https://meilisearch.org.cn/docs/learn/advanced/prefix). But Postgres full text search `ts_rank` function only allows attribute weighting. When using the `pg_trgm` extension, developers are left to implement their own sorting based on similarity.

In search-focused databases, the concepts of result ranking, attribute priority, numbers of word matched, and exactness of the query are first-class concepts. They match high-level APIs that allow explicit fine-tuning of search behavior. This makes it easier to make these concepts available to non-tech, business stakeholders. This was cited as a key reason for [why Bookshop chose Meilisearch](/blog/bookshop-increases-search-based-purchases/)or their ecommerce search.

8\. Missing out on InstantSearch libraries
------------------------------------------

When it comes to search experience, websites and applications often implement the same user interface patterns: a textual search bar, checkbox lists of facets, range sliders, sorting menu, page navigation, etc. The open-source InstantSearch library comes with implementations of all these features in the form of widgets available via SDKs in JavaScript, iOS, and Android.

When time to market is paramount, it’s hard to pass on such niceties. Supported by Algolia, the InstantSearch libraries enjoy wide adoption and several search engine databases come with [InstantSearch-compatible APIs](https://github.com/meilisearch/meilisearch-js-plugins/tree/main/packages/instant-meilisearch). Read our Nuxt guide for ecommerce search to learn [how to implement InstantSearch widgets with Vue](/blog/nuxt-ecommerce-search-guide/)Callout>
  Prefer React? Read our tutorial on [using InstantSearch with React](/blog/instant-meilisearch/)/Callout>

9\. Limited Cloud support
-------------------------

Outsourcing the provisioning, maintenance, and scaling of servers is a common strategy in the Cloud era. Instead of managing servers, teams can focus on delivering value to their users. Postgres, like other databases, is available in a wide range of Cloud offerings for managed services. Unfortunately, managed services often come with limitations.

In the case of Postgres, implementing state-of-the-art full text search requires installing extensions. Moreover, fine-tuning language dictionaries and more configuration require access to the file system. Unfortunately, this means that many features are unavailable in Cloud environments.

To enable delegation of infrastructure, search engines often come with [dedicated cloud services](https://meilisearch.org.cn/cloud). Those bespoke platforms do not compromise and allow using the full palette of search features. Moreover, customers can benefit from premium SLAs, support, and other enterprise services tailored to their searching use cases.

* * *

Postgres is a great, flexible database that allows the implementation of many custom, all-in-one solutions. Its full text search features might be sufficient for basic search, but it falls short when it comes to real-time search with relevance concerns. These limitations become worse on large datasets. It’s only natural, because Postgres is a database, not a search engine.

Meilisearch is an open-source search engine to build fast and relevant search experiences. It aims at providing state of the art experiences for end users while providing a simple and intuitive developer experience. You can try it by [running Meilisearch locally](https://meilisearch.org.cn/docs/learn/getting_started/quick_start) or creating an account [for free on Meilisearch Cloud](https://cloud.meilisearch.com/login).

* * *

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-postgres)

* * *

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

When does Postgres stop being good enough for full text search?

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

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

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

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

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

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

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

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

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

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

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

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

### Key strengths

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

**Flexibility**

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

**Scalability**

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

**Aggregation and analysis**

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

### Challenges

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

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

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

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

Here is Elasticsearch’s default response:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### Key strengths

Meilisearch focuses on simplicity, relevancy, and performance.

**Simplicity**

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

**Relevancy**

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

**Performance**

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

Challenges
----------

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

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

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

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

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

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

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

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

Learn more about what Meilisearch can bring to your business

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

* * *

Conclusion
----------

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

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

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

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

Meilisearch vs Elasticsearch

Meilisearch v0.30 is out and brings with it the ability to create numbered page selectors. You can read more about the new features and updates from v0.30 in our [release blog post](/blog/whats-new-in-v0-30/)his article will go over the different ways of navigating search results and the pros and cons of each method.

### What is pagination, and what are some common alternatives?

Let’s say you go to an ecommerce website to buy a new pair of shoes. It would be quite overwhelming if you got 700 pairs of shoes to choose from as soon as the page loads—not to mention that fetching every pair of shoes would certainly slow down the site.  

To avoid this, most websites will break search results up into chunks, such as pages, and load a certain number at a time based on input from the user.  

There are three main ways to display large datasets: pagination, infinite scroll, and load more. Each method has benefits and downsides that make it suited for certain use cases and content types. For example, Google’s use of numbered pagination makes it easier to find a specific result again, while Twitter, Facebook, and Instagram use infinite scroll to keep users glued to their screens. Google uses load more on mobile devices to display search results.  

Changing from one type of pagination to another can completely alter user experience.  Imagine waking up to a paginated version of Twitter, where you have to continuously click a “Next” button to view more posts in your feed (thanks, Elon). This would completely change the way you interact with the site!  

In making the choice of how to display search results, you decide how much content to show users at one time, what action they have to take to view more, and how convenient it is to find a specific result again.

### Pagination

Pagination works by breaking search results down into separate pages. There are two main types of pagination interfaces: numbered ones, where you find a list of numbered pages at the bottom of each page, and unnumbered ones, where you navigate from page to page using the “Previous” and “Next” buttons.  

Pagination is one of the most popular ways to display search results and is particularly common on ecommerce websites. Pagination breaks down content, making it easier to process. Since each page is distinct, users can easily return to items they liked or share them with others. This helps users to search for something specific instead of browsing through a never-ending list of items.  

The biggest downside to pagination is that most users don’t look beyond the first few pages and hence never get to look at more results. When was the last time you went to the second page of Google’s search results?

![](https://media.tenor.com/zmDrt3416pcAAAAC/think-winniethepooh.gif)

Since the results are replaced with every new page, users need to switch between pages to compare results. In addition, pagination isn’t very mobile-friendly. Mobile users prefer load more or infinite scroll as it’s more intuitive. It also requires additional actions from the user: clicking the “Next” button and waiting for the page to load. This may also give the impression that pagination is slow.

#### Numbered page selection

Page numbers add clarity to the search process and guide users to what they’re searching for. Numbered page selection offers numerous advantages, such as:  

*   Users can be shown the total number of pages of results, allowing them to estimate how long they will need to find a particular item. (“I have 25 pages worth of shoes to sift through!”)
*   With numbered pages, it’s clear that some pages are more relevant than others. (“I didn’t find those shoes on the first five pages, so this website probably doesn’t sell them.”)
*   Users can remember the positioning of an item, and numbered pages allow them to return to it faster. (“I liked the pink shoes on page 3.”)
*   Users can generally stop in the middle of a session and continue from where they left off. (“I stopped at page 5 yesterday.”)

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

#### “Previous” and “Next” buttons

In numberless pagination, users navigate via “Next” and “Previous” buttons instead of a list of numbered pages. This alternative to numbered pagination is often used for mobile displays where there isn’t enough space to display page numbers. Since there are only two buttons, it offers less precision, as users can’t jump to specific pages. However, it offers better performance as it isn’t necessary to calculate the total number of search results.  

![](https://lh4.googleusercontent.com/7g66Jnt6E-GR1esTMZrmCv6MDvHMOn-FprG5cHxYQhmHGQLS8vYFvlmOlpaBdjmf_pc285dIACe3SeUNSj2UJ9C2JMfk4cxoxbqFuS_eD4q9qZp1h2yhIaz-9ng7xB3ly39_PvvtUNqm6L0a5euKFYvZSn9ttg5NzKPQMmz4X0k37XiGqD7RnkuVwT9XKg)

### Infinite scroll

Infinite scroll has become increasingly popular over the past decade due to the rise in smartphones. It loads more content seamlessly as the user scrolls, reducing friction. It’s also more intuitive than pagination; you just keep scrolling to view more content! Additionally, since all the content is loaded to a single page, it may seem faster than traditional pagination.

![](/blog/content/images/2022/11/IMG_3391.GIF

The biggest downside to infinite scroll is poor usability.  The page length increases infinitely, making it difficult to find previously viewed results again, nor can users bookmark or share a particular set of items on the list.  Page performance slows down as more content is loaded, making the page “heavier”. Meanwhile, the site footer may be inaccessible since infinite scroll pushes it endlessly down as more content is loaded. Since Googlebot cannot emulate scrolling, infinite scroll also has a negative impact on SEO.  

However, the greatest impact by far is on user behavior. At some point, users of infinite scroll will stop paying attention to individual results and begin to focus more on scrolling, leading to decreased engagement. You can read more about this in [Baymard Institute's study](https://www.smashingmagazine.com/2016/03/pagination-infinite-scrolling-load-more-buttons/) on design patterns for loading products on desktops and mobile devices.  

Based on the above, infinite scroll may not be the best solution for ecommerce websites. How do you find the pink shoes you liked 15-ish scrolls ago?  

There is one use case where infinite scroll cannot be beat. For entertainment websites whose main purpose is to keep the users with no particular aim on the page for as long as possible, infinite scroll all but guarantees a longer time on site. This is why infinite scroll is closely linked with social media and other business models that rely on advertising or data harvesting.

### Load more

Like infinite scroll, load more is a mobile-friendly option that works by extending one page infinitely. However, unlike infinite scroll, load more allows users to choose whether they want to view more results by clicking a “Load more” button at the bottom of the page. This critical difference gives users more control, making it easier, for example, to access the footer or keep track of a specific result. Studies show that it also increases the amount of attention users give to each individual item.  

Load more shares many downsides with infinite scroll, such as poor page performance. Like infinite scroll, it’s not ideal for SEO as Googlebot cannot click the “Load more” button. This means it cannot crawl or index all of your content.  

![](https://lh5.googleusercontent.com/-xmPwy0C6ZdgZoHNMV4fmRdxR_g9scVY5J0ktGY_k0oh24Un80WooYE9zSRo_TxNhPJE5--hAQJ-UJIRPejnFZt4pcNca6l4z6JedvwrjdKucMBAurVeBgMgIGYWS9unr2cOEA-1CZYBwlQ0ySexv2HqYSWqCSemBCVK5_jb-VweLwczjNcXQjl3ghxdmA)

### So, what do I use?

The short answer: it depends on the kind of product experience you want.  

**Pagination**

*   Your users are looking for highly specific results
*   SEO is very important to you

**Infinite scroll**

*   You’re building a social media site
*   Your users want to explore a large amount of content

**Load more**

*   You want to hide your content behind a paywall
*   You want to build an ethical mobile experience
*   You want to gain some of the benefits of both pagination and infinite scroll  
    

Or you could go hybrid! Consider Ikea: they use a load more button but also display the total number of search results and a progress bar, enabling users to see how many results they’ve viewed so far.  

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

While we have covered the three main ways to display search results today, they are far from set in stone. At the end of the day, your goal is to help your users find the content they need. If you understand which key goals you want to accomplish with your search navigation interface and which pitfalls you want to avoid, you may be able to design something even better than what’s been done before. Good luck, and let us know what you create with Meilisearch!

Meilisearch 最新消息和公司动态

如何提供最佳搜索结果：深入了解全文搜索引擎

Postgres 何时不再适合全文搜索？

Meilisearch 与 Elasticsearch

导航搜索结果：分页、无限滚动和加载更多