 is a vector (an array of numbers) that represents real-world objects such as words, sentences, images or videos. The interesting property that these embeddings have is that two embeddings that represent similar or related real-world entities will share some similarities as well, so embeddings can be compared, and a 

When thinking specifically in terms of an application for searching, performing a search of embeddings in the vector space tends to find results that are more related to concepts, instead of to the exact keywords typed in the search prompt.

In this section of the tutorial you are going to learn how to generate embeddings using freely available machine learning models, then you will use Elasticsearch's vector database support to store and search these embeddings. And towards the end, you will also combine vector and full-text search results and create a powerful hybrid search solution that offers the best of both approaches.

Embeddings Intro

Introduction to Embeddings

In this section you are going to learn about one of the most convenient options that are available to generate embeddings for text, which is based on the 

Working with SentenceTransformers is the recommended path while you explore and become familiar with the use of embeddings, as the models that are available under this framework can be installed on your computer, perform reasonably well without a GPU, and are free to use.

The SentenceTransformers framework is installed as a Python package. Make sure that your Python virtual environment is activated, and then run the following command on your terminal to install this framework:

As always, any time you add new dependencies to your project it is a good idea to update your requirements file:

The next task is to decide on a machine learning model to use for embedding generation. There is a list of 

 in the documentation. Because SentenceTransformers is a very popular framework, there are also compatible models created by researchers not directly associated with the framework. To see a complete list of models that can be used, you can check the 

For the purposes of this tutorial there is no need to overthink the model selection, as any model will suffice. The SentenceTransformers documentation includes the following note with regards to their pretrained models:

"The all-* models where trained on all available training data (more than 1 billion training pairs) and are designed as general purpose models. The all-mpnet-base-v2 model provides the best quality, while all-MiniLM-L6-v2 is 5 times faster and still offers good quality."

 model is a good choice that offers a good compromise between speed and quality, so let's use this model. Locate this model in the table, and click the "info" icon to see some information about it.

An interesting detail that is good to be aware of about your chosen model is the length the generated embeddings have, or in other words, how many numbers or dimensions the resulting vectors will have. This is important because it directly affects the amount of storage you will need. In the case of 

, the generated vectors have 384 dimensions.

The following Python code demonstrates how the model is loaded. You can try this in a Python shell.

The first time you do this, the model will be downloaded and installed in your virtual environment, so the call may take some time to return. Once the model is installed, instantiating it should not take long.

With the model instantiated, you are now ready to generate an embedding. To do this, pass the source text to the 

The result is an array with all the numbers that make up the embedding. As you recall, the embeddings generated by the chosen model have 384 dimensions, so this is the length of the 

Generating Embeddings

Generate Embeddings

In the Full-Text Search chapter of this tutorial you have learned how to create an index with several fields. At that time it was mentioned that Elasticsearch can, for the most part, automatically determine the best type to use for each field based on the data itself. Even though Elasticsearch 8.11 is able to automatically map some vector types, in this chapter you will define this type explicitly as an opportunity to learn more about type mappings in Elasticsearch.

The types associated with each field in an index are determined in a process called 

, which can be dynamic or explicit. The mappings that were created in the Full-Text Search portion of this tutorial were all 

 method, which returns the type mappings that are in effect for a given index. If you want to explore these mappings on your own, start a Python shell and enter the following code:

 method is a dictionary with information about every field in the index. For your convenience, below is a nicely formatted structure of this information for the 

 index created in the Full-Text Search section of the tutorial:

 as type. When trying to decide on a type, Elasticsearch first checks the type of the data, which helps it assign numeric, boolean and object types to fields. When the field data is a string, it also tries to see if the data matches a date pattern. Detection on strings based on patterns can also be enabled for numbers if desired.

, an alternative or secondary type that is available to use when appropriate. In Elasticsearch, dynamically typed 

 sub-field to perform an exact search for a given category. To avoid having the sub-field added, an explicit mapping of 

 can be given, and then this will be the main and only type.

Let's add a new field to the index where an embedding for each document will be stored.

