embedvec — High-Performance Embedded Vector Database

The fastest pure-Rust vector database — HNSW indexing, SIMD acceleration, E8 quantization, and flexible persistence (Sled, RocksDB, or PostgreSQL/pgvector).

Why embedvec Over the Competition?

Key Advantages

1. 10-100× Lower Latency — No network round-trips. embedvec runs in your process, not a separate server. Sub-millisecond queries are the norm, not the exception.

2. 6× Less Memory — E8 lattice quantization (from QuIP#/QTIP research) achieves ~1.25 bits/dimension with <5% recall loss. Store 1M vectors in 500MB instead of 3GB.

3. No Infrastructure — No Docker, no Kubernetes, no managed service bills. Just cargo add embedvec and you're done. Perfect for edge devices, mobile, WASM, and serverless.

4. Scale When Ready — Start embedded, then seamlessly migrate to PostgreSQL/pgvector for distributed deployments without changing your code.

5. True Rust Safety — No unsafe FFI, no C++ dependencies (unless you opt into RocksDB). Memory-safe, thread-safe, and panic-free.

When to Use embedvec

Why embedvec?

• Pure Rust — No C++ dependencies (unless using RocksDB/pgvector), safe and portable
• Blazing Fast — AVX2/FMA SIMD acceleration, optimized HNSW with O(1) lookups
• Memory Efficient — E8 quantization provides 4-6× compression with <5% recall loss
• Flexible Persistence — Sled (pure Rust), RocksDB (high perf), or PostgreSQL/pgvector (distributed)
• Production Ready — Async API, metadata filtering, batch operations

Benchmarks

768-dimensional vectors, 10k dataset, AVX2 enabled:

Run cargo bench to reproduce on your hardware.

Core Features

Quick Start — Rust

[dependencies]

embedvec = "0.5"

tokio = { version = "1.0", features = ["rt-multi-thread", "macros"] }

serde_json = "1.0"

use embedvec::{Distance, EmbedVec, FilterExpr, Quantization};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create in-memory index with E8 quantization
    let mut db = EmbedVec::builder()
        .dimension(768)
        .metric(Distance::Cosine)
        .m(32)                              // HNSW connections per layer
        .ef_construction(200)               // Build-time beam width
        .quantization(Quantization::e8_default())  // 4-6× memory savings
        .build()
        .await?;

    // Add vectors with metadata
    let vectors = vec![
        vec![0.1; 768],
        vec![0.2; 768],
    ];
    let payloads = vec![
        serde_json::json!({"doc_id": "123", "category": "finance", "timestamp": 1737400000}),
        serde_json::json!({"doc_id": "456", "category": "tech", "timestamp": 1737500000}),
    ];

    db.add_many(&vectors, payloads).await?;

    // Search with metadata filter
    let filter = FilterExpr::eq("category", "finance")
        .and(FilterExpr::gt("timestamp", 1730000000));

    let results = db.search(
        &vec![0.15; 768],  // query vector
        10,                 // k
        128,                // ef_search
        Some(filter)
    ).await?;

    for hit in results {
        println!("id: {}, score: {:.4}, payload: {:?}", hit.id, hit.score, hit.payload);
    }

    Ok(())
}

Quick Start — Python

pip install embedvec-py

import embedvec_py
import numpy as np

# Create database with E8 quantization
db = embedvec_py.EmbedVec(
    dim=768,
    metric="cosine",
    m=32,
    ef_construction=200,
    quantization="e8-10bit",  # or None, "e8-8bit", "e8-12bit"
    persist_path=None,         # or "/tmp/embedvec.db"
)

# Add vectors (numpy array or list-of-lists)
vectors = np.random.randn(50000, 768).tolist()
payloads = [{"doc_id": str(i), "tag": "news" if i % 3 == 0 else "blog"} 
            for i in range(50000)]

db.add_many(vectors, payloads)

# Search with filter
query = np.random.randn(768).tolist()
hits = db.search(
    query_vector=query,
    k=10,
    ef_search=128,
    filter={"tag": "news"}  # simple exact-match shorthand
)

for hit in hits:
    print(f"score: {hit['score']:.4f}  id: {hit['id']}  {hit['payload']}")

API Reference

EmbedVec Builder

EmbedVec::builder()
    .dimension(768)                    // Vector dimension (required)
    .metric(Distance::Cosine)          // Distance metric
    .m(32)                             // HNSW M parameter
    .ef_construction(200)              // HNSW build parameter
    .quantization(Quantization::None)  // Or E8 for compression
    .persistence("path/to/db")         // Optional disk persistence
    .build()
    .await?;

Core Operations

FilterExpr — Composable Filters

// Equality
FilterExpr::eq("category", "finance")

// Comparisons
FilterExpr::gt("timestamp", 1730000000)
FilterExpr::gte("score", 0.5)
FilterExpr::lt("price", 100)
FilterExpr::lte("count", 10)

// String operations
FilterExpr::contains("name", "test")
FilterExpr::starts_with("path", "/api")

// Membership
FilterExpr::in_values("status", vec!["active", "pending"])

// Existence
FilterExpr::exists("optional_field")

// Boolean composition
FilterExpr::eq("a", 1)
    .and(FilterExpr::eq("b", 2))
    .or(FilterExpr::not(FilterExpr::eq("c", 3)))

Quantization Modes

// No quantization (full f32)
Quantization::None

