Built in RustOpen Source

The embedded vector and document
database for on-device AI

Store JSON-like documents, run structured queries, and search vectors in one Rust engine. TalaDB runs entirely on-device across the browser, Node.js, and React Native — no database server or cloud API required.

Get Started Web Demo → Mobile Demo → GitHub

pnpm add taladb @taladb/web

app.ts
import { openDB } from 'taladb'
import { pipeline } from '@xenova/transformers'

// Open a persistent on-device database
const db = await openDB('myapp.db')
const articles = db.collection<Article>('articles')

// On-device embedding model — no API key
const embed = await pipeline('feature-extraction',
  'Xenova/all-MiniLM-L6-v2')

// Store a document with its vector embedding
await articles.createVectorIndex('embedding', { dimensions: 384 })
await articles.insert({
  title: 'Getting started with TalaDB',
  embedding: await embed(article.body),
})

// Filtered vector search — narrow, then rank
const results = await articles.findNearest(
  'embedding',
  await embed('how do I reset my password?'),
  5,
  { locale: 'en', published: true }
)
// [{ document: Article, score: 0.94 }, ...]

Everything you need. Nothing you don't.

A vector and document database in one embedded engine — browser, Node.js, and React Native.

On-Device Vector Search

Exact k-NN (cosine, dot, euclidean) with metadata pre-filtering, plus optional HNSW at scale — the filtered vector search cloud providers charge for, running entirely on device. No API key, no round-trip.

Hybrid Search (RAG-Ready)

Fuse BM25 keyword ranking with vector similarity via reciprocal rank fusion — so an exact SKU and a semantic paraphrase both surface from one query. The production RAG retrieval recipe, on-device.

MongoDB-like Query API

Familiar $eq, $gt, $in, $and, $or operators. Fully typed with TypeScript generics — field names and value types validated at compile time.

Live Queries

Subscribe to a filtered collection and receive a fresh snapshot on every write — no polling, no websockets, no infrastructure.

Encryption at Rest

Transparent AES-GCM-256 encryption. Keys derived via PBKDF2-HMAC-SHA256. Every value encrypted with a fresh random nonce — tamper-proof and crash-safe.

ACID Transactions

Powered by redb — a pure-Rust B-tree storage engine. Every write is atomic, consistent, isolated, and durable. Crash-safe out of the box.

Runs Everywhere

One Rust core compiles to browser WASM, a Node.js native module, and a React Native JSI HostObject. One API, zero platform branches in your app code.

Secondary Indexes

Type-safe B-tree indexes with O(log n) range scans. The query planner picks the best index automatically — no hints or query annotations needed.

Full-Text Search (BM25)

Relevance-ranked keyword search with searchText — the same BM25 model as Lucene and Elasticsearch — plus the boolean $contains filter. No external search engine required.

Multi-Tab Safe

The first browser tab owns the OPFS file; later tabs read a live copy and forward their writes to it. No duplicate engines, no lost updates, no lock errors — and db.isPrimary() tells you which tab owns the storage when work must run only once.

Aggregation Pipelines

MongoDB-style $match, $group, $sort, $skip, $limit, and $project stages with $sum, $avg, $min, $max accumulators — summaries computed inside the Rust engine, not by materialising every document in JavaScript.

Why not just use…?

Every alternative makes a trade-off TalaDB doesn't.

CapabilityTalaDBIndexedDBSQLite WASMDexie.jsPinecone / Qdrant
Document (JSON) storage✓✓~✓✓
MongoDB-style query DSL✓——~~
Aggregation pipeline ($group)✓—✓——
On-device vector search✓—~—✓
Filtered vector search✓———✓
TypeScript generics on queries✓——✓—
ACID transactions✓~✓~✓
Secondary B-tree indexes✓✓✓✓~
Full-text search (BM25)✓—~~~
Hybrid search (keyword + vector)✓———~
Live queries / subscriptions✓——~—
Encryption at rest✓—~—✓
Schema migrations✓——✓—
React Native (JSI)✓—✓——
Browser + OPFS persistence✓✓✓✓—
No cloud / no API key✓✓✓✓—
Rust core (no GC pauses)✓—~—✓
Compact WASM core (572 KB gzip)✓————

✓ supported  ·  ~ partial / limited  ·  — not supported

Built for AI that runs on the device

From AI-powered web apps to offline-first mobile — TalaDB fits where your data lives.

BrowserWASMOPFS

AI-Powered Web Apps

Pair TalaDB with on-device models (transformers.js, ONNX Web) to build semantic search, RAG pipelines, and AI assistants that run entirely in the browser.

  • Store document embeddings alongside metadata
  • Filtered search: filter by tag, rank by similarity
  • No API key, no rate limit, no data egress
BrowserNode.js

Offline-First SaaS

Build apps that work without a connection. TalaDB persists data to OPFS in the browser and redb on Node.js — sync to your backend whenever a connection is available.

  • ACID writes survive tab closes and crashes
  • HTTP push sync fires in the background
  • Live queries keep the UI reactive without polling
iOSAndroidJSI

React Native Mobile

The JSI HostObject gives you synchronous database access without bridges. Store user data, search history, and embeddings directly on the device.

  • Synchronous reads via JSI — no async overhead
  • Same TypeScript API as web and Node.js
  • AES-GCM-256 encryption for sensitive user data
Node.jsBun

CLI Tools & Scripts

Use TalaDB as a fast, embedded document store for CLI tools, build pipelines, and data transformation scripts — no database server to spin up.

  • Native napi-rs module — no serialization overhead
  • ACID transactions for safe concurrent writes
  • Full-text and vector search in a single binary

Up and running in minutes

Pick your platform and go.

1

Install

bash
$ pnpm add taladb @taladb/web
2

Configure Vite

TalaDB's WASM worker needs cross-origin isolation headers to use OPFS.

vite.config.ts
import { defineConfig } from 'vite'

export default defineConfig({
  server: {
    headers: {
      'Cross-Origin-Opener-Policy': 'same-origin',
      'Cross-Origin-Embedder-Policy': 'require-corp',
    },
  },
})
3

Open a database and query

app.ts
import { openDB } from 'taladb'

const db = await openDB('myapp.db')
const users = db.collection<{ name: string; age: number }>('users')

await users.insert({ name: 'Alice', age: 30 })
const results = await users.find({ age: { $gte: 18 } })
// [{ _id: '...', name: 'Alice', age: 30 }]
Full Browser Guide →

Start building local-first today.

Free, open-source, Apache 2.0 licensed. One API across browser, Node.js, and React Native — no cloud required.

Read the Docs Web Demo → Mobile Demo →
GitHub·npm·Roadmap·Support TalaDB

TalaDB is maintained by one person. Sponsoring on GitHub directly funds continued development.