pgvector compression benchmarks show 31x reduction on OpenAI embeddings

Ahmad Shawar benchmarks pgvector compression codecs including halfvec, RaBitQ, and TurboQuant on OpenAI ada-002 vectors, demonstrating 31x memory savings with 0.999 recall via 1-bit quantization and top-100 reranking.

The answer up front

Teams scaling RAG vector storage on Postgres can cut memory footprints immediately without sacrificing retrieval precision. For OpenAI ada-002 embeddings, switching to halfvec drops index size by 2x with zero operational friction and 0.999 Recall@10. For large multi-gigabyte datasets, pairing 1-bit RaBitQ quantization with top-100 full-precision vector reranking yields 31x memory compression while preserving 0.999 Recall@10. Skip aggressive quantization if you use non-normalized vector distributions like SIFT or GloVe without prior testing.

Methodology

This review evaluates the pgvector compression benchmark published by developer Ahmad Shawar in October 2026 (source URL: https://dev.to/ahmad_shawar_de8d35d546cf/your-embeddings-are-32x-bigger-than-they-need-to-be-maybe-309h). The published dataset tests 100,000 OpenAI ada-002 embeddings (1,536 dimensions at 6,144 bytes per float32 vector) along with public comparative benchmarks on DBpedia, GloVe word vectors, and SIFT image descriptors.

This v0 review relies on author-published evaluation runs averaged across three random seeds on Postgres 18 using native pgvector options alongside Rust extension implementations of RaBitQ and TurboQuant. Independent hardware repros and long-term production query latency profiling under heavy concurrent write loads remain pending.

Measuring codec trade-offs on OpenAI vectors

Storing uncompressed float32 OpenAI ada-002 vectors costs 6,144 bytes per row. At 100 million documents, vectors demand 600 GB of storage before accounting for index overhead. In Shawar's published benchmark of 100,000 ada-002 vectors, native float16 storage (halfvec) halves memory usage to 3,072 bytes per vector with virtually no loss in recall (0.999 Recall@10).

Mid-tier quantization methods squeeze vectors further. RaBitQ 4-bit compresses vectors 8x down to 776 bytes per row with 0.972 Recall@10. Google Research's TurboQuant 4-bit yields 772 bytes per row at 0.953 Recall@10. At extreme 1-bit compression, standard binary_quantize reduces vectors 32x to 192 bytes but degrades Recall@10 to 0.707. RaBitQ 1-bit retains centering logic, achieving 0.834 Recall@10 at 200 bytes per row.

Combining two-phase search with quantized codes

The standout pattern in the benchmark data is two-phase retrieval. Searching 1-bit RaBitQ codes to collect the top 100 candidate matches, then reranking those 100 candidates against full-precision vectors, restores Recall@10 to 0.999. This approach reduces the searched index size by 31x (200 bytes searched per vector) while maintaining the accuracy of uncompressed float32 vectors.

TurboQuant offers a middle ground: 3-bit codes paired with 8-bit reranking compress memory by 11x (580 bytes searched) while yielding 0.996 Recall@10. However, these gains do not automatically transfer to all vector distributions. On SIFT image descriptors where values are predominantly positive, 1-bit sign-based quantization collapses Recall@10 down to 0.055. GloVe word vectors similarly suffer, dropping to 0.348 Recall@10 under binary quantization.

Pricing and availability snapshot

As of October 2026, pgvector, halfvec, and binary_quantize are open-source extensions available in standard Postgres deployments at zero licensing cost. Custom Rust implementations of RaBitQ and TurboQuant operate as open-source Postgres extension modules. Infrastructure cost savings derive directly from reduced RAM allocation in cloud database instances.

Verdict

If you host OpenAI ada-002 or similarly normalized LLM embeddings on pgvector, migrate to halfvec immediately for an effortless 50 percent RAM footprint reduction. If RAM limits threaten your budget at scale, implement 1-bit RaBitQ quantization with a top-100 full-precision reranking pass to achieve 31x memory compression with 0.999 Recall@10. Do not deploy 1-bit binary quantization without top-k reranking or on non-spherical embeddings like SIFT without empirical recall validation on your own dataset.

What we'd test next

We plan to benchmark index build times and query throughput (QPS at p95/p99 latency) across HNSW and IVFFlat configurations for RaBitQ versus halfvec in Postgres 18. We will also test whether higher-dimensional embeddings (such as 3,072-dimension text-embedding-3-large) exhibit identical recall resilience under 1-bit RaBitQ reranking under active write loads.

The investor read

Vector database inflation is a primary driver of unmanaged infrastructure spend for AI native applications. Ahmad Shawar's benchmarks highlight why specialized vector databases like Pinecone, Qdrant, and Milvus face growing churn pressure from Postgres pgvector. By implementing two-phase search with 1-bit RaBitQ and candidate reranking, technical teams can shrink vector RAM footprints 31x directly inside existing Postgres pipelines. This architectural reality limits the total addressable market for standalone vector database startups unless they offer proprietary GPU indexing or ultra-high scale filtering that Postgres cannot match. For investors, tooling companies building optimized quantization primitives and open-source Postgres extensions represent high-leverage infrastructure bets that reduce cloud COGS for AI startups.

Pull quote: “Searching 1-bit RaBitQ codes to collect the top 100 candidate matches, then reranking those 100 candidates against full-precision vectors, restores Recall@10 to 0.999.”