Vector Databases & Retrieval Architecture Cheat Sheet: Concepts, Indexing, Quantization & Selection

A Vector Database stores high-dimensional dense and sparse embeddings alongside metadata, enabling millisecond-scale Approximate Nearest Neighbor (ANN) similarity search as the core retrieval and memory layer for RAG, semantic search, and AI agents.

🔗 Related Cheat Sheets: LLM & AI Agent Concepts · Core AI Algorithms · PostgreSQL Commands · Redis Commands · MongoDB Commands

---

1. Core Concepts & Distance Metrics

1.1 Essential Terminology

1.2 Three Core Distance & Similarity Metrics

Cosine(u, v) = (u · v) / (‖u‖₂ · ‖v‖₂)
IP(u, v)     = u · v = ∑ᵢ (uᵢ × vᵢ)
L₂(u, v)     = √( ∑ᵢ (uᵢ − vᵢ)² )

---

2. ANN Index Algorithms & Vector Quantization

2.1 Vector Index Comparison

HNSW Core Tuning Parameters:

• M (max bidirectional links per node, typically 16–64): Higher M improves recall on high-dimensional data at the cost of RAM and build time.
• efConstruction (candidate list size during index build, typically 100–400): Affects build time only; higher values yield higher-quality graphs.
• efSearch (dynamic search beam width at query time, must be ≥ top_k): Only parameter tunable per query; increasing raises recall and lowers QPS.

2.2 Quantization & Memory Sizing

Reference baseline for 10 million × 1536-dimensional vectors (raw FP32):

Raw Vector Size ≈ N × D × 4 Bytes   (HNSW graph adjacency adds ~1.2×–1.5× overhead)

---

3. Tiered Comparison of Vector Databases & Search Engines

3.1 Dedicated Native Vector Databases

3.2 Vector Search Libraries (Not Full Databases)

3.3 Traditional Databases & Search Engine Extensions

3.4 Fully Managed Cloud Services

---

4. Filtering Strategies & Hybrid Search

4.1 Metadata Filtering Execution Modes

4.2 Reciprocal Rank Fusion (RRF)

When merging dense semantic retrieval and BM25 lexical retrieval, score scales differ across engines; RRF combines rankings directly without score calibration:

RRF_Score(d) = ∑_{r ∈ R} 1 / (k + rank_r(d))     (standard smoothing constant k = 60)

---

5. Production Snippets

5.1 pgvector Schema, HNSW Index & Iterative Scan (SQL)

-- 1. Enable extension and create table with half-precision vectors + full-text column
CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE documents (
    id BIGSERIAL PRIMARY KEY,
    tenant_id INT NOT NULL,
    content TEXT NOT NULL,
    embedding halfvec(1536),          -- float16 saves 50% memory vs float32
    fts tsvector GENERATED ALWAYS AS (to_tsvector('simple', content)) STORED
);

-- 2. Build Cosine HNSW index (M=16, ef_construction=128) and GIN full-text index
CREATE INDEX idx_docs_emb_hnsw ON documents
    USING hnsw (embedding halfvec_cosine_ops)
    WITH (m = 16, ef_construction = 128);

CREATE INDEX idx_docs_fts ON documents USING gin (fts);

-- 3. Tune ef_search and enable iterative scan (pgvector 0.8+) for filtered queries
SET hnsw.ef_search = 100;
SET hnsw.iterative_scan = relaxed_order;

SELECT id, content, 1 - (embedding <=> $1::halfvec) AS cosine_sim
FROM documents
WHERE tenant_id = 42
ORDER BY embedding <=> $1::halfvec
LIMIT 10;

pgvector Distance Operators: <-> Euclidean (L₂) · <=> Cosine distance (1 - cos) · <#> Negative Inner Product · <+> Manhattan (L₁).

5.2 Qdrant Collection, Binary Quantization & Payload Filtering (Python)

from qdrant_client import QdrantClient, models

client = QdrantClient(url="http://localhost:6333")

# Create collection with on-disk vectors and in-RAM binary quantization
client.create_collection(
    collection_name="knowledge_base",
    vectors_config=models.VectorParams(
        size=1536,
        distance=models.Distance.COSINE,
        on_disk=True,
    ),
    quantization_config=models.BinaryQuantization(
        binary=models.BinaryQuantizationConfig(always_ram=True)
    ),
)

# Index frequently filtered metadata fields for fast inline filtering
client.create_payload_index(
    collection_name="knowledge_base",
    field_name="tenant_id",
    field_schema=models.PayloadSchemaType.KEYWORD,
)

# Query with metadata filter + oversampled rescoring
hits = client.query_points(
    collection_name="knowledge_base",
    query=[0.012, -0.045, ...],  # 1536-dim query vector
    query_filter=models.Filter(
        must=[models.FieldCondition(key="tenant_id", match=models.MatchValue(value="org_a"))]
    ),
    search_params=models.SearchParams(
        quantization=models.QuantizationSearchParams(rescore=True, oversampling=3.0)
    ),
    limit=10,
).points