Vector Index

Unlike B-trees or inverted indexes that organize one-dimensional scalar values, a vector index structures data in a high-dimensional embedding space (typically 768 to 4096 dimensions). It partitions this space using graph-based structures like Hierarchical Navigable Small Worlds (HNSW) or clustering algorithms like Inverted File Index (IVF). The goal is to group semantically similar vectors into proximal regions, enabling the search algorithm to ignore vast irrelevant swaths of the dataset during query time.

Exact nearest neighbor search in high-dimensional spaces suffers from the curse of dimensionality, making brute-force linear scans computationally prohibitive. A vector index implements Approximate Nearest Neighbor (ANN) algorithms that trade a marginal, tunable loss in recall for massive gains in speed. By traversing a navigable graph or probing specific clusters, the index retrieves results in logarithmic or sub-linear time complexity, often returning 99% relevant neighbors while scanning less than 1% of the total dataset.

The index is fundamentally bound to a specific similarity metric that defines the 'distance' between vectors. While Cosine Similarity is standard for text embeddings due to its magnitude-invariance, indexes are often optimized for specific metrics:

• Euclidean Distance (L2): Sensitive to magnitude, used in visual feature matching.
• Inner Product: Used when vectors are not normalized, common in recommendation systems.
• Manhattan Distance (L1): Used in sparse high-dimensional grids. The choice of metric dictates the geometric partitioning strategy of the index.

A production-grade vector index functions as a dual-purpose database, combining vector search with strict metadata filtering. This allows for pre-filtering (reducing the search space by applying a scalar WHERE clause before the ANN search) or post-filtering (applying filters after the ANN search). Advanced indexes support multi-tenancy via partition keys, ensuring that a query for 'Q3 financial reports' only scans vectors belonging to the finance department, enforcing strict access control and reducing noise.

Static indexes require a full rebuild to incorporate new data, a non-starter for dynamic enterprise pipelines. A robust vector index supports CRUD operations (Create, Read, Update, Delete) without requiring a complete re-indexing. It manages tombstones for deleted vectors and handles upserts (insert or update) seamlessly. This is achieved through append-only log structures or mutable graph layers that allow new nodes to be inserted into the navigable network without degrading the search performance of the existing structure.

To handle billion-scale datasets that exceed available RAM, a vector index utilizes memory-mapped file I/O and quantization techniques. Algorithms like Product Quantization (PQ) compress the original high-dimensional vectors into compact codes that fit in CPU cache, while DiskANN designs graph layouts specifically to minimize random disk seeks. This architecture ensures that the index maintains low-latency query performance even when the raw vector data resides entirely on high-speed NVMe solid-state storage.

The algorithmic foundation of modern vector indexes. ANN algorithms trade a small, controlled loss in recall for orders-of-magnitude speed improvements over exact k-NN search.

• HNSW: Builds a multi-layered navigable graph for logarithmic-time traversal.
• IVF: Clusters vectors and searches only the nearest partitions.
• PQ (Product Quantization): Compresses vectors to reduce memory footprint and accelerate distance computations.

Without ANN, similarity search over billion-scale vector collections would be computationally infeasible for real-time applications.

The standard distance metric used within a vector index to determine semantic relatedness. It measures the cosine of the angle between two embedding vectors, ignoring magnitude differences.

• A score of 1.0 indicates identical direction (semantic equivalence).
• A score of 0.0 indicates orthogonal vectors (no semantic overlap).
• A score of -1.0 indicates opposite direction (semantic opposition).

Cosine similarity is preferred over Euclidean distance in high-dimensional spaces because it normalizes for vector length, focusing purely on directional alignment of semantic features.

The fixed-length output of an embedding model that defines the capacity and cost profile of a vector index.

• Low dimensions (384-512): Faster search, lower memory, suitable for simple semantic matching.
• High dimensions (1024-4096): Capture nuanced semantic features but increase index size and query latency linearly.

Common model dimensions include OpenAI text-embedding-3-small (1536), text-embedding-3-large (3072), and all-MiniLM-L6-v2 (384). The dimension is fixed at index creation and cannot be changed without full re-indexing.

The mechanism that combines vector similarity with structured predicates to narrow search scope before or after ANN retrieval.

• Pre-filtering: Applies strict boolean conditions (e.g., date > 2024-01-01) before vector search, guaranteeing results match filters but risking empty sets.
• Post-filtering: Retrieves top-k vectors by similarity, then discards non-matching results, ensuring results but potentially returning fewer than k.

Effective metadata filtering requires a vector database that supports hybrid scalar-vector indexes to avoid the performance pitfalls of naive filtering approaches.

A strategy for maintaining a vector index without costly full rebuilds. Instead of re-indexing the entire corpus, only new, updated, or deleted vectors are processed.

• Insert: New document chunks are embedded and added to the index structure.
• Update: Existing vectors are replaced with re-embedded versions of modified documents.
• Delete: Vectors are removed via ID-based tombstoning.

Graph-based indexes like HNSW support true incremental inserts, while IVF-based indexes may require periodic re-clustering to maintain recall as data distributions shift.

A retrieval strategy that fuses results from a dense vector index and a sparse inverted index (BM25) to maximize both semantic recall and keyword precision.

• Dense component: Captures conceptual similarity via vector proximity.
• Sparse component: Matches exact terminology, codes, or rare entities that embeddings may miss.

Fusion is typically performed via reciprocal rank fusion (RRF) or score-based linear combination. Hybrid search is critical for enterprise domains where exact part numbers, legal citations, or product SKUs must be matched precisely.