What vector search is

Vector search encodes content into numerical representations that can be used to find similarities between pieces of content. Embedding models map domain-specific data into a vector space where similar items sit close together; at query time the query is embedded into the same space and a nearest neighbour search returns the closest results. Vectors are arrays of fixed dimensions storing numeric values in float, byte or bit form, and the shape of the vector and the comparison function are determined by the embedding model. Similarity is computed with functions such as the dot product, cosine similarity or the Euclidean metric.

  • Encodes content into vectors to measure similarity
  • Vectors are fixed-dimension arrays of float, byte or bit values
  • Distance functions include dot product and Euclidean metric
  • Captures implicit meaning of data beyond keyword matching

Sources: Reduce costs with disk-based vector search - OpenSearch, Boost OpenSearch vector search performance with Intel AVX-512 - OpenSearch

OpenSearch as a vector database

OpenSearch can act as a vector database, storing embeddings as dense vector fields and retrieving them with k-nearest neighbour algorithms. The k-NN implementation is provided as a plugin and is enabled on an index with the index.knn setting, alongside parameters such as ef_construction, m, ef_search and space_type. Published guides show building a hybrid search application against a recipe dataset using an OpenSearch 2.17 cluster and an external embedding model, and setting up a retrieval-augmented generation system with OpenSearch and DeepSeek using the opensearch-py client, transformers, torch and sentence-transformers.

  • index.knn enables k-NN on an index
  • Embeddings stored as dense vector fields
  • opensearch-py official Python client
  • RAG workflows documented with the DeepSeek model
  • Docker image opensearchproject/opensearch-knn for local setup

Sources: Recipes to vectors: Building a hybrid search app with OpenSearch - OpenSearch, Zero to RAG: A quick OpenSearch vector database and DeepSeek integration guide - OpenSearch, Building effective hybrid search in OpenSearch: Techniques and best practices - OpenSearch

Approximate nearest neighbour and HNSW tuning

Because exact k-nearest neighbour search is computationally expensive on large datasets, OpenSearch uses approximate nearest neighbour methods such as Hierarchical Navigable Small Worlds (HNSW). Configuring HNSW is a multi-objective problem balancing search quality, measured by recall@k, against search speed, measured by query throughput. A denser graph generally improves recall but reduces throughput, while a sparser graph has the opposite effect.

  • M – maximum number of graph edges per vector
  • efSearch – size of the candidate queue during search
  • efConstruction – equivalent queue size used during index construction
  • Recall@k and query throughput as the two tuning objectives

Source: A practical guide to selecting HNSW hyperparameters - OpenSearch

Reducing memory cost: disk-based search and quantization

Vector indexes can be very large; storing one billion 768-dimensional 32-bit float embeddings requires roughly 2,861 GB, and costs rise further with replicas and metadata. OpenSearch addresses this with quantization, which compresses vectors into smaller representations while limiting information loss, and with disk-based vector search using online binary quantization. Disk-based vector search offers two modes: on_disk, which includes a rescoring stage, and in_memory, which does not. From OpenSearch 2.13, a k-NN index can also apply Faiss scalar quantization, where the SQfp16 encoder converts each 32-bit float dimension to a 16-bit float, saving about 50% of memory with minimal reduction in recall.

  • on_disk mode: includes a rescoring stage
  • in_memory mode: does not include a rescoring stage
  • Online binary quantization underpins disk-based search
  • Faiss SQfp16 encoder available from OpenSearch 2.13
  • fp16 vector values must fall in the range [-65504.0, 65504.0]
  • clip parameter controls handling of out-of-range values

Sources: Reduce costs with disk-based vector search - OpenSearch, Optimizing OpenSearch with Faiss FP16 scalar quantization: Enhancing memory efficiency and cost-effectiveness - OpenSearch

Hardware acceleration

Intel Advanced Vector Extensions 512 (Intel AVX-512) were introduced in OpenSearch 2.18 as a set of instructions that accelerate vector workloads. Benchmarks run with OpenSearch Benchmark on 4th Generation Intel Xeon Scalable processors showed performance boosts of up to 15% for indexing and up to 13% for search compared with AVX2, across fp32 and fp16 quantization using the Faiss library. Separately, GPU acceleration is being introduced as a preview feature for the OpenSearch Vector Engine in the 3.0 release using NVIDIA cuVS, with a decoupled architecture made up of a Vector Index Build Service, the OpenSearch Vector Engine and an object store.

  • Intel AVX-512 introduced in OpenSearch 2.18
  • Up to 15% indexing and 13% search gains versus AVX2
  • GPU-accelerated index builds use the CAGRA algorithm from NVIDIA cuVS
  • Vector Index Build Service, Vector Engine and object store form the GPU architecture

Sources: Boost OpenSearch vector search performance with Intel AVX-512 - OpenSearch, GPU-accelerated vector search in OpenSearch: A new frontier - OpenSearch

