Vector compression is the trick that makes billion-scale retrieval affordable. Raw float32 embeddings are 4 bytes per dimension, so a 1024-dim vector is 4096 bytes. At a billion vectors, that is 4TB of RAM you almost certainly cannot afford. Compression schemes shrink each vector to tens of bytes, sometimes even single-digit bytes, at the price of a small recall hit.
**PQ (Product Quantization)** splits each vector into a small number of sub-vectors (say 16 chunks of 64 dimensions each). For each chunk position, k-means learns 256 centroid sub-vectors. Each chunk in your data is then stored as the 1-byte index of its closest centroid. A 1024-dim vector becomes 16 bytes.
**OPQ (Optimized PQ)** is the same idea with one extra step: before running PQ, learn a rotation matrix that spreads the variance evenly across all sub-spaces. Better balance, lower quantization error, same byte budget.
**SQ (Scalar Quantization)** is the simplest scheme. For each dimension independently, find the min and max across the corpus and divide the range into 256 (8-bit) or 16 (4-bit) uniform buckets. Store each dim as the bucket index. No training, no codebook.
**BQ (Binary Quantization)** is the most aggressive: store only the sign bit of each dimension. A 1024-dim vector becomes 128 bytes. Distance becomes Hamming distance, which on modern CPUs is just popcount(XOR), the fastest distance kernel in computing.
**Four compression schemes, two distinct mechanisms.**
`PQ` is the codebook scheme. Split each vector into `pq_m` sub-vectors of `d / pq_m` dimensions. Run k-means with 256 centers on each sub-space across the training corpus, producing one codebook per sub-space. Encode each sub-vector as the 1-byte index of its closest centroid. A 1024-dim float32 vector (4096 bytes) becomes `pq_m` bytes, typically 16 to 64. Distance to a query is computed via a lookup table per sub-space. Reference: Jegou, Douze, Schmid (2011).
`OPQ` is PQ with a pre-rotation. PQ's recall is sensitive to how variance is distributed across the sub-spaces; if one sub-space carries most of the variance, its centroids cannot represent the data well. OPQ learns an orthogonal rotation matrix R that decorrelates the dimensions before PQ encoding. The encoded form is `PQ(Rx)` instead of `PQ(x)`. Same byte budget, materially lower quantization error.
`SQ` is per-dimension uniform bucketing. For each dimension, take the min and max across the corpus, divide the range into 256 (int8) or 16 (int4) uniform bins. Store each dim as a bin index. No training, no codebook, instant build, and the distance computation can run in SIMD int8 arithmetic. Recall drop is small at int8, more noticeable at int4.
`BQ` is the extreme: 1 bit per dimension, the sign. A vector becomes a packed bitstring. Distance between two BQ vectors is `popcount(a XOR b)`, a single CPU instruction over each 64-bit word. The recall drop is real (vectors must be reasonably well-separated), but the speed and storage wins are enormous. Qdrant and Weaviate both ship it as a first-class option in 2026; some embedding models are even trained to be binary quantization friendly.
The pairing reflects the mechanism: PQ codebook lookup, OPQ rotate then codebook, SQ uniform bin per dim, BQ sign bit and popcount.
Quick reference
TL;DR
PQ splits the vector and looks up per-subspace codebook entries. OPQ rotates first, then runs PQ. SQ bucket-rounds each dim to 8 or 4 bits. BQ keeps only the sign bit per dim and uses popcount(XOR) as distance.
Imagine you have a thousand-number recipe card and you need to fit a million of them in a single shoebox. **PQ** chops the card into chunks and replaces each chunk with a tiny sticker from a sticker book the library invented. **OPQ** is the same trick, but first the cards are shuffled into a friendlier order so the stickers fit even better. **SQ** keeps the same layout but rounds every number to the nearest of 256 (or 16) shades of gray. **BQ** is the most brutal: it only records whether each number was positive or negative, packing the whole card into a bracelet of beads where each bead is just one bit. You lose detail, but comparing two bracelets is almost free.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Tiny corpora (under 100k vectors) on a single box Raw float32 already fits; quantization adds engineering cost and recall risk for no real memory benefit.
BQ on embeddings that were not trained for binary or are not zero-centered Recall can drop 20+ points; you will spend the savings re-running with PQ a quarter later.
PQ or OPQ on a fast-shifting corpus distribution Codebooks trained on the old distribution become stale; SQ avoids this because it retrains nothing.
Quick scan · 2–4 min
Everything important, quickly.
4 min: PQ codebook mechanism + OPQ rotation fix + SQ uniform bucketing + BQ sign bit and popcount + how each composes with IVF or HNSW + 2026 vendor defaults.
Side-by-side
Scheme
Bytes/vec (1024-dim)
Training needed
Distance kernel
Recall hit
PQ (pq_m=16)
16
Yes (codebook per subspace)
Sum of 16 table lookups
Moderate
OPQ (pq_m=16)
16
Yes (rotation + codebook)
Rotate, then PQ lookup
Lower than PQ at same size
SQ-int8
1024
No
int8 SIMD dot product
Tiny
BQ
128
No (assumes zero-centered)
popcount(XOR)
Largest of the four
Real-world examples
Real products, models, and research that use this idea.
1Faiss ships PQ, OPQ, SQ, and binary indexes as separate index factories. The 'IVF65536,OPQ32_64' string is the canonical billion-scale recipe at Meta and inside Milvus.
2Qdrant exposes scalar quantization (int8 and int4) and binary quantization as per-collection toggles in 2026; users rarely build PQ by hand because the SQ and BQ options cover most cost-sensitive cases.
3Cohere's binary embeddings (released 2024) are specifically trained so that BQ over them keeps recall above 0.95, making BQ a first-class production option, not a research curiosity.
4Pinecone's compressed serverless tier uses a PQ variant under the hood; users do not see the algorithm name but pay the lower per-vector storage rate.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhy does OPQ's learned rotation help at the same byte budget?
Sign in or go Pro to see the approach for this follow-up.
QHow would you decide pq_m for a 1024-dim corpus targeting recall 0.95?
Sign in or go Pro to see the approach for this follow-up.
QWhen does BQ beat SQ-int8 in production?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Treating SQ and PQ as the same family. SQ buckets each dimension independently; PQ groups dimensions into sub-spaces with a learned codebook per sub-space. Different objects, different recall behavior.