// E8 with Hadamard preprocessing (recommended)
Quantization::E8 {
    bits_per_block: 10,
    use_hadamard: true,
    random_seed: 0xcafef00d,
}

// Convenience constructor
Quantization::e8_default()  // 10-bit with Hadamard

E8 Lattice Quantization

embedvec implements state-of-the-art E8 lattice quantization based on QuIP#/NestQuant/QTIP research (2024-2025):

1. Hadamard Preprocessing: Fast Walsh-Hadamard transform + random signs makes coordinates more Gaussian/i.i.d.
2. Block-wise Quantization: Split vectors into 8D blocks, quantize each to nearest E8 lattice point
3. Asymmetric Search: Query remains FP32, database vectors decoded on-the-fly during HNSW traversal
4. Compact Storage: ~2-2.5 bits per dimension effective

Why E8?

The E8 lattice has exceptional packing density in 8 dimensions, providing better rate-distortion than scalar quantization or product quantization for normalized embeddings typical in LLM/RAG applications.

Performance

Measured Benchmarks (768-dim, 10k vectors, AVX2)

Projected Performance at Scale

Feature Flags

[dependencies]

embedvec = { version = "0.5", features = ["persistence-sled", "async"] }

Persistence Backends

embedvec supports three persistence backends:

Sled (Default)

Pure Rust embedded database. Good default for most use cases.

use embedvec::{EmbedVec, Distance, BackendConfig, BackendType};

// Simple path-based persistence (uses Sled)
let db = EmbedVec::with_persistence("/path/to/db", 768, Distance::Cosine, 32, 200).await?;

// Or via builder
let db = EmbedVec::builder()
    .dimension(768)
    .persistence("/path/to/db")
    .build()
    .await?;

RocksDB (Optional)

Higher performance LSM-tree database. Better for write-heavy workloads and large datasets.

[dependencies]

embedvec = { version = "0.5", features = ["persistence-rocksdb", "async"] }

use embedvec::{EmbedVec, Distance, BackendConfig, BackendType};

// Configure RocksDB backend
let config = BackendConfig::new("/path/to/db")
    .backend(BackendType::RocksDb)
    .cache_size(256 * 1024 * 1024);  // 256MB cache

let db = EmbedVec::with_backend(config, 768, Distance::Cosine, 32, 200).await?;

pgvector (PostgreSQL) — Scale to Billions

Native PostgreSQL vector search using the pgvector extension. Best for:

• Distributed deployments across multiple nodes
• Existing PostgreSQL infrastructure (no new services)
• SQL access to vectors alongside relational data
• Teams already familiar with PostgreSQL operations
• Scaling beyond 10M vectors with horizontal sharding

[dependencies]

embedvec = { version = "0.5", features = ["persistence-pgvector", "async"] }

Prerequisites: PostgreSQL 15+ with pgvector extension installed:

CREATE EXTENSION vector;

use embedvec::{BackendConfig, BackendType};
use embedvec::persistence::PgVectorBackend;

// Configure pgvector backend
let config = BackendConfig::pgvector(
    "postgresql://user:password@localhost/mydb",
    768  // vector dimension
)
.table_name("my_vectors")      // optional, default: "embedvec_vectors"
.index_type("hnsw");           // "hnsw" (default) or "ivfflat"

// Connect (auto-creates table and index)
let backend = PgVectorBackend::connect(&config).await?;

// Insert vectors with JSONB metadata
backend.insert_vector(
    "doc_123", 
    &embedding, 
    Some(json!({"category": "tech", "author": "alice"}))
).await?;

// Native vector search (executed in PostgreSQL)
let results = backend.search_vectors(&query, 10, Some(128)).await?;
for (id, external_id, similarity, metadata) in results {
    println!("{}: {} (score: {:.4})", id, external_id, similarity);
}

// Other operations
let count = backend.count().await?;
backend.delete_vector("doc_123").await?;
backend.clear().await?;

Why pgvector with embedvec?

pgvector features:

• HNSW indexes — Faster queries, tunable ef_search (default: 128)
• IVFFlat indexes — Better for bulk loading, lower memory
• Cosine similarity — <=> operator for normalized embeddings
• JSONB metadata — Query vectors with SQL WHERE clauses
• Auto-provisioning — Tables and indexes created on connect
• Connection pooling — Up to 10 concurrent connections via sqlx

Index comparison:

Testing

# Run all tests

cargo test


# Run with specific features

cargo test --features "persistence"


# Run benchmarks

cargo bench

Benchmarking

# Install criterion

cargo install cargo-criterion


# Run benchmarks

cargo criterion


# Memory profiling (requires jemalloc)

cargo bench --features "jemalloc"

Roadmap

• v0.5 (current): E8 quantization stable + persistence
• v0.6: Binary/PQ fallback, delete support, batch queries
• v0.7: LangChain/LlamaIndex official integration
• Future: Hybrid sparse-dense, full-text + vector

License

MIT OR Apache-2.0

Contributing

Contributions welcome! Please read CONTRIBUTING.md before submitting PRs.

Acknowledgments

• HNSW algorithm: Malkov & Yashunin (2016)
• E8 quantization: Inspired by QuIP#, NestQuant, QTIP (2024-2025)
• Rust ecosystem: serde, tokio, pyo3, sled

embedvec — The "SQLite of vector search" for Rust-first teams in 2026.