Radial search

Before OpenSearch 2.14, the k-NN plugin provided only top K queries for approximate vector similarity search. OpenSearch 2.14 introduced radial search, which retrieves all points in a vector space within a specified maximum distance or above a minimum score threshold from a query point. Radial search is supported in both k-NN search and neural search, and is useful for proximity-based filtering, threshold-specific queries and dynamic range adjustments.

  • Maximum distance: physical distance threshold in the vector space
  • Minimum score: similarity score threshold such as score > 0.95
  • Supported in k-NN search and neural search
  • Available from OpenSearch 2.14

Source: Understanding vector radial search in OpenSearch - OpenSearch

Hybrid search and score normalisation

Vector search can be combined with lexical BM25 search in hybrid queries, which merge results from multiple query sources to improve relevance. Because the subqueries produce scores on different scales, OpenSearch normalises them before combination, using score-based techniques such as min-max and L2 normalisation and rank-based techniques such as reciprocal rank fusion. Z-score normalisation was added in OpenSearch 3.0-beta1 and is applied by creating a search pipeline that specifies z_score as the technique. Min-max suits closely clustered top-k results, while z-score suits more evenly distributed, approximately normal score distributions.

  • Min-max and L2 score-based normalisation
  • Rank-based combination via reciprocal rank fusion
  • z_score technique added in OpenSearch 3.0-beta1
  • Normalisation applied through a search pipeline

Sources: Building effective hybrid search in OpenSearch: Techniques and best practices - OpenSearch, An overview of rank normalization in hybrid search - OpenSearch, Introducing the z-score normalization technique for hybrid search - OpenSearch

Project context and where to find it

Vector search is listed on the OpenSearch home page under machine learning and AI capabilities, alongside anomaly detection, search, observability and security analytics. OpenSearch is distributed under the Apache 2.0 licence and can be downloaded from the project site, with documentation, a blog, a forum, GitHub and Slack available to users. The OpenSearch Software Foundation, formed in September 2024, is a project of the Linux Foundation and governs the project.

  • Apache 2.0-licensed open source suite
  • Download and documentation available on opensearch.org
  • Community channels: forum, events, blog, GitHub, Slack
  • OpenSearch Software Foundation formed in September 2024

Source: Home - OpenSearch

Sources

  1. Home - OpenSearch https://opensearch.org/ Verified 01 Nov 2026
  2. Recipes to vectors: Building a hybrid search app with OpenSearch - OpenSearch https://opensearch.org/blog/recipes-to-vectors-building-a-hybrid-search-app-with-opensearch/ Verified 01 Nov 2026
  3. Introducing the z-score normalization technique for hybrid search - OpenSearch https://opensearch.org/blog/introducing-the-z-score-normalization-technique-for-hybrid-search/ Verified 01 Nov 2026
  4. Building effective hybrid search in OpenSearch: Techniques and best practices - OpenSearch https://opensearch.org/blog/building-effective-hybrid-search-in-opensearch-techniques-and-best-practices/ Verified 01 Nov 2026
  5. A practical guide to selecting HNSW hyperparameters - OpenSearch https://opensearch.org/blog/a-practical-guide-to-selecting-hnsw-hyperparameters/ Verified 01 Nov 2026
  6. Boost OpenSearch vector search performance with Intel AVX-512 - OpenSearch https://opensearch.org/blog/boost-opensearch-vector-search-performance-with-intel-avx512/ Verified 01 Nov 2026
  7. GPU-accelerated vector search in OpenSearch: A new frontier - OpenSearch https://opensearch.org/blog/gpu-accelerated-vector-search-opensearch-new-frontier/ Verified 01 Nov 2026
  8. Reduce costs with disk-based vector search - OpenSearch https://opensearch.org/blog/reduce-cost-with-disk-based-vector-search/ Verified 01 Nov 2026
  9. Zero to RAG: A quick OpenSearch vector database and DeepSeek integration guide - OpenSearch https://opensearch.org/blog/deepseek-integration-rag/ Verified 01 Nov 2026
  10. An overview of rank normalization in hybrid search - OpenSearch https://opensearch.org/blog/how-does-the-rank-normalization-work-in-hybrid-search/ Verified 01 Nov 2026
  11. Optimizing OpenSearch with Faiss FP16 scalar quantization: Enhancing memory efficiency and cost-effectiveness - OpenSearch https://opensearch.org/blog/optimizing-opensearch-with-fp16-quantization/ Verified 01 Nov 2026
  12. Understanding vector radial search in OpenSearch - OpenSearch https://opensearch.org/blog/vector-radial-search/ Verified 01 Nov 2026

Last verified 01 Nov 2026. This entry is compiled from the public web pages listed above. Nothing here is stated that those pages do not, and each of them was read on the date shown.