Efficient Vector Search with Deep Learning Embeddings in Elasticsearch

The article, originally written by Eike Dehling (Textkernel software and data engineer) and translated by Yang Zhentao, describes how to engineer a search system that uses deep‑learning document embeddings instead of traditional keyword matching.

A document embedding is essentially a long numeric array. Finding similar documents therefore becomes a problem of locating other arrays that are close in vector space, typically using Euclidean distance or similar metrics. Because the search is based on embeddings rather than keywords, it can retrieve semantically related documents even when they contain different terms, achieving synonym‑like recall.

The author notes existing tools such as Facebook’s FAISS library, which is fast and supports many vector‑based retrieval methods, but it does not integrate cleanly with search engines like Elasticsearch. Some Elasticsearch plugins exist ( elasticsearch‑vector‑scoring ), yet they lack filtering capabilities and are slower.

Fast Nearest Neighbours

To speed up retrieval, various index structures are used to filter candidates before exact distance computation. Keyword search relies on inverted indexes; geographic search uses KD‑trees. Similar structures are needed for high‑dimensional vectors because brute‑force distance calculation on a large dataset is prohibitively expensive.

FAISS offers several techniques for building such indexes:

PCA dimensionality reduction

K‑means clustering

Locality‑Sensitive Hashing (LSH)

Other methods not listed

After reducing dimensionality, one can employ KD‑trees, clustering, or LSH together with inverted indexes to quickly shortlist near‑neighbors, then compute precise distances on this smaller set.

Elasticsearch Plugin

Lucene (the underlying library of Elasticsearch) already implements KD‑tree structures, but they are not exposed via the Elasticsearch API. A small custom plugin can expose vector distance calculations; the source code is available at github.com/EikeDehling/vector-search-plugin .

Integration Work

The integration steps are analogous to assembling a puzzle:

Install the Elasticsearch plugin

Perform PCA dimensionality reduction (using Python/sklearn or Java/Smile)

Index the reduced vectors (and any additional fields) into Elasticsearch

Query the index using the new vector‑search capabilities

Example search request (wrapped in a code block):

POST my_index/_search
{
  "query": {
    "function_score": {
      "query": {
        "range": {
          "pca_reduced_vector": {
            "from": "-0.5,-0.5,-0.5,-0.5,-0.5,-0.5,-0.5,-0.5",
            "to": "0.5,0.5,0.5,0.5,0.5,0.5,0.5,0.5"
          }
        }
      },
      "functions": [
        {
          "script_score": {
            "script": {
              "inline": "vector_scoring",
              "lang": "binary_vector_score",
              "params": {
                "vector_field": "full_vector",
                "vector": [ 0.0, 0.0716, 0.1761, 0.0, 0.0779, 0.0, 0.1382, 0.3729 ]
              }
            }
          }
        }
      ],
      "boost_mode": "replace"
    }
  },
  "size": 10
}

Conclusion

The article demonstrates how deep‑learning vector embeddings can be leveraged for fast, accurate similarity search. This approach is useful for any scenario where keyword search falls short, and embeddings can be generated with models such as doc2vec. The combination of PCA reduction, KD‑tree indexing, and a custom Elasticsearch plugin yields a practical, high‑performance solution.