The stack you run today — in one binary.

Teams stitch 5–6 databases and move data between them with constant ETL. Relata unifies them, plus time-travel, policy, provenance and agent memory — and it already speaks the protocols your clients target.

One engine. Three things happen to every row.

Whatever door data enters, it is recognized, governed and remembered in time. Reads go through the same policy lens.

• Policy lives in the query path — governance & history aren't bolted on; they're how reads/writes happen.
• The door is the source of truth — an S3 object / Mongo doc / Redis key is a governed row.

Point your existing clients at Relata — that's it.

No new driver, no rewrite. Each door is opt-in with one env var (RELATA_<DOOR>_ENABLE=true) and a port.

One switch: free · server · cluster

Same binary, same SQL, same governance — laptop to cluster. Storage is the only free-tier limit (10 GB); doors, multi-tenancy & clustering are free.

curl -sSf https://relatadb.dev/install.sh | sh     # macOS · Linux
docker run -p 9090:9090 -v ~/.relata:/data ghcr.io/relatadb/relata
RELATA_PROFILE=server RELATA_BEARER_TOKEN=$TOKEN relata serve

Raw payload becomes typed, governed knowledge.

You don't define schemas up front. Relata recognizes what data is, shapes it to your ontology, stamps time and lineage, and indexes it for search — automatically, on the way in.

• Auto-typed — emails, IBANs, phones, VINs, IMEIs, wallets… recognized & validated (75+ types), stored canonically.
• Ontology-shaped — declare types once; writes validated against shapes, state machines & computed fields. /admin/schema-discovery proposes a schema from samples.
• Stamped — every row gets valid/system time, provenance link, audit entry; embedding + identity enrichment follow async.

It's SQL — plus time, purpose, meaning & relationships.

-- time-travel to what we knew on Jul 15
SELECT * FROM Person AS OF '2026-07-15' WITH PROVENANCE

-- bind the read to a purpose (governance)
[PURPOSE 'fraud'] SELECT name, iban FROM Person WHERE country = 'SG'

-- relationships in one query
PATHS_BETWEEN('john@acme.io','shellco@x.io', 5)

-- meaning search
SEARCH HYBRID('laundering shell co', top_k=20) FROM IntelChunk

• Same query works via psql, HTTP /query, gRPC, Arrow, or MCP.
• Materialized views, EXPLAIN ANALYZE, automatic result caching.

Every fact remembers when it was true — and when you learned it.

Nothing is overwritten; updates supersede. Ask AS OF any moment to replay exactly what the database believed then — court-grade history out of the box.

SELECT * FROM Account AS OF '2026-07-01' AS OF SYSTEM TIME '2026-07-10'

Policy is part of the query, not a separate system.

Bind a read to a purpose, enforce cell-level masking, keep a tamper-evident audit — expressed in the query, applied on every door.

[PURPOSE 'fraud'] SELECT name, mask(iban) FROM Person
-- ACL evaluated · cells masked · egress filtered · audit written — automatically

• Masked cells stay masked — even excluded from vector embeddings, so masked data can't leak via search.
• Every read/write attributed & logged to a hash-chained audit log.

Full-text search that forgives typos & speaks any language.

A built-in BM25 engine — no separate search cluster to run. Weighted typo tolerance, CJK-aware, fast on large corpora.

SELECT * FROM IntelChunk
WHERE SEARCH(content, 'recieves~2 invoice')   -- ~2 = up to 2 typos
LIMIT 20;

• Indexes automatically on ingest; spills to disk under cap.
• Per-field BM25F scoring; CJK + latin tokenizers.

Search by meaning — vectors in, hybrid out.

Ingest vectors with pgvector or let Relata embed text for you. Query pure vector, or fuse keyword + meaning in one hybrid call.

-- pgvector ingest (psql)
INSERT INTO docs(id, emb) VALUES (1, '[0.12, -0.03, …]');
-- meaning + keyword fused (RRF)
SEARCH HYBRID('shell company laundering', top_k=20) FROM docs;

• Tiered index — hot vectors in RAM, the rest on disk; size for working set.
• ACL-masked cells kept out of embeddings — no leak via vector search.

Reason about relationships in one query.

Links are first-class. Walk paths, rank influence, detect rings and communities — no separate graph database.

“Who is this, really?” — across all your sources.

