# 介绍Turbovec：一个基于Google TurboQuant算法的Rust向量索引，支持Python绑定

- 来源：MarkTechPost（RSS）
- 作者：Asif Razzaq
- 发布时间：2026-05-21 05:42
- AIHOT 分数：65
- AIHOT 链接：https://aihot.virxact.com/items/cmperngt3008tslbg7d68cs7i
- 原文链接：https://www.marktechpost.com/2026/05/20/meet-turbovec-a-rust-vector-index-with-python-bindings-and-built-on-googles-turboquant-algorithm

## AI 摘要

Google Research的TurboQuant算法已通过Turbovec项目应用于向量搜索领域。该工具以Rust语言构建，提供Python绑定接口，可直接集成到RAG流水线中。Turbovec实现了16倍的向量压缩率，同时无需进行任何码本训练，显著降低了部署和使用门槛。

## 正文

Vector search underpins most retrieval-augmented generation (RAG) pipelines. At scale, it gets expensive. Storing 10 million document embeddings in float32 consumes 31 GB of RAM. For dev teams running local or on-premise inference, that number creates real constraints.

A new open-source library called turbovec addresses this directly. It is a vector index written in Rust with Python bindings. It is built on TurboQuant, a quantization algorithm from Google Research. The same 10-million-document corpus fits in 4 GB with turbovec. On ARM hardware, search speed beats FAISS IndexPQFastScan by 12–20%.

The TurboQuant Paper

TurboQuant was introduced by Google’s research team. The Google team proposes TurboQuant as a data-oblivious quantizer. It achieves near-optimal distortion rates across all bit-widths and dimensions. It requires zero training and zero passes over the data.

Most production-grade vector quantizers, including FAISS’s Product Quantization, requires a codebook training step. You must run k-means over a representative sample of your vectors before indexing begins. If your corpus grows or shifts, you may need to retrain and rebuild the index entirely. TurboQuant skips all of that. It uses an analytical property of rotated vectors instead of a data-dependent calibration.

How turbovec Quantizes Vectors

The quantization pipeline has four steps:

(1) Each vector is normalized. The length (norm) is stripped and stored as a single float. Every vector becomes a unit direction on a high-dimensional hypersphere.

(2) A random rotation is applied. All vectors are multiplied by the same random orthogonal matrix. After rotation, each coordinate independently follows a Beta distribution. In high dimensions, this converges to Gaussian N(0, 1/d). This holds for any input data — the rotation makes the coordinate distribution predictable.

(3) Lloyd-Max scalar quantization is applied. Because the distribution is known analytically, the optimal bucket boundaries and centroids can be precomputed from the math alone. For 2-bit quantization, that means 4 buckets per coordinate. For 4-bit, it means 16 buckets. No data passes are needed.

(4) The quantized coordinates are bit-packed into bytes. A 1536-dimensional vector shrinks from 6,144 bytes in FP32 to 384 bytes at 2-bit. That is a 16x compression ratio.

At search time, the query is rotated once into the same domain. Scoring happens directly against the codebook values. The scoring kernel uses SIMD intrinsics — NEON on ARM and AVX-512BW on modern x86, with an AVX2 fallback — with nibble-split lookup tables for throughput.

TurboQuant achieves distortion within approximately 2.7x of the information-theoretic Shannon lower bound.

Recall and Speed: The Numbers

All benchmarks use 100K vectors, 1,000 queries, k=64, and report the median of 5 runs.

For recall, turbovec compares against FAISS IndexPQ (LUT256, nbits=8, float32 LUT). This is a strong baseline: FAISS uses a higher-precision LUT at scoring time and k-means++ for codebook training. Despite this, TurboQuant and FAISS are within 0–1 point at R@1 for OpenAI embeddings at d=1536 and d=3072. Both converge to 1.0 recall by k=4–8. GloVe at d=200 is harder. At that dimension, TurboQuant trails FAISS by 3–6 points at R@1, closing by k≈16–32.

On speed, ARM results (Apple M3 Max) show turbovec beating FAISS IndexPQFastScan by 12–20% across every configuration. On x86 (Intel Xeon Platinum 8481C / Sapphire Rapids, 8 vCPUs), turbovec wins every 4-bit configuration by 1–6%. It runs within ~1% of FAISS on 2-bit single-threaded. Two configurations sit slightly behind FAISS: 2-bit multi-threaded at d=1536 and d=3072. There, the inner accumulate loop is too short for unrolling amortization. FAISS’s AVX-512 VBMI path holds the edge in those two cases (2–4%).

Python API

Installation is a single command: pip install turbovec. The primary class is TurboQuantIndex, initialized with a dimension and bit width.

Copy CodeCopiedUse a different Browser

from turbovec import TurboQuantIndex

index = TurboQuantIndex(dim=1536, bit_width=4) index.add(vectors) scores, indices = index.search(query, k=10) index.write("my_index.tq")

A second class, IdMapIndex, supports stable external uint64 IDs that survive deletes. Removal is O(1) by ID. This is useful for document stores where vectors are frequently updated or deleted.

