RelataDB — one database for messy, sensitive, connected data

RelataDB turns records arriving from many places — phone logs, bank transfers, social profiles, sanctions lists, app logs — into one connected, trustworthy, provable picture. It does the work most teams do by hand (cleaning, matching, proving, governing) inside the database, so your team spends its time asking questions, not reconciling data.

Already running MongoDB / Postgres / Redis / Neo4j / ClickHouse / an S3 client? Point your existing client at Relata in 60 seconds — no SDK, no rewrite. Your driver, your ORM, your GUI tool all keep working. See Compatibility & Doors.

Is this for me?

RelataDB earns its keep when your data is at least one of:

  • Messy — the same entity wears disguises across sources (+44 7700… in a call log, 07700… in a CRM, an email at signup, a CustomerID in billing). You can't tell it's the same human without weeks of cleanup.
  • Sensitive — who-can-see-what rules differ by team, country, and purpose, and you have to enforce them on read.
  • Needs proving — every fact must be traceable to its source (audit, legal, compliance, court-grade replay).
  • Connected — you need the graph of who-knows-who, who-paid-who, who-called-who — without hand-building it.

If your data is clean, public, and low-stakes, a regular database is simpler and cheaper. See Relata vs others for an honest side-by-side (including when not to use Relata).

Try it in 60 seconds

The server is one binary, no JVM, no external services. Pick the path that matches your stack — both paths read and write the same governed store.

Path A — keep your existing client (drop-in)

Best if you have a working app and want governance, history, and provenance without rewriting code.

docker run -d -p 9090:9090 -p 27017:27017 -p 5433:5433 -p 6379:6379 \
  -e RELATA_BEARER_TOKEN=change-me \
  ghcr.io/relatadb/relata:2.0.0
// Your MongoDB client, unchanged except host/port + password = your token
const { MongoClient } = require("mongodb");
const c = new MongoClient("mongodb://localhost:27017", {
  auth: { username: "relata", password: "change-me" },
});
await c.db("cases").collection("logs").insertOne({ _id: "r1", body: "hello" });

Same story for psql, redis-cli, Neo4j, ClickHouse, boto3, Arrow Flight — one binary speaks 13 wire protocols. Full port table + per-protocol quickstarts: Compatibility & Doors.

Path B — use the SDK (full surface)

Best for greenfield, or when you want first-class SQL, graph traversals, agent memory, MCP tools, and hybrid search.

docker run -d -p 9090:9090 ghcr.io/relatadb/relata:2.0.0
# or: 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["name"], row["email"])
// 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);

SDK quickstart (Python / TypeScript / Go): Quickstart.

What you get by default

Four things every other database makes you build yourself — RelataDB does them in the write and read paths, not as an afterthought:

WhatMeansWhy it matters
Identity resolutionThe same person across phone / email / CustomerID is auto-merged into one entity, deterministically (no LLM guessing)Stop hand-matching; query a graph that formed itself
Bi-temporal historyEvery row carries valid_from/to + system_from/to; rewind with AS OF '<ts>'"What did we know on Tuesday?" is one query, not a restore
Provenance on every factWhere it came from, when, who put it there — tamper-evident audit hash chainCourt-grade replayable; auditors and lawyers get answers fast
Cell-level governanceCedar-inspired ABAC: who can see which cell, by purpose / team / countryShare the data without leaking the sensitive fields

Plus hybrid search (BM25 + HNSW vector + identity fusion in one query), 10 cognitive memory verbs for AI agents (remember · recall · recognize · justify · consolidate · forget · associate · episodes · resolve · summarise), and 13 wire protocols so your existing tools work unchanged.

Where to go next

A clear path from "is this for me?" to production — not 20 links.

Evaluate (~10 minutes)

  • Compatibility & Doors — bring your existing MongoDB / Postgres / Redis / Neo4j / ClickHouse / S3 client
  • Quickstart — first query in 5 minutes (Python / TypeScript / Go)
  • Relata vs others — honest comparison, including when not to use Relata

See it in action

  • Use cases — AML / sanctions, law-enforcement investigation graphs, telecom co-location, maritime dark-fleet, cyber Sigma detection, OSINT identity fusion, governed RAG

Build

Run in production

What's honestly shipping

RelataDB is on the path to 5.0. The governed core is real and smoke-tested — 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) from one binary. The honest gap list lives at Limits & Caveats.