Vector Database Architecture

How Embeddings Work

An embedding model maps text (or images, audio) to a dense vector in ℝᵈ. Models like text-embedding-3-small, sentence-transformers/all-MiniLM-L6-v2, and OpenAI's CLIP produce vectors where semantic similarity ≈ cosine similarity:

cosine_sim(A, B) = (A · B) / (‖A‖ · ‖B‖)

Two sentences with similar meaning cluster together in the high-dimensional space even if they share no words. "How do I reset my password" and "How to recover account access" land near each other. "SQL injection attack" lands far away.

Cosine vs L2 vs Dot Product

ANN Index Algorithms Compared

HNSW — The Production Standard

HNSW (Malkov & Y Reshetov, 2016) builds a navigable small world graph across L layers. Layer 0 has all N vectors; each upper layer ℓ contains ~N·e^(−ℓ) vertices selected randomly. Long-range edges in upper layers skip vast distances; short-range edges in layer 0 provide precision. Search is greedy: start at entry point, examine ef candidates, move toward closest neighbor, repeat until convergence on layer 0.

IVF: Inverted File Index

IVF partitions vectors into k clusters (k-means on a subset). Each cluster has an inverted list of member vectors. Search restricts comparison to vectors in the nearest w clusters (probe depth). IVF alone is slower than HNSW but combines well with product quantization for memory-constrained deployments.

PQ: Product Quantization

Product quantization splits each d-dimensional vector into m subvectors of d/m dimensions, then runs k-means (typically k=256) on each subvector space independently. Each subvector is replaced by its centroid ID — a single byte. A 1536-d float32 vector (6 KB) becomes 1536/8 = 192 bytes: 32× compression. Search uses an asymmetric distance computation (ADC) to reconstruct approximate distances from quantized codes.

HNSW + PQ = Production Stack

Most production deployments combine HNSW (for topology search) with PQ (for storage compression) and a re-ranking pass (exact distance on top-100 candidates). This is exactly what Pinecone Serverless, Qdrant, and Weaviate do under the hood.

Storage Architecture: How the DB Is Built

Segments and Sharding

At write time, vectors arrive in batches and are written to a mutable segment (like ClickHouse's MergeTree). When a segment fills, it is sealed and its vectors are indexed with HNSW. Sealed segments are immutable — no more inserts or updates. This design allows concurrent reads during indexing, just like LSM-tree databases.

Filtering and Hybrid Search

Most production workloads require filtered search: "find similar vectors where category='docs' and date>'2026-01-01'". Naively applying filters post-search destroys recall. Modern vector DBs handle this via:

• Pre-filtering: Build a bitset of qualifying IDs before ANN search, intersect with candidates
• Payload index: Maintain a B-tree or inverted index on payload fields for fast filtering
• Hybrid search: Combine dense vector search with sparse BM25/keyword search using Reciprocal Rank Fusion (RRF)

Pinecone vs Weaviate vs Qdrant vs Milvus

RAG System Design Patterns

Chunking Strategies

How you split documents dramatically affects retrieval quality. Common approaches:

• Fixed-size (512 tokens): Simple, consistent, but can split sentences and lose context
• Recursive character split: Split on newlines, then sentences, preserving semantic units
• Semantic/chunking by embedding: Cluster sentences by embedding similarity, split at cluster boundaries
• Document-structure aware: Split on headers, paragraphs — preserve titles as metadata

Parent Document Retrieval

Store both small chunks (for precision retrieval) and their parent document (for full context). On retrieval, fetch the small chunk's nearest neighbors, then return the parent document for richer LLM context. This addresses the "missing surrounding context" problem.

Re-ranking

HNSW returns candidates in ~10ms but at 95% recall. A cross-encoder re-ranker (like cross-encoder/ms-marco-MiniLML-6-v2) scores each candidate against the query with full attention — O(N·d) instead of O(log N). Use it as a second-stage filter: HNSW → top-100 → cross-encoder → top-10 → LLM.

Quantization: Reducing Memory Footprint

Scalar Quantization (SQ8)

Each 32-bit float is linearly mapped to an 8-bit integer: int8 = round(float / scale). The scale factor (one per vector, or per block of 128–256 vectors) is stored separately. SQ8 achieves ~4× compression with <1% accuracy loss for cosine similarity.

Product Quantization (PQ)

Split the d-dimensional vector into m subvectors of d/m dimensions. Run k-means on each subvector space with k=256 centroids. Replace each subvector by its nearest centroid ID (1 byte). The centroid vectors (256 × d/m × 4 bytes each) are stored in a codebook. For d=768, m=8: each vector = 8 bytes + codebook ~8 KB per 256 vectors.

Binary Quantization (BQ)

Threshold each float at 0: bit=1 if positive else 0. Hamming distance (bit XOR + count) replaces cosine similarity. Achieves 32× compression. Works surprisingly well for nearest neighbor ranking on normalized embeddings.

Choosing Quantization