Data & documents

Itzma brings serverless vector search to object storage with Rust and Python

Itzma is a new library enabling vector search directly on object storage like S3, removing the need for dedicated vector database servers while supporting HNSW and SQ8 indexes.

Glass cube with glowing vectors above a cloud storage icon
Illustration generated for this article

A new open-source library called itzma has emerged to simplify vector search infrastructure by allowing developers to store and query vectors directly in object storage buckets. Released in mid-November 2026, this Rust library with Python bindings eliminates the need for dedicated vector database servers, enabling any process with bucket access to write and query data using standard cloud storage services.

What happened

The project, hosted on GitHub under the repository sergiommarcial/itzma, introduces a serverless approach to vector similarity search. Instead of managing complex clusters or specialized database instances, engineers can now treat their object storage buckets as the primary backend for vector operations. The system supports both dense and sparse vectors, offering flexibility for various machine learning workflows including retrieval-augmented generation (RAG) systems.

Itzma operates without a central coordinator, leader, or lock manager. This design choice allows multiple processes to interact with the same namespace concurrently, making it suitable for distributed applications where different services might need to read from or write to the same vector collection. The library handles concurrency through optimistic locking mechanisms and write-ahead logs, ensuring data consistency even when multiple writers are active simultaneously.

How it works

The core mechanism relies on treating object storage keys as a structured file system. Each namespace corresponds to a key prefix, and documents are stored as immutable segments named by the range of write-ahead log entries they contain. When a write occurs, it is first appended to a write-ahead log as a single object. Periodically, these log entries are compacted into larger, immutable segment files that hold the actual vector data and indexes.

For querying, itzma supports two primary index types: HNSW and SQ8. HNSW builds a graph over one-byte-per-dimension codes, which is efficient once cached but requires a larger initial read. SQ8 clusters vectors into partitions, reading only relevant sections during a query, which is better for uncached scenarios. The system also supports sparse vectors with inverted indexes, allowing for hybrid search strategies. All queries respect a read budget to prevent excessive costs from scanning large datasets, and the library ensures that readers always see a consistent view of the data by reading the latest manifest and any un-compacted log tail.

Key details

  • Storage Backend: Works with any service implementing the object_store interface, including S3, GCS, Azure, and local disk, though local disk lacks conditional update support for compaction.
  • Index Types: Supports HNSW for high recall with cached data and SQ8 for efficient uncached reads, with benchmarks showing recall@10 above 0.98 on standard datasets.
  • Concurrency: Uses put-if-absent for writes and compare-and-swap for manifest updates, retrying up to 32 times to handle contention without a central coordinator.
  • Data Formats: Vectors can be ingested via NumPy arrays, Arrow, Polars, or DuckDB tables, with automatic validation against a declared schema for dimensions and attribute types.
  • Maintenance: Requires manual or scheduled calls to compact, gc, and index functions, as the library does not run background tasks automatically, though a Python maintainer is available.
  • Safety Features: Includes read budgets to limit cost exposure, atomic batches to ensure all-or-nothing writes, and recovery tools to rebuild manifests from existing segments and logs.

Why it matters

For software engineers building AI products, the operational overhead of managing vector databases is a significant bottleneck. Traditional solutions require provisioning servers, managing scaling policies, and handling network latency between application services and the database. Itzma shifts this complexity to the object storage layer, which is already a staple in most cloud architectures. This means teams can leverage existing S3 or GCS buckets for vector storage, reducing infrastructure costs and simplifying deployment pipelines.

The serverless nature of itzma also aligns well with modern event-driven architectures. Since any process with bucket access can query the data, it enables decoupled microservices to share vector state without tight coupling to a specific database instance. This is particularly valuable for RAG systems where ingestion pipelines and query services may scale independently. However, developers must be aware that performance depends heavily on caching strategies and proper maintenance scheduling, as the library does not automate index building or garbage collection.

What you can do

  • Evaluate itzma for small to medium-scale RAG applications where managing a dedicated vector database cluster is overkill.
  • Implement a scheduled worker to run maintain functions regularly, ensuring segments are compacted and indexes are built to keep query performance high.
  • Use the CacheStore and DecodedCache features to optimize read performance, especially if your workload involves frequent queries on hot data.
  • Test concurrency limits in your specific environment, as the 32-retry limit for write contention may need adjustment for high-throughput ingestion pipelines.
  • Leverage the Python bindings to integrate with existing data processing stacks using Arrow or Polars for efficient batch uploads.
  • Monitor read budgets closely in production to avoid unexpected costs from large scans, adjusting the DEFAULT_READ_BUDGET as needed for your dataset size.
  • #vector search
  • #rust
  • #python
  • #object storage
  • #serverless
  • #rag

Tools from the Bytechap store

$89

DocBento

Self-hosted document management that reads every scan and answers with page citations.

Live demo

Keep reading

All stories