The structure of an explicit mapping matches the 

 method of the Elasticsearch client. Only the fields that need to be typed explicitly need to be given, as any fields that are not included in the mapping will continue to be typed dynamically as before.

 class, adding an explicitly typed field named 

, which is the appropriate type when storing embeddings. You will later learn about another type of vector, the 

, which is useful in other types of semantic search applications.

: the size of the vectors that will be stored. Since version 8.11 the dimensions are automatically assigned when the first document is inserted.

 to indicate that the vectors should be indexed for searching. This is the default.

: the distance function to use when comparing vectors. The two most common ones are 

. The dot product is more efficient, but it requires vectors to be normalized. The default is 

In the previous section you have learned how to generate embeddings using the SentenceTransformers framework and the 

 model. Now it is time to integrate the model into the application.

First of all, the model can be instantiated in the 

As you recall from the full-text search portion of this tutorial, the 

 methods, to insert single and multiple documents into the index respectively. These two methods now need to generate the corresponding embeddings that go with each document.

The next code block shows new versions of these two methods, along with a new 

 helper method that returns an embedding.

 field to the document to be inserted. The embedding is generated from the 

 field of each document. In general, embeddings are generated from sentences or short paragraphs, so in this case the summary is an ideal field to use. Other options would have been the 

 field, which contains the title of the document, or maybe the first few sentences from the document's 

With these changes in place the index can be rebuilt, so that it stores an embedding for each document. To rebuilt the index, use this command:

Storing Embeddings

Store Embeddings in Elasticsearch

The k-nearest neighbor (kNN) algorithm performs a similarity search on fields of 

 type. This type of search, which is more appropriately called "approximate kNN", accepts a vector or embedding as a search term, and finds entries in the index that are close.

In this section you are going to learn how to run a kNN search using the document embeddings created in the previous section.

In the full-text search section of the tutorial you learned about the 

 method of the Elasticsearch client. When searching vectors, the 

 that runs a kNN search for the query entered by the user in the search form.

 options for pagination remain the same, and everything else in the function and the 

 search option accepts a number of parameters that configure the search:

: the field in the index to search. The field must have a 

: the embedding to search for. This should be an embedding generated from the search text.

: the number of candidate documents to consider from each shard. Elasticsearch retrieves this many candidates from each shard, combines them into a single list and then finds the closest "k" to return as results.

: the number of results to return. This number has a direct effect on performance, so it should be kept as small as possible. The value passed in this option must be less than 

With the settings used in the code above, the 10 best matching results will be returned.

You are welcome to experiment with this new version of the application. Here are a pair of good examples to appreciate how useful this type of search:

Searching for "holiday", which is the British English equivalent to "vacation" in American English, kNN search returns the document "Vacation Policy" as top result, even though the word holiday itself does not appear in the document.

Searching for "cats and dogs" or any other term related to pets brings the "Office Pet Policy" document as top result, even though the document summary does not mention any specific pets.

The search query, as defined in the full-text section of this tutorial, allowed the user to request a specific category to be used, using the syntax 

 is in charge of finding and separating these filter expressions from the search query. In the version of the 

 variable is not used, so the category filters are ignored.

 option actually accepts the same type of filters, so the filters can be inserted directly into the 

 query, exactly as they are returned by the 

Aggregations also work well in kNN queries, so they can also be added back:

 function has the same functionality as the full-text search version, implemented using vector search instead of keyword-based search.

In the next section, you'll learn how to combine results from these two different search methods.

k-Nearest Neighbor Search

k-Nearest Neighbor (kNN) Search

You have now seen two different approaches to search a collection of documents, each with its own particular benefits. If one of these methods matches your needs then you don't need anything else, but in many cases each method of searching returns valuable results that the other method would miss, so the best option is to offer a combined result set.

, an algorithm that combines results from two or more lists into a single list.

Elasticsearch integrates the RRF algorithm into the search query. Consider the following example, which has 

 sections to request full-text and vector searches respectively, and a 

 section that combines them into a single result list.

While RRF works fairly well for short lists of results without any configuration, there are some parameters that can be tuned to provide the best results. Consult the 

