Knowledge Base

What is a Vector Database?

A vector database stores and retrieves data by meaning, not just keywords. It uses high-dimensional vectors (embeddings) to enable semantic search, recommendations, and AI applications like RAG—making it essential for modern AI systems.

Everything About Vector Databases

Vector databases are purpose-built to store, index, and query vector embeddings—numerical representations of data (text, images, audio) in high-dimensional space. Unlike traditional databases that match exact values or keywords, vector databases find items that are similar in meaning or structure using distance metrics like cosine similarity or Euclidean distance.

They power semantic search, retrieval-augmented generation (RAG), recommendation systems, anomaly detection, and more. This knowledge base walks you through concepts, how they work, popular tools, and practical use cases—from fundamentals to advanced topics.

Use the directory below to jump to any topic. Each lesson page goes deeper with clear explanations and examples.

Explore Topics

Click any topic to open its lesson page and learn more.

I

Basic Fundamentals

1 What is a vector in the context of machine learning? 2 Definition of a Vector Database vs. a Relational Database. 3 Why can't traditional SQL indexes (B-Trees) work for vectors? 4 What is "Unstructured Data" and why does it require VDBs? 5 The concept of "Embedding" simplified. 6 What is a "Dense Vector" vs. a "Sparse Vector"? 7 What is the "Latent Space"? 8 What is the "Curse of Dimensionality"? 9 Difference between Vector Search and Keyword Search (BM25). 10 What is Semantic Search? 11 High-level architecture of a Vector Database. 12 The role of a "Collection" or "Index" in a VDB. 13 What is a "Point" in a VDB? 14 The importance of IDs and Metadata. 15 What does "Nearest Neighbor" mean? 16 Exact vs. Approximate Nearest Neighbor (ANN) search. 17 Common use cases for VDBs (Recommendation, Chatbots). 18 What is a "Feature Vector"? 19 Difference between a Vector Library (Faiss) and a Vector Database (Pinecone/Milvus). 20 The lifecycle of a vector query.

II

Embeddings & Data Prep

21 How are embeddings generated for text (Transformers)? 22 How are embeddings generated for images (CNNs/ViTs)? 23 What is Multi-modal embedding (CLIP)? 24 How does chunking strategy affect vector quality? 25 Overlapping chunks vs. fixed-size chunks. 26 Normalizing vectors: Why is it necessary? 27 Fixed-length vs. Variable-length embeddings. 28 The impact of embedding model dimensionality on VDB performance. 29 Re-ranking: Why do we do it after the initial search? 30 Fine-tuning embedding models for specific domains. 31 Handling out-of-vocabulary (OOV) terms in embeddings. 32 The role of tokenization in vectorization. 33 How to handle "Cold Start" problems with embeddings. 34 Storing raw data vs. storing only vectors. 35 Privacy concerns: Can you reconstruct data from a vector? 36 Dimensionality reduction techniques (PCA, t-SNE) for visualization. 37 Choosing the right embedding model for your VDB. 38 Batching embeddings for ingestion. 39 Handling updates to the embedding model (Version drift). 40 Cross-encoders vs. Bi-encoders.

III

Similarity Metrics (Mathematical Foundations)

41 Euclidean Distance (L2) explained. 42 Cosine Similarity explained. 43 Inner Product (Dot Product) explained. 44 Manhattan Distance (L1). 45 Hamming Distance for binary vectors. 46 Jaccard Similarity for sparse vectors. 47 When to use L2 vs. Cosine Similarity? 48 The relationship between Dot Product and Cosine Similarity on normalized vectors. 49 Minkowski Distance. 50 Mahalanobis Distance. 51 Angular Distance vs. Cosine Similarity. 52 Why does Cosine Similarity ignore magnitude? 53 Computation overhead of different distance metrics. 54 Hardware acceleration (SIMD) for distance calculations. 55 Impact of distance metrics on recall. 56 Thresholding: How to define a "good" match score. 57 Normalized vs. Unnormalized distance scores. 58 Handling negative values in vector components. 59 Mathematical properties of a metric space. 60 Custom distance functions: Are they supported?

IV

Indexing Algorithms - HNSW

61 What is HNSW (Hierarchical Navigable Small World)? 62 The concept of "Small World" graphs. 63 What is a Skip List and how does HNSW use it? 64 Defining "M" (number of bi-directional links) in HNSW. 65 Defining "efConstruction" and its impact on build time. 66 Defining "efSearch" and its impact on query speed. 67 Memory consumption of HNSW indexes. 68 How does HNSW handle high-dimensional data? 69 Navigable Small World (NSW) vs. HNSW. 70 Incremental building of HNSW graphs. 71 Entry point selection in HNSW. 72 Pruning strategies in HNSW graphs. 73 Parallelizing HNSW index construction. 74 Limitations of graph-based indexes. 75 HNSW on disk vs. HNSW in RAM. 76 Updating a node in an HNSW graph. 77 Deleting a node in an HNSW graph (the "Orphan" problem). 78 The trade-off between Recall and Latency in HNSW. 79 How HNSW handles clusters of data. 80 Visualizing the layers of an HNSW index.

V

Indexing Algorithms - IVF & Quantization