The same entity shows up as an email, a phone, an IBAN, a wallet. Relata recognizes each, then resolves them into one — even when ingested through different doors.

RESOLVE_IDENTITY('john@acme.io')   -- → unified entity + all aliases
LOOKUP_IDENTITY('+15551234567')      -- → matches across Person/Org/Account/Watchlist

• Identities detected automatically on ingest — emails, phones, IBANs, MMSIs, VINs, wallets…
• Resolution fuses records across doors & sources into one cluster.

Give your agents governed tools & long-term memory.

Point Claude, Cursor, Cline or LangChain at Relata. Agents get 66 governed tools — and a memory that remembers across sessions, forgets on policy, and justifies any decision.

relata mcp config --client claude     # → paste JSON, start chatting
relata token issue --principal "agent:fraud1" --role analyst --purpose fraud --ttl 3600

• Same governance as humans — every agent call is ACL'd, masked, purpose-bound, audited.
• Memory verbs: remember · recall · consolidate · forget · justify — tenant-isolated, bi-temporal.

One database for the whole agentic journey — not just memory.

Relata is built for AI — agents call in for governed memory, tools, and retrieval — and with AI — it embeds, searches, and interprets underneath. The trust path (identity, governance, audit) stays deterministic. Meet it at rung one; it scales with you all the way up.

• Deterministic where it matters — identity is checksum-gated, ACL is bitmap-compiled, audit is hash-chained. Models are modular & opt-in; they are never in the trust path.
• Bring your own models — point RELATA_LLM_URL / RELATA_EMBED_URL at Ollama, vLLM, LM Studio, or any OpenAI-compatible endpoint. Or run fully deterministic.

One deployment, many tenants — zero leakage.

Host all customers on a shared knowledge plane. Isolation is enforced at every layer, by construction: a tenant never sees another's rows, vectors or cache.

RELATA_TENANCY_MODE=multi relata serve
curl -H "X-Relata-Tenant-Id: acme" -H "Authorization: Bearer $TOKEN" …

• Tenant is the isolation key — for rows, vector buckets, and the result cache.
• Optional Groups & Projects for finer scoping; tenant-less writes fail closed.

Add nodes — point lookups don't fan out.

Switch to cluster, list peers. The coordinator routes each query to the fewest shards that can answer it, merges results, and tells you honestly when a result is partial.

RELATA_PROFILE=cluster \
NODE_ID=eu-1 CLUSTER_ROLE=coordinator \
CLUSTER_PEERS=http://eu-2:9090,http://us-1:9090 relata serve

• Partition routing — an id lookup hits only the owning shard; else broadcast + merge.
• Read-your-writes guard blocks wrong-shard writes; partial reads return 206 + warnings.

It gets faster as you use it — fairly, per tenant.

Repeated queries hit a result cache that's isolated per tenant & user (no leakage), with a per-tenant budget so no one starves anyone. Relata also predicts and pre-runs your next query.

• Adaptive sizing — RAM auto-split across store / index / cache / vectors.
• Predictive prefetch — learns patterns, warms the cache before you ask.
• Per-query control: WITH CACHE TTL / STALENESS / BYPASS.

Pick your use case — mix doors & engines.

One database serves several of these at once. Each maps a real workload to the Relata surfaces it leans on.

The mental model in 8 lines.

• Everything is bi-temporal. Updates supersede, never overwrite — AS OF time-travels.
• Policy lives in the query — [PURPOSE '…'] + masking, on every door.
• The door is the source of truth — your S3 object / Mongo doc / Redis key is a row.
• Tenant (org) is the isolation key. Send X-Relata-Tenant-Id; no tenant → no access.
• Storage is the only free limit (10 GB). Doors, multi-tenant, cluster — all free.
• Vectors are lazy by default — set RELATA_ANN_EAGER=true to build on write.
• Cache is per-tenant — no cross-leak; one tenant can't evict another.
• Agents ride the same governance as humans — issue a scoped principal per agent.

Run it on macOS, Linux, Docker or Kubernetes.

One binary, no external database, no GPU. Curl install in seconds, or a production Helm chart with autoscaling, mTLS and backups.

Ship now — more speed & smarts landing next.

The foundation is current. Open work, by outcome:

curl -sSf https://relatadb.dev/install.sh | sh
relata serve     # → http://localhost:9090  (docs · playground · /admin/dashboard)