To enable a combined search that returns results from both full-text and vector search methods, the full-text search logic used earlier in the 

 function has to be brought back. To implement a hybrid search strategy the 

 arguments, each requesting a separate query. The 

 section as shown above is added as well to combine the results into a single ranked list.

 that implements the hybrid search strategy:

With this version the best results from each search method are combined. Click 

 to review the complete application with these changes.

Hybrid Search

Hybrid Search: Combined Full-Text and kNN Results

This section will introduce you to a different way of searching that leverages Machine Learning (ML) techniques to interpret meaning and context.

Vector Search

This hands-on tutorial will teach you how to build a complete search solution using 

How to perform full-text keyword searches on a dataset, optionally with filters

How to generate, store and search dense vector embeddings using a Machine Learning model

 model to generate and search sparse vectors

How to combine search results from the methods listed above using Elastic's 

This most important aspect of this tutorial is that it will show you how to implement all these features on a project that you will run on your own computer, all done in small incremental steps.

The examples you will learn are written in 

, but the concepts are universal and can be applied to your favorite language or technology stack.

To get the most out of this tutorial, we recommend that you follow along and run all the examples.

Welcome

To follow this tutorial you will need to install the following components:

An installation of Elasticsearch, based on our hosted 

 service (which includes a free trial period), or a self-hosted service that you run on your own computer. See the 

 section above for installation instructions.

 interpreter. Make sure it is a recent version, such as Python 3.8 or newer.

The tutorial assumes that you have no previous knowledge of Elasticsearch or general search topics, but it expects you to have a basic familiarity with the following technologies, at least at a beginner level:

The command prompt or terminal application in your operating system.

Requirements

Download the starter search application by clicking on the link below.

Download the Tutorial Starter Application

Find a suitable parent directory for your project, such as your 

 directory, and extract the contents of the zip file there. This should add a 

 directory with several sub-directories and files inside.

 directory created in the previous section.

Following Python best practices, you are now going to create a 

, a private Python environment dedicated to this project. Do this with the following command:

This command creates a Python virtual environment in a 

 in this command with any name that you like. Note that in some installations of Python, you may need to use 

 the virtual environment, which is a way to make this virtual environment the active Python environment for the terminal session you are in. If you are working on a UNIX-based operating system such as Linux or macOS, activate the virtual environment as follows:

The above activation command would also work if you are working inside a WSL environment on a Microsoft Windows computer. But if you are using the Windows command prompt or PowerShell, the activation command is different:

When the virtual environment is activated, the command-line prompt changes to show the name of the environment:

The last step to configure the Python environment is to install a few packages that are needed by the starter application. Make sure that the virtual environment was activated in the previous step, and then run the following command to install these dependencies:

At this point you should be able to start the application with the following command:

To confirm that the application is running, open your browser and navigate to 

The Flask application is configured to run in development mode. When it detects that a source file has been changed, it will restart itself automatically to incorporate the changes. You can leave this terminal session with the application running while you continue with the tutorial, and as you make changes the application will restart to update.

Project Setup

Python Client Setup

Set Up the Elasticsearch Python Client

Create an Index

Create an Elasticsearch Index

Search Basics

Pagination

Filters

Faceted Search

In this section of the tutorial you are going to learn how to work with the full-text search capabilities of Elasticsearch. This will introduce you to several core topics such as working with the Python client library, creating and updating indices, making queries, and working with search results, all of which also apply to the more advanced search methods you will learn later.

Full-Text Search

ELSER Model

The ELSER Model

Semantic Queries

Hybrid Search: Combined Full-Text and ELSER Results

In this section you are going to learn about another Machine Learning approach to search that utilizes the 

Elastic Learned Sparse EncodeR model, or ELSER

, a Natural Language Processing model trained by Elastic to perform semantic search.

Semantic Search

Semantic Search using ELSER

Congratulations, you have finished the Search Tutorial!

We hope that this tutorial has given you a base from which you can start to experiment and create your search solution with Elasticsearch!

Vector Search

Ready to build state of the art search experiences?