Open-source toolkit shrinks embeddings up to 42x while keeping recall high.

Introducing TurboQuant Pro, an open-source vector compression toolkit designed to significantly reduce the size of high-dimensional embeddings by 5-42 times while maintaining exceptional recall rates.

April 9, 20263 min readMachine Learning

The numbers in this post deserve a second look, not because they're flashy, but because they're honest. A 42x compression ratio with 0.93 cosine similarity isn't magic, and it isn't hype, it's the result of pairing a well-known rotation trick with scalar quantization and then measuring it against 2.4 million real embeddings. That's the kind of work that moves the needle, because it gives engineers a practical map instead of a promise. The table alone is worth the read: it tells you exactly when to reach for the clever solution (KV cache, high compression, tight quality budget) and when to walk past it. For most RAG pipelines, the authors say, a simple int8 quantization gets you 4x compression at 0.999 cosine similarity with three lines of NumPy. That's not a compromise. That's a gift.

What makes this post stand out is the discipline underneath the engineering. The team didn't just throw a model at the wall and report a single number. They benchmarked six methods on real BGE-M3 embeddings pulled from a genuinely interesting corpus, ancient Greek philosophy, Talmud, Pali Canon, Sanskrit, Old Norse, and Reddit. That's not a stunt. It's a signal that the results generalize across domains and languages, which is more than most vector compression papers can claim. And they're honest about the tradeoffs. TurboQuant's rotation trick is only worth the complexity when you need the last bit of recall at high compression, particularly for long-context KV cache. For everything else, simpler wins. That kind of clarity is rare in a field that rewards obscurity.

There's also a deeper point here about how we should think about embeddings and memory. Vector databases are eating RAM, and most teams respond by buying bigger machines or sharding earlier than they should. This work offers a third path: store less, store it smartly, and keep the quality you actually need. The pgvector bytea integration is particularly practical, because it means you can get 10x compression without migrating off your current stack. That's not a revolution. It's an upgrade path, and it's available today with `pip install turboquant-pro`.

The honest takeaway is this: you don't need to wait for a breakthrough to fix your embedding storage problem. Start with int8. If your embedding model supports Matryoshka truncation, slice and quantize. Measure your recall, not your enthusiasm. And when you genuinely need to push past 10x, TurboQuant's approach is a solid, well-tested option, not because it's fancy, but because it's been benchmarked against the alternatives on data that looks like yours. That's the kind of confidence you can build on.

From Machine Learning

TL;DR: We built an open-source toolkit that compresses high-dimensional vectors (embeddings, KV cache, anything in pgvector/FAISS) by 5-42x while maintaining 0.95+ cosine similarity. Benchmarked 6 methods on 2.4M real embeddings. MIT licensed.
GitHub: https://github.com/ahb-sjsu/turboquant-pro Install: pip install turboquant-pro

Read the original at Machine Learning

Briefing

Source: Machine Learning
Published: April 9, 2026

Turbocharge Your Vector Database with One Autotune Command
We just shipped an autotune CLI for turboquant-pro — it connects to your PostgreSQL database, samples embeddings, sweeps 12 compression configurations, and tells you exactly which one to use. bash turboquant-pro autotune \ --source "dbname=mydb user=me" \ --table chunks --column embedding \ --min-recall 0.95 10 seconds later: ``` Evaluating 12 configurations... Config Ratio Cosine Recall Var% Time PCA-128 + TQ2 113.8x 0.9237 78.7% 79.9% 2.2s PCA-128 + TQ3 78.8x 0.9390 84.0% 79.9% 0.6s PCA-256 + TQ3 41.0x 0.9700 92.0% 92.3% 0.7s PCA-384 + TQ3 27.7x 0.9823 93.7% 97.3% 0.7s PCA-384 + TQ4 20.9x 0.9906 96.0% 97.3% 0.6s PCA-512 + TQ4 15.8x 0.9949 96.3% 99.0% 0.6s Recommendation (min recall >= 95%): PCA-384 + TQ4: 20.9x compression Cosine similarity: 0.9906 Recall@10: 96.0% Storage: 758 MB -> 36 MB (saves 722 MB) ``` What it does The problem: you have a pgvector database with millions of embeddings. You want to compress them. But which configuration? PCA to how many dims? 2-bit, 3-bit, or 4-bit quantization? The quality/compression tradeoff depends on your specific data. Autotune answers this in ~10 seconds: Samples N embeddings from your table (default 5K, we used 2K here) Tries all 12 combinations of PCA dims (128, 256, 384, 512) x bit widths (2, 3, 4) Measures cosine similarity preservation and recall@10 for each Identifies the Pareto-optimal frontier Recommends the highest compression that meets your recall threshold Prints copy-paste code Real results on 194K production embeddings We ran this on a production RAG system (194K BGE-M3 1024-dim embeddings from 33 code repos): If you need 95%+ recall: PCA-384 + TQ4 gives you 20.9x compression at 0.991 cosine and 96.0% recall. Your 758 MB shrinks to 36 MB. If you can tolerate 84% recall: PCA-128 + TQ3 gives you 78.8x compression at 0.939 cosine. 758 MB becomes 10 MB. That's your entire corpus fitting in L3 cache. If you want maximum compression: PCA-128 + TQ2 hits 113.8x — nearly two orders of magnitude. Cosine still at 0.924. The whole sweep took 10.8 seconds on CPU. No GPU needed. How it works under the hood PCA-Matryoshka (our IEEE TAI submission) is a training-free technique: fit PCA once on a sample, rotate all vectors so truncation works, then quantize to 2-4 bits via TurboQuant scalar quantization. The "autotune" part is just sweeping the configuration space and measuring quality on your actual data. The key insight from our 15-method benchmark: PCA-Matryoshka + TurboQuant strictly dominates both binary quantization and product quantization across the practical compression range. Autotune finds exactly where on that frontier your data lives. Install & use ```bash pip install turboquant-pro[pgvector] turboquant-pro autotune \ --source "dbname=mydb user=me" \ --table my_embeddings \ --column embedding_vector \ --min-recall 0.95 \ --output results.json ``` Options: --sample-size, --pca-dims, --bits, --queries, --top-k. Full results saved as JSON for programmatic use. ```python After autotune recommends PCA-384 + TQ4: from turboquant_pro import PCAMatryoshka, PCAMatryoshkaPipeline, TurboQuantPGVector pca = PCAMatryoshka(input_dim=1024, output_dim=384) pca.fit(sample_embeddings) tq = TurboQuantPGVector(dim=384, bits=4) pipeline = PCAMatryoshkaPipeline(pca, tq) compressed = pipeline.compress(embedding) # 4096 bytes -> 195 bytes ``` GitHub: https://github.com/ahb-sjsu/turboquant-pro PyPI: pip install turboquant-pro Paper: IEEE TAI submission (PCA-Matryoshka: 15-method compression benchmark) License MIT submitted by /u/ahbond [link] [comments]