Qdrant Compresses Vectors 8x and Loses Only 1–2 pp of Search Recall
Vector databases store embeddings as heavy float32 values, and memory quickly becomes the main cost. Qdrant has added TurboQuant compression, which randomly rotates each vector and stores every number in 1–4 bits instead of 32. In 4-bit mode, you need 8 times less space, while search recall (the share of the correct neighbors found) trails SQ at 4x compression by only 1–2 pp. If you run SQ or BQ, test TurboQuant on a sample of your own data.
AI-processed from Qdrant Articles; edited by Hamidun News
If you run vector search in production, you know where the memory goes: to embeddings. By default, each number in a vector takes 32 bits (float32), and collections often hold millions of vectors. To save space, people compress them, but the stronger the compression, the more often search misses the right documents. The Qdrant team (authors Ivan Pleshkov and Jonas Schulz) has added a new compression method called TurboQuant and shown that it beats two older options either on memory or on quality.
What the options were and what was added
Previously, Qdrant offered two main paths. Scalar quantization (SQ) stores each number in one byte (int8): 4x compression, and on most embeddings the quality is nearly indistinguishable from float32. Binary quantization (BQ) stores 1, 1.5, or 2 bits per number, which compresses by about 32, 21, or 16 times. However, the results depend heavily on the embedding model: it works well on uniform, well-trained models.
TurboQuant adds four modes: 4 bits per number (8x compression), 2 bits (16x), 1.5 bits (about 21x), and 1 bit (32x). You enable it in the quantization_config block of the collection: choose the bit depth (bits2 and so on) and, if needed, pin the data in memory with the memory parameter. This parameter requires Qdrant 1.19; on version 1.18, you must omit it.
How it works in plain terms
Imagine a vector as a set of hundreds of numbers, where some coordinates vary widely and others are nearly zero. Rounding such numbers uniformly is inefficient. So the method first multiplies each vector by a random orthogonal matrix, rotating it in space. Distances and dot products stay the same, while the spread across coordinates evens out. After that, each number is rounded to the nearest value from a small ready-made table (the Lloyd–Max codebook), one table shared across all datasets. Nothing needs training, no calibration sample is required, and no separate tables need to be stored. Classic Product Quantization works differently: its codebook has to be trained on your data and shipped with the index.
Qdrant did not take the method as is. It combined ideas from TurboQuant and RaBitQ and added its own refinements:
- Length renormalization. Compressed vectors come out slightly shorter than the originals. Qdrant stores one coefficient per vector (the same 4 bytes already reserved for length) and multiplies by it when computing similarity.
- Per-coordinate calibration. The theory assumes vectors spread uniformly over a sphere, but real embeddings are not like that. So for each segment, a per-coordinate shift and scale are fitted once. The correction is applied on the query side, so storage does not grow and the distance kernel does not change. On perfectly uniform data, the result matches plain TurboQuant.
- Metrics. Cosine distance, dot product, and L2 are supported. The L1 metric is not supported: the rotation does not preserve the L1 norm, and for it the authors recommend staying with SQ.
Of the two variants in the original paper, Qdrant chose MSE. It lets you compare two compressed vectors directly (needed, for example, when building an HNSW graph) and maps well onto the integer instructions of AVX-VNNI, AVX-512, and NEON.
What the benchmarks showed and what to do
The team compared the methods on public embedding datasets (the full table covers ten). The results:
- 4 bits versus SQ. 8x compression instead of 4x. On most datasets, recall trails SQ by 1–2 pp (percentage points), and on some TurboQuant comes out ahead, because the int8 grid fits the distribution of those embeddings poorly.
- 2 bits versus BQ 2 bits. At the same 16x compression, TurboQuant leads by 11–15 pp on the four datasets shown and by 9–24 pp across all ten.
- 1 bit versus standard BQ. At the same 32x compression, the gain is 9–21 pp. This refers to the simple version of BQ, where both stored vectors and the query take 1 bit each. The version with an 8-bit query is covered separately in the article.
The authors' advice is straightforward. If you are on SQ, try 4-bit TurboQuant: you get half the memory at comparable recall. If you are on BQ, use TurboQuant at the same size, that is 2 bits instead of 2 or 1 instead of 1, and you will find more documents for the same gigabytes. Migration means changing the config and reindexing.
There are caveats too. The numbers come from Qdrant's own benchmarks, so first verify the method on a test sample of your data and your embedding model. If your search relies on the L1 metric, TurboQuant will not work for you. For everyone else, it is one of the cheapest ways to reduce memory costs without rewriting the application.
- Nov 21, 2026NAND flash for SSDs drops 19–32% in spot deals — drives could get cheaper
- Nov 21, 2026Unsloth Updates Compressed Qwen3.8-27B: Accuracy Up 5–10% at the Same Size
- Nov 21, 2026AI Writes Vulnerable Code in 44% of Tests: Positive Technologies Gives Agents a Scanner
- Nov 21, 2026Sber Releases a 14,990-Ruble Speaker with GigaChat That Understands Voice Without Internet
Key Questions Answered
What the options were and what was added?
Previously, Qdrant offered two main paths. Scalar quantization (SQ) stores each number in one byte (int8): 4x compression, and on most embeddings the quality is nearly indistinguishable from float32. Binary quantization (BQ) stores 1, 1.5, or 2 bits per number, which compresses by about 32, 21, or 16 times. However, the results depend heavily on the embedding model: it works well on uniform, well-trained models.
How it works in plain terms?
Imagine a vector as a set of hundreds of numbers, where some coordinates vary widely and others are nearly zero. Rounding such numbers uniformly is inefficient. So the method first multiplies each vector by a random orthogonal matrix, rotating it in space. Distances and dot products stay the same, while the spread across coordinates evens out. After that, each number is rounded to the nearest value from a small ready-made table (the Lloyd–Max codebook), one table shared across all datasets.
What the benchmarks showed and what to do?
The team compared the methods on public embedding datasets (the full table covers ten). The results: 4 bits versus SQ. 8x compression instead of 4x. On most datasets, recall trails SQ by 1–2 pp (percentage points), and on some TurboQuant comes out ahead, because the int8 grid fits the distribution of those embeddings poorly. 2 bits versus BQ 2 bits. At the same 16x compression, TurboQuant leads by 11–15 pp on the four datasets shown and by 9–24 pp across all ten. 1 bit versus standard BQ.
Test Frontier LLMs & Autonomous Agents in One Workspace
Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.
The AI world, distilled — once a week
Seven stories that actually mattered, hand-picked. No noise, no reposts, no press releases.
Done! Check your inbox for a confirmation.