minimemory

Embedded vector database for Rust, JavaScript, and Python. Like SQLite for vectors.

493KB WASM | Zero deps | HNSW + BM25 + Filters | 5 quantization types | 314 Rust tests | 51 browser tests

What it is

minimemory is an embedded vector database that runs everywhere: native Rust, browser via WASM, Cloudflare Workers, Node.js. It combines vector similarity search, BM25 full-text search, and metadata filters in a single library with no external dependencies.

• npm package — npm install @rckflr/minimemory
• miniCMS — Full CMS built on minimemory, runs 100% in browser
• Cloudflare DO demo — Durable Objects benchmark vs D1

Install

Rust:

[dependencies]
minimemory = { git = "https://github.com/MauricioPerera/minimemory" }

JavaScript/TypeScript:

npm install @rckflr/minimemory

Quick Start

Rust:

use minimemory::{VectorDB, Config, Distance};

let db = VectorDB::new(Config::new(384))?;
db.insert("doc-1", &vec![0.1; 384], None)?;
let results = db.search(&vec![0.15; 384], 10)?;

JavaScript:

import init, { WasmVectorDB } from '@rckflr/minimemory';
await init();

const db = new WasmVectorDB(384, "cosine", "flat");
db.insert("doc-1", new Float32Array(384));
const results = JSON.parse(db.search(new Float32Array(384), 10));

Features

Quantization

// JavaScript
const db = WasmVectorDB.new_int3(384, "cosine", "flat"); // 10.7x compression

// Rust
let config = Config::new(384)
    .with_quantization(QuantizationType::Int3);

Filter Syntax

Rust (builder pattern):

use minimemory::Filter;

Filter::eq("category", "tech")
    .and(Filter::gt("score", 0.5f64))
    .or(Filter::regex("title", "^Rust"));

JavaScript (MongoDB-style JSON):

db.filter_search('{"category": "tech"}', 100);
db.filter_search('{"score": {"$gt": 0.5}}', 100);
db.filter_search('{"$and": [{"category": "tech"}, {"year": {"$gte": 2024}}]}', 100);
db.filter_search('{"title": {"$regex": "^Rust"}}', 100);

Pagination

// Rust
let page = db.list_documents(
    Some(Filter::eq("status", "active")),
    Some(OrderBy::desc("created_at")),
    10,  // limit
    0,   // offset
)?;
// page.items, page.total, page.has_more()

// JavaScript
const page = JSON.parse(db.list_documents(
    '{"status": "active"}',
    "created_at", true, 10, 0
));
// { items: [...], total: 42, has_more: true }

Persistence

Rust (.mmdb files):

db.save("my_database.mmdb")?;
let db = VectorDB::open("my_database.mmdb")?;

JavaScript (export/import):

const snapshot = db.export_snapshot();
localStorage.setItem("my-db", snapshot);

// Later...
db.import_snapshot(localStorage.getItem("my-db"));

Browser Usage

<script type="module">
import init, { WasmVectorDB } from './minimemory.js';
await init();

const db = new WasmVectorDB(384, "cosine", "flat");
db.insert_document("user-1", null, JSON.stringify({
    name: "Alice", role: "admin"
}));

const page = JSON.parse(db.list_documents(
    '{"role": "admin"}', "name", false, 10, 0
));
</script>

Cloudflare Workers

import init, { WasmVectorDB } from '@rckflr/minimemory';
import wasmModule from '@rckflr/minimemory/minimemory_bg.wasm';

export default {
    async fetch(request, env) {
        await init(wasmModule);
        const db = new WasmVectorDB(384, "cosine", "flat");
        // ... use db
    }
}

WASM API (35 methods)

Constructors

CRUD

insert, insert_with_metadata, insert_document, get, delete, update, update_with_metadata, contains, ids, len, is_empty, clear

Search

search, keyword_search, filter_search, search_with_filter, list_documents, search_paged

Persistence

export_snapshot, import_snapshot

Matryoshka

insert_auto, insert_auto_with_metadata, search_auto, update_auto, update_auto_with_metadata

Benchmarks

Cloudflare Workers production (Durable Objects):

vs D1: minimemory 3x faster for vector search (50 docs benchmark).

Ecosystem

Architecture

minimemory (19,700 LOC Rust)
├── db.rs              — VectorDB main API
├── distance/          — Cosine, Euclidean, DotProduct, Manhattan (SIMD)
├── index/             — Flat, HNSW, IVF
├── quantization.rs    — None, Int8, Int3, Binary, Polar
├── query/             — Filters ($eq, $gt, $regex, $and, $or)
├── search/            — Hybrid search (BM25 + vector + RRF)
├── storage/           — Memory, Disk (.mmdb v3), format
├── reranker.rs        — Trait-based cross-encoder
├── agent_memory.rs    — Semantic + episodic + working memory
├── memory_traits.rs   — Domain-agnostic memory system
├── bindings/wasm.rs   — 35-method WASM API
└── types.rs           — PagedResult, OrderBy, Config

License

MIT

Author

Mauricio Perera