RelataDB — one database for messy, sensitive, connected data

Relata DB 3.0
Relata DB 3.0 is the current release: a single-machine open edition with a /v1 HTTP API and the PostgreSQL, Mongo, Redis, Neo4j, ClickHouse, S3 and Flight listeners retired. The 2.x documentation is kept in the 2.5.8 snapshot. Start at What is new in 3.0.

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.

Coming from MongoDB, Postgres, Redis, Neo4j, ClickHouse or an S3 client? In 3.0 those compatibility listeners are retired; use HTTP/JSON or the SDKs instead. See Migrating from retired 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 — plain HTTP/JSON

Best if you want to call the database from any language with no SDK. The API is described by the OpenAPI 3.1 document at GET /openapi.json, and every data-plane route lives under /v1/.

Auth is mandatory. Mint a registry token as shown in the Quickstart, then:

curl -s -X POST http://localhost:8080/v1/ingest/bulk \
  -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
  -d '{"objects":[{"_type":"Person","_pk":"p1","name":"Alice"}],"on_conflict":"upsert"}'
 
curl -s -X POST http://localhost:8080/v1/query \
  -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
  -d '{"sql":"SELECT name FROM Person LIMIT 10","purpose":"analytics"}'

/v1/query is read-only; writes go through the ingest routes. Read-only GraphQL (POST /v1/graphql), MCP (POST /mcp) and search (POST /v1/search) are on the same port. The Person type must exist first; register it or use POST /v1/ingest/auto.

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.

# Boot + mint flow, step by step: Quickstart → Prerequisites
docker run -d -p 8080:8080 --name relata \
  -e RELATA_BEARER_TOKEN=local-dev-bearer \
  -e RELATA_ADMIN_TOKEN=local-dev-admin \
  -e RELATA_KMS_LOCAL_DEV=true \
  -e RELATA_SECURITY_MODE=open \
  ghcr.io/relatadb/relata:3.0.0
# or: curl -sSf https://relatadb.dev/install.sh | sh && relata serve

The SDK examples below use the registry token minted in the Quickstart (RELATA_BEARER_TOKEN itself is loopback-only and is refused through a published port):

# pip install relata-sdk
from relata import RelataClient
from relata.ingest import IngestClient
 
with RelataClient("http://localhost:8080", bearer_token="<minted-token>", purpose="analytics") as client:
    IngestClient.from_client(client).bulk("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:8080", {
  bearerToken: "<minted-token>",
  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 HTTP/JSON, GraphQL (read-only), MCP and A2A interfaces from one binary.

Where to go next

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

Evaluate (~10 minutes)

  • What is new in 3.0 — the open single-machine edition, the /v1 API and the retired doors
  • 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 — SIEM/SOC, financial crime, blockchain threat intelligence, physical-security video evidence, governed RAG and agent memory, SaaS backends, compliance

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 HTTP/JSON, read-only GraphQL, MCP and A2A interfaces from one binary (the compatibility listeners are retired in 3.0). The honest gap list lives at Limits & Caveats.