What RelataDB is#

RelataDB turns messy, sensitive, multi-source data into one connected, trustworthy, provable picture — so your team spends its time asking questions, not cleaning and reconciling data.

New here? The 30-second version: it's a database that, by default, (1) recognizes the same identity across all your sources and auto-connects it, (2) records full history on two timelines so you can rewind to any moment, (3) notarizes where every fact came from, and (4) governs who can see each cell. Think graph database + notary + auditor. Skim Relata vs others next, then the Concepts pages.

The problem it solves#

You have records about the same people, organizations, money, and events arriving from many places — phone logs, bank transfers, social profiles, sanctions lists, app logs. They're a mess in three ways:

• The same thing wears many disguises. One person shows up as +44 7700… in a call log, 07700… in a CRM, an email at signup, and a customer ID in billing. You can't tell it's the same human without weeks of cleanup.
• You can't trust where anything came from. Who put a fact there? When? Was it corrected? Is it still true? Usually nobody knows.
• You can't safely use or share it. Different fields have different rules about who may see them, and those rules shift by country, team, and purpose.

Most teams spend the majority of their time reconciling and proving their data, and only a fraction actually using it. RelataDB flips that ratio.

In technical terms#

RelataDB is a Rust data engine for ontology-driven identity and governed knowledge workloads. It replaces the polyglot stack (Postgres + Neo4j + Elasticsearch + Qdrant + Redis + Iceberg) with one engine that handles relational, graph, vector, full-text, time-series, and geospatial data in a single query plane, with bi-temporal versioning, cell-level governance, and PROV-O provenance built in from the bottom up.

What makes it different#

• Bi-temporal rows — every record carries valid_from/to and system_from/to. Travel to any point in history with AS OF.
• Identity resolution — cross-source entity matching built into the query language (LOOKUP_IDENTITY, RESOLVE_IDENTITIES, PATHS_BETWEEN).
• Built-in governance — Cedar-inspired ABAC, cell masking, PURPOSE tracking, egress filtering, GDPR Art. 17 erasure.
• Provenance on every row — PROV-O lineage + a tamper-evident audit hash chain, byte-identical exhibit replay.
• Agent-native — 10 cognitive verbs (remember · recall · recognize · justify · consolidate · forget · associate · episodes · resolve · summarise) over MCP and /memory/*, with a Memory client shipping in all three SDKs (Python, TypeScript, Go). Drop-in framework adapters (LangChain, LlamaIndex, CrewAI, AutoGen, AG2, LangGraph, Pydantic-AI, smolagents) are Python-only.
• Universal protocols — speaks Postgres wire, gRPC, HTTP, MCP, Arrow Flight, SPARQL, plus 8 compatibility doors (S3, ClickHouse HTTP/TCP, Neo4j HTTP/Bolt, Redis, MongoDB). 13 wire surfaces from one binary — bring your existing client.
• Hybrid search — BM25 + custom HNSW vector + identity fusion with reciprocal-rank scoring in a single query.

Quick start#

Pick the SDK that matches your stack — each takes under a minute. The server is one binary:

# Docker (recommended — no build required)
docker run -d -p 9090:9090 ghcr.io/relatadb/relata:2.0.0
# or, the Docker Hub mirror (same image):
docker run -d -p 9090:9090 openworkbench/relata-db:2.0.0
 
# or install the pre-built binary
curl -sSf https://relatadb.dev/install.sh | sh && relata serve

# pip install relata-sdk
from relata import RelataClient
 
with RelataClient("http://localhost:9090", purpose="analytics") as client:
    client.ingest("Person", [{"name": "Alice", "email": "alice@example.com"}])
    for row in client.query("SELECT * FROM Person LIMIT 10"):
        print(row)

// npm install @zysec-ai/relata-sdk
import { createClient } from "@zysec-ai/relata-sdk";
 
const relata = createClient("http://localhost:9090", { defaultPurpose: "analytics" });
const result = await relata.query("SELECT * FROM Person LIMIT 10");
console.log(result.rows);

# psql / pgvector / ClickHouse / Neo4j / Redis / Mongo / curl / S3 — all work too.
curl -s http://localhost:9090/query \
  -H 'Content-Type: application/json' \
  -d '{"sql":"SELECT * FROM Person LIMIT 5"}'

Where to go next#

Getting started:

• Quickstart — running in 5 minutes
• SDK quickstart — first query in 5 minutes across Python, TypeScript, Go

Understand the system:

• How It Works — the conceptual mental model and the journey of a row
• Data Flow — the eager/lazy ingest split and the query path
• SmartIngest — deterministic identity detection and its honest boundary
• Jobs & Triggers — the typed-Job engine and what fires it
• Architecture Overview — the five planes, data flow, design invariants
• Data Model — primitives, bi-temporal rows, canonical types
• Storage Engine — on-disk layout, WAL, caching, paged backends
• Query Engine — planner, optimizer, streaming execution

Concepts:

• AI in RelataDB · Bi-Temporal · Identity · Governance · Provenance · Agent Memory · Hybrid Search

Operate in production:

• Configuration · Auth & Security · Multi-Tenancy
• Observability · Backup & Restore · Scaling

Code:

• SDKs: Python · TypeScript · Go
• Reference: SQL reference · MCP Tools · Protocols · Env Variables · Limits

Deploy:

• Deployment — profiles, persistence, graceful shutdown

What's honestly shipping#

RelataDB is on the path to 5.0. The governed core is real — bi-temporal store, planner with ACL + organisation isolation, provenance/audit hash chain, SmartIngest identity detection, and all 8 compatibility doors + 5 native protocols (13 wire surfaces) are implemented and smoke-tested. The honest gap list lives at Limits & Caveats.