As we established in the introduction to this chapter, the goal of a vector database is to efficiently find vectors similar to a given query vector. The most straightforward approach is exact nearest neighbor search, often called k-Nearest Neighbors (k-NN) when looking for the top $k$ results. This involves calculating the distance (e.g., cosine similarity or Euclidean distance) between the query vector and every single vector in the database, then sorting these distances to find the closest matches.

While simple to understand, this brute-force method quickly becomes computationally prohibitive as the dataset size ( $N$ , the number of vectors) and the dimensionality ( $D$ ) of the vectors grow. Imagine a database with millions or even billions of vectors, each having hundreds or thousands of dimensions, which is common in modern machine learning applications like natural language processing and computer vision.

The Curse of Dimensionality Strikes Again

The challenge stems from a phenomenon known as the "curse of dimensionality". In high-dimensional spaces, several issues arise that make exact nearest neighbor search impractical:

Computational Cost: The time complexity of a brute-force exact search is typically $O(N \times D)$ . Calculating the distance between two vectors of dimension $D$ takes $O(D)$ operations. Doing this for all $N$ vectors in the database results in a total cost proportional to the product of the dataset size and the dimensionality. For large $N$ and high $D$ , this linear scan is simply too slow for real-time applications demanding low latency responses. Consider a database with 10 million vectors ( $N=10^7$ ), each with 768 dimensions ( $D=768$ ). A single exact search requires roughly $7.68 \times 10^9$ floating-point operations just for the distance calculations, not including sorting or data retrieval overhead.

As the number of vectors increases, the computation time for an exact search grows linearly (assuming fixed dimensionality).

Inefficiency of Traditional Indexing: Spatial indexing structures like k-d trees or R-trees, which work well in low-dimensional spaces (e.g., 2D or 3D geographic data), become inefficient as dimensionality increases. Their performance often degrades to be no better, or even worse, than a linear scan in high dimensions. The branching factor needed to effectively partition the space grows exponentially with dimension, making these structures impractical.
Distance Concentration: Counter-intuitively, in very high-dimensional spaces, the distances between most pairs of points tend to become very similar. The ratio between the distance to the nearest neighbor and the farthest neighbor approaches 1. This makes it inherently harder to distinguish between neighbors based solely on distance, although effective embeddings usually mitigate this issue by ensuring meaningful clustering in the vector space.

Why Approximation is Often Sufficient

Given these limitations, performing an exact nearest neighbor search for every query is frequently infeasible for large-scale, high-dimensional datasets common in vector databases. The latency would be unacceptable for interactive applications like semantic search, recommendation systems, or image retrieval.

This is where Approximate Nearest Neighbor (ANN) search comes into play. ANN algorithms sacrifice the guarantee of finding the absolute mathematically nearest neighbors. Instead, they aim to find very close neighbors with high probability, while dramatically reducing the search time and computational resources required.

Think about a typical semantic search application. Does a user absolutely need the single document whose embedding vector has the mathematically smallest cosine distance to their query embedding? Usually not. They need a set of highly relevant documents. If an ANN algorithm returns 9 out of the top 10 exact matches, or perhaps the 2nd, 3rd, and 5th closest matches instead of the 1st, 2nd, and 3rd, the user experience is often indistinguishable, especially if the results are semantically very similar.

The fundamental idea behind ANN is to trade a small amount of accuracy (often measured by recall, the proportion of true nearest neighbors found) for significant gains in speed (lower latency) and efficiency (fewer computations, less memory). This trade-off is configurable, allowing developers to balance performance requirements against the desired level of accuracy for their specific application.

Because exact search doesn't scale, approximate methods have become the standard for efficient similarity search in high-dimensional vector databases. The following sections will explore the core concepts behind ANN and introduce several popular algorithms used to achieve this balance.