Agents that understand data.

Relate is an open-source embedded database for AI agents. Give your agents a place to keep their data and see how it all connects. No signup. No server to deploy.

Pure data joy.

$curl -sSfL https://relatedb.ai/install.sh | bash && relate skill install --agent claude-code

Installs the CLI, then the relate skill for Claude Code. The install script verifies release signatures and SHA256 checksums.

Read docs

See it work

From question to answer, in seconds.

An agent asks a question, writes Cypher, and Relate reads the connected facts and returns rows. Sample data, scripted preview.

AgentRelate skill

Who owns the page the Q3 launch depends on?

Thinking

Maya owns Pricing, and the Q3 launch depends on it. The launch email is also part of Q3.From 3 facts in agent-memory.rl

CypherRun

MATCH (t:Task {name: 'Q3 launch'})
      <-[:DEPENDS_ON]-(p:Page)
      <-[:OWNS]-(o:Person)
RETURN p.name, o.name

p.name	o.name
Pricing	Maya

Graph4 nodes · 3 relationships

One database for every agent.

Every agent, script and app reads and writes the same graph, kept in memory, a directory or one file. No server to run.

Your application

Agent skill · MCP

Claude Code

Codex

Cursor

Any MCP client

CLI · Libraries

Shell

Python

JavaScript

Rust

Cypher

Embedded library

Stores data

in memorya directoryone file

Reads and writes

Your data

Agent memory

Codebase

Recommendations

Your own data

Open source

Read the code, run it locally, and add your own recipes.

Part of your application

Relate runs inside your application. Keep your data in memory, in a directory, or in one file.

Cypher, for connected data

Your agent asks in Cypher and gets back how the facts connect. Skill and MCP endpoint included.

Start in minutes

No signup. No server to deploy.

Run a query on connected data.

Pick a scenario to watch an agent write Cypher and read the rows that come back. Sample data, scripted preview.

memory.rl ready

you What do you remember from our last session?

agent writes:

relate> MATCH (e:Event)-[:AFFECTS]->(x)

relate> WHERE e.session = 'last'

relate> RETURN e.summary AS remembered, labels(x)[0] AS kind, x.name AS item

remembered	kind	item
"Pricing depends on the Q3 launch"	"Decision"	"Annual plan"
"Launch moved to Nov 12"	"Task"	"Draft launch email"
"Maya owns the pricing page"	"Person"	"Maya"

3 rows

Live graph

One statement at a time.

Pick a shape of data and watch the graph grow as each Cypher statement runs, with new facts landing in the connections that already exist.

agent-memory.rl

Cypher

CREATE (maya:Person {name: 'Maya'})-[:REPORTS_TO]->(sam:Person {name: 'Sam'}),
       (alex:Person {name: 'Alex'})-[:REPORTS_TO]->(sam),
       (sam)-[:LEADS]->(:Team {name: 'Platform'});
MATCH (a {name: 'Maya'}) CREATE (a)-[:MENTORS]->(:Person {name: 'Priya'});
MATCH (a {name: 'Sam'}) CREATE (a)-[:LEADS]->(:Team {name: 'Design'});
MATCH (a {name: 'Alex'}) CREATE (a)-[:MEMBER_OF]->(:Team {name: 'Infra'});

CREATE (maya:Person {name: 'Maya'})-[:REPORTS_TO]->(sam:Person {name: 'Sam'}),
       (alex:Person {name: 'Alex'})-[:REPORTS_TO]->(sam),
       (sam)-[:LEADS]->(:Team {name: 'Platform'});
MATCH (a {name: 'Maya'}) CREATE (a)-[:MENTORS]->(:Person {name: 'Priya'});
MATCH (a {name: 'Sam'}) CREATE (a)-[:LEADS]->(:Team {name: 'Design'});
MATCH (a {name: 'Alex'}) CREATE (a)-[:MEMBER_OF]->(:Team {name: 'Infra'});

Quickstart

Four steps to your first query.

Install the agent skill
One command, for the agents you already use.
agent skill
Pick a storage format
In memory, a directory, or one .rl file.
memory / directory / .rl
Create data
Write Cypher, load a CSV, or mirror from Aura.
Cypher / CSV / Aura
Query it
Tables for you, JSON for your agent.
table / JSON

Set up relate for me. Read https://relatedb.ai/skill.md, install the relate agent skill, create a database, add my data, and answer my questions by writing Cypher queries.

Read docs

Built for agents, wherever your agent runs.

relate is a library inside your application. Your agent writes Cypher and relate answers with the results. Use the interface that fits your build.

Agent skill

Teaches your coding agent to write Cypher for relate.

MCP endpoint

Lets agents that speak MCP connect without glue code.

Command line

Create, load and query a database right from the shell.

Libraries

Embed relate in your own application, in your language.

Your language, one library

The same relate in Rust, Python, JavaScript, WebAssembly, Go, Java, Swift and C. Pick the one your application is written in.

No server to run

relate starts when your application does and stops when it stops. Nothing to host, nothing to keep running.

MATCH (:Person {name: 'Maya'})-[:DECIDED]->(:Topic) -[:DEPENDS_ON]->(:Launch) RETURN Launch.name

Memory with structure.

Raw data becomes connected facts, so your agent can follow how people, decisions and documents relate. Relationships and similarity answer in one query.

Facts, not loose text

Decisions, people and documents become facts you can query.

Relationships and similarity together

One Cypher statement can combine both.

Zero to querying in seconds.

Install the open-source package, create a database and start running your first query. No account, no instance and no server to deploy.

$curl -sSfL https://relatedb.ai/install.sh | bash $relate --mode envelope "RETURN 1 AS ok" {"columnTypes":["INTEGER"],"columns":["ok"],"notifications":[],"rows":[{"ok":1}],"truncated":false}

Cypher you already know.

relate speaks the openCypher language and is tested against the openCypher TCK, the language contract. Where it differs from Neo4j, the docs say so.

Read the differences

Build it with us, one recipe at a time.

Share a recipe for the cookbook, report what you find, and show what your agents learned.

GitHub Add a recipe

Start building

Give your agent a graph it can think with.

Get started Open the playground