81 What is IVF (Inverted File Index)? 82 The role of Voronoi cells in IVF. 83 K-means clustering for index centroids. 84 What is nlist (number of clusters)? 85 What is nprobe (number of clusters to search)? 86 Flat Indexing: When is Brute Force better? 87 Scalar Quantization (SQ): Moving from Float32 to INT8. 88 Product Quantization (PQ) explained. 89 How PQ compresses vectors into codes. 90 The concept of "Codebooks" in PQ. 91 Optimized Product Quantization (OPQ). 92 Locally Sensitive Hashing (LSH) for VDBs. 93 Random Projection (Johnson-Lindenstrauss lemma). 94 Binary Quantization (BQ) and its speed advantages. 95 Residual Quantization (RQ). 96 The trade-off between compression ratio and accuracy. 97 How quantization reduces memory footprint. 98 Combining IVF and PQ (IVFPQ). 99 Search space reduction techniques. 100 Tree-based indexing (e.g., Annoy). 101 Space-partitioning trees. 102 Comparing Graph-based vs. Cluster-based indexes. 103 GPU-accelerated indexing (Faiss-GPU). 104 Disk-ANN: How to run ANN on SSDs. 105 Vamana: The algorithm behind Disk-ANN.

VI

Database Internals & Storage

106 In-memory vs. On-disk Vector Databases. 107 Write-Ahead Logs (WAL) in VDBs. 108 The LSM-Tree (Log-Structured Merge-Tree) for metadata. 109 Immutable segments in VDB storage. 110 How compaction works in a vector database. 111 Tiered storage: Moving old vectors to S3. 112 Memory-mapped files (mmap) for vector storage. 113 Columnar storage for metadata. 114 How VDBs handle "Deletes" (Soft vs. Hard deletes). 115 Atomic updates in a VDB. 116 Snapshotting and Backup strategies. 117 Data persistence guarantees (ACID compliance in VDBs?). 118 Index persistence: Loading indexes from disk. 119 Cache management for vectors. 120 Overcoming RAM limitations for billion-scale vectors. 121 Storing "Payloads" (JSON) alongside vectors. 122 Compression algorithms for metadata (Zstd, Snappy). 123 The role of Protobuf or Arrow in VDB communication. 124 Handling high-frequency updates (Streaming ingestion). 125 Garbage collection of deleted vectors.

VII

Filtering & Querying

126 Metadata Filtering: The basics. 127 Pre-filtering vs. Post-filtering. 128 Why Pre-filtering is hard for ANN indexes. 129 Bitmaps and Bitsets for filtering. 130 "In-bitmap" filtering during graph traversal. 131 Boolean expressions in vector queries (AND, OR, NOT). 132 Range queries on metadata. 133 Hybrid Search: Combining Vector + Keyword Search. 134 Reciprocal Rank Fusion (RRF). 135 Weighting scores in Hybrid Search. 136 Multi-vector search (Per-document multiple vectors). 137 Pagination in ANN search (Why it's difficult). 138 Sorting by metadata vs. sorting by distance. 139 Namespaces and Partitioning. 140 Multi-tenant isolation in VDBs. 141 Filtering on dynamic metadata (Schemaless). 142 Full-text search integration within VDBs. 143 Geo-spatial filtering alongside vector search. 144 How to handle "Null" metadata values. 145 Querying with "Group By" equivalents.

VIII

Distributed Systems & Scaling

146 Sharding: How to split a billion vectors across nodes. 147 Sharding by ID vs. Sharding by Vector (Spatial sharding). 148 Replication for High Availability. 149 Consistency levels (Strong vs. Eventual) in VDBs. 150 Leaderless vs. Leader-based replication. 151 Horizontal vs. Vertical scaling of VDBs. 152 The "Coordinator" node's role in a distributed query. 153 Load balancing vector queries. 154 Managing "Hot Shards." 155 Cross-region replication. 156 Cloud-native architecture (Separation of Compute and Storage). 157 Auto-scaling triggers for VDBs. 158 Disaster recovery for a distributed VDB. 159 Handling "split-brain" in a VDB cluster. 160 Cost-optimization: Spot instances for vector indexing. 161 Distributed index building. 162 Raft/Paxos consensus in VDB metadata management. 163 Global secondary indexes for metadata. 164 Throttling and Rate-limiting. 165 The role of Kubernetes in deploying VDBs.

IX

Performance, Evaluation & Benchmarking

166 Measuring Recall@K. 167 Measuring Latency (p50, p99). 168 Throughput (Queries Per Second - QPS). 169 The Recall-Latency Trade-off curve. 170 Measuring Index Build Time. 171 Memory usage per million vectors. 172 Cost per query (CPQ). 173 Using the ANN-Benchmarks suite. 174 Real-time vs. Offline indexing performance. 175 Impact of CPU architecture (AVX-512, ARM Neon) on speed. 176 GPU vs. CPU for query serving. 177 Benchmarking different distance metrics. 178 How metadata cardinality affects query performance. 179 Stress testing a VDB. 180 Monitoring VDB health (Prometheus/Grafana metrics). 181 Profiling a slow vector query. 182 Impact of network latency on distributed VDBs. 183 Data drift detection. 184 Warm-up time for in-memory indexes. 185 Accuracy vs. Speed in quantization.

X

Ecosystem & Advanced Topics

186 The RAG (Retrieval-Augmented Generation) stack. 187 Vector Databases for LLM Caching (GPTCache). 188 Privacy-preserving vector search (Homomorphic encryption). 189 Self-supervised learning for better embeddings. 190 Role of VDBs in Autonomous Agents. 191 Using VDBs for Long-term Memory in AI. 192 Time-weighted vector search (Recency bias). 193 Federated search across multiple VDBs. 194 Open-source vs. Proprietary (Managed) VDBs. 195 The future of "Vector-native" hardware. 196 Combining Knowledge Graphs with Vector Databases. 197 Dynamic Indexing: Switching algorithms on the fly. 198 Role of VDBs in Anomaly Detection. 199 Ethics: Bias in embedding models and its propagation in VDBs. 200 The "Vector Database" vs. "Vector-capable Relational Database" debate.