Every vector database eventually runs into the same wall: the embeddings don't fit in RAM, and the moment they spill to disk your search gets slow. Quantization is the standard escape — store a compressed copy of each vector, search that, and pay for the lost precision in recall. The whole game is the exchange rate. How much recall does a given amount of compression cost you?
For years the honest answer was: it depends on your embedding model, and you find out by trying — one reason choosing a vector database has always come bundled with choosing a compression strategy. Scalar quantization to int8 gives you 4× smaller vectors and usually near-ceiling recall — but "usually" hides the cases where a model's coordinate distribution doesn't sit nicely on the int8 grid and recall quietly sags. Go more aggressive — binary quantization, one bit per dimension, 32× smaller — and recall falls off a cliff that's steep enough that binary is really a "search the sketch, then rescore everything" strategy, not a standalone index.
Qdrant 1.18 shipped a method that moves that exchange rate, and the interesting part is how it moves it. TurboQuant comes from a Google Research paper published at ICLR 2026, and its one real idea is to do something to the vector before compressing it.
The trick is the rotation, not the bits#
Take a vector and apply a fast Hadamard rotation. Nothing is lost — it's a rotation, fully invertible — but the coordinates come out the other side with their energy spread evenly across all dimensions. No single coordinate carries outsized magnitude anymore.
That sounds cosmetic. It's the whole thing. A coarse quantizer — say, four bits, sixteen levels per coordinate — does its worst work when a few dimensions dominate, because it wastes its limited levels trying to represent those outliers and starves everything else. Real embeddings are exactly that lopsided, and every model is lopsided in its own way, which is why quantization recall has always been model-dependent. Rotate first and the lopsidedness disappears. The coordinates become statistically interchangeable, so a single uniform quantizer works about as well no matter which embedding model produced the vector.
The base algorithm is data-oblivious: no trained codebook, no per-dataset tuning. That's the property that lets one quantizer be a default instead of a knob.
That "no trained codebook" bit is what separates TurboQuant from product quantization, the other way people reach for aggressive compression. PQ learns a codebook from your data — powerful, but it's a training step you redo when the distribution shifts, and per the Qdrant issue tracking the feature, TurboQuant beat PQ on recall at every bit-width they tested while skipping the training entirely. Qdrant does add a light calibration pre-pass and a length-renormalization step it credits to RaBitQ, to close the gap between the paper's clean assumptions and messy production embeddings. But there's no per-dataset training loop.
The second half: only the storage is lossy#
The other design choice is asymmetry. TurboQuant compresses the stored vectors but scores the query in full precision. Quantization error enters on exactly one side of the dot product, never both, and that costs nothing extra at query time because you were going to hold the query vector in memory anyway.
Put the two together and the numbers get good. TurboQuant 4-bit is 8× smaller than float32 and lands within one to two points of scalar int8's recall — that's twice the compression at the same accuracy, which is enough to make it the sensible default. Push harder and it separates from the alternatives more, not less: at 2-bit it beats binary quantization by 11–15 points at the same 16× storage, and at 1-bit it beats plain binary by 9–21 points at the same 32×. The band where you previously had to choose between "int8, 4×" and "binary, falls apart" now has real options in it.
What it doesn't fix#
TurboQuant is not a way to throw your original vectors away. To reach top recall you still rescore — run the fast quantized search, then recompute similarities for the top candidates against the uncompressed vectors. Which means you keep the full-precision copies, typically on disk (on_disk), with the quantized index pinned in RAM (always_ram). The 8× or 16× is the size of the thing you keep hot, not your total storage. If you were hoping to delete the originals, that hope survives contact with neither TurboQuant nor any other quantizer.
So the headline isn't the compression ratio; other methods reach those ratios. It's that the rotation buys you those ratios without the recall cliff and without a per-model tuning ritual. The practical upshot for anyone running agent memory or RAG at scale: you can swap embedding models without re-deriving your quantization strategy, and you can turn the compression up a notch further than you used to before recall makes you stop. Set it to 4-bit, keep rescoring on, and the exchange rate is finally boring — which, for infrastructure, is the highest compliment there is.