turbovec integrates with LangChain (pip install turbovec[langchain]), LlamaIndex (pip install turbovec[llama-index]), and Haystack (pip install turbovec[haystack]). The Rust crate is available via cargo add turbovec.

Marktechpost’s Visual Explainer

turbovec

How to Use turbovec

TurboQuant vector search — Rust + Python

01 / 07

Overview

What is turbovec?

turbovec is a vector index written in Rust with Python bindings. It is built on Google Research’s TurboQuant algorithm — a data-oblivious quantizer that requires zero codebook training. A 10 million document corpus that occupies 31 GB as float32 fits in 4 GB with turbovec.

16x compression at 2-bit

Beats FAISS on ARM by 12–20%

Fully local — no data egress

MIT licensed

Guide created by Marktechpost — AI & ML Research News

Step 1

Installation

Install the Python package from PyPI with a single command. For Rust, add the crate via Cargo.

terminal copy

# Python pip install turbovec

# Rust cargo add turbovec

Note: To build from source, install maturin then run maturin build –release inside the turbovec-python/ directory. For Rust, run cargo build –release.

Guide created by Marktechpost — AI & ML Research News

Step 2

Basic Usage — TurboQuantIndex

TurboQuantIndex is the primary class. Initialize it with a vector dim and a bit_width of 2 or 4. Vectors are indexed immediately on add() — no training step required.

python copy

from turbovec import TurboQuantIndex

index = TurboQuantIndex(dim=1536, bit_width=4)

# Add vectors (numpy float32 array, shape [n, dim]) index.add(vectors) index.add(more_vectors) # incremental adds are fine

# Search: returns top-k scores and positional indices scores, indices = index.search(query, k=10)

Guide created by Marktechpost — AI & ML Research News

Step 3

Stable IDs — IdMapIndex

Use IdMapIndex when you need external uint64 IDs that survive deletes. Removal is O(1) by ID — useful for document stores where vectors change over time.

python copy

import numpy as np from turbovec import IdMapIndex

index = IdMapIndex(dim=1536, bit_width=4)

# Map vectors to your own uint64 external IDs index.add_with_ids(vectors, np.array([1001, 1002, 1003], dtype=np.uint64))

# Search returns your external IDs, not positional indices scores, ids = index.search(query, k=10)

# O(1) delete by external ID\nindex.remove(1002)

Guide created by Marktechpost — AI & ML Research News

Step 4

Save & Load an Index

Both index types support persistent storage. TurboQuantIndex writes to .tq files. IdMapIndex writes to .tvim files.

python copy

from turbovec import TurboQuantIndex, IdMapIndex

# TurboQuantIndex —> .tq index.write("my_index.tq") loaded = TurboQuantIndex.load("my_index.tq")

# IdMapIndex —> .tvim index.write("my_index.tvim") loaded = IdMapIndex.load("my_index.tvim")

Guide created by Marktechpost — AI & ML Research News

Step 5

Framework Integrations

turbovec ships optional extras for LangChain, LlamaIndex, and Haystack. Install the extra that matches your stack.

terminal copy

# LangChain pip install turbovec[langchain]

# LlamaIndex pip install turbovec[llama-index]

# Haystack pip install turbovec[haystack]

Tip: Each integration plugs turbovec in as a drop-in vector store. See docs/integrations/ in the repo for full usage examples with each framework.

Guide created by Marktechpost — AI & ML Research News

Step 6

Using turbovec in Rust

The Rust API mirrors the Python API. Both TurboQuantIndex and IdMapIndex are available. All x86_64 builds target AVX2 as baseline; AVX-512 is enabled at runtime via feature detection.

rust copy

use turbovec::TurboQuantIndex;

let mut index = TurboQuantIndex::new(1536, 4); index.add(&vectors);

let results = index.search(&queries, 10);

index.write("index.tv").unwrap(); let loaded = TurboQuantIndex::load("index.tv").unwrap();

Full API: docs/api.md

github.com/RyanCodrai/turbovec

Guide created by Marktechpost — AI & ML Research News

← Prev

Next →

Key Takeaways

No codebook training. turbovec indexes vectors instantly — no k-means, no rebuilds as the corpus grows.

16x compression. A 1536-dim float32 vector shrinks from 6,144 bytes to 384 bytes at 2-bit quantization.

Faster than FAISS on ARM. turbovec beats FAISS IndexPQFastScan by 12–20% on ARM across every configuration.

Near-optimal distortion. TurboQuant achieves distortion within ~2.7x of the Shannon lower bound — provably near the theoretical limit.

Fully local. No managed service, no data egress — pairs with any open-source embedding model for an air-gapped RAG stack.

Check out the Repo here. Also, feel free to follow us on Twitter and don’t forget to join our 150k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.

Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us

The post Meet Turbovec: A Rust Vector Index with Python Bindings, and Built on Google’s TurboQuant Algorithm appeared first on MarkTechPost.