Meet Relate by Neo4j: An Embedded Database for AI Agents

Your agent works with a lot of different kinds of data: customer records, documents and tickets, plans that span sessions, records of what it did and who approved it. To be quick and reliable, an agent needs context it can reason over and a place to work that runs right inside your application, with no separate server. Most databases need an account, credentials, and a running server before an agent can use them. So developers skip database servers and keep the data in a Python dict, a JSON file, or a vector store, which hold facts but not how those facts connect.

Today, at NODES 2026, we’re launching Relate by Neo4j: an open-source, embedded graph database that helps your agents build and understand relationships in any data. It runs as a library inside your application process, CLI in your sandbox or WASM in your browser, with no setup or server to deploy, and stops when your application does, so there is nothing to maintain.

Watch an Agent Use Relate

Let’s say you’re building an app. You don’t write every line of code yourself. You grab ready-made packages to speed up the build. Each of those packages pulls in other packages it needs, and those pull in more. Some of them have known security vulnerabilities that have been publicly reported, and others have quietly been abandoned. You didn’t add most of these packages yourself, so you don’t know they’re in your app.

In this demo, Claude Code uses Relate to audit the 24 direct dependencies of Google’s Agent Development Kit (ADK). Relate’s skill is installed in the agent, so it knows how to use Relate from its first command. Instead of one big database, the agent gives each dependency its own throwaway Relate instance. Each one is a small graph where every package is a node and every “needs” link is a relationship. The agent loads each dependency’s tree from deps.dev, using real data, and checks every graph for known security advisories and unmaintained packages. It then reports what it finds and deletes the databases.

The whole demo starts with one prompt:

Audit this project's direct dependencies for transitive security advisories and unmaintained packages using deps.dev, using a throwaway fleet of relate instances using the Relate CLI — one isolated graph per dependency. Audit only the 24 direct dependencies in the main dependencies list in pyproject.toml, and use the exact versions pinned for them in constraints-3.11.txt. Ignore the other packages in that file.Code language: JavaScript (javascript)

Built for Agents, and Runs Where They Run

Many AI engineers let their coding agent pick the tools, so we optimized Relate for the agent itself. One command installs a skill into the agents you already use, including Claude Code, Cursor, Windsurf, GitHub Copilot, Antigravity CLI, Cline, Codex, and Pi, and a separate command starts an MCP endpoint. Your agent can find it and start using it in seconds. Agent mode returns JSON or Toon the agent can read and cap returned rows so a large result doesn’t crowd out its working memory. Actionable error messages (structured JSON with a retryable flag), built-in help, and agent context also steer the agent toward efficient interactions.

Because Relate runs inside your code, it goes wherever your agent goes. It ships as a Rust crate, a command-line tool, a Python package, a Swift package for MacOS/iOS, and a WASM build for browsers, with JavaScript, Java, and Go bindings. Notebooks, browser tabs, phones, and edge devices all work. On mobile, geospatial search runs alongside traversals in the same query, making mobile and on-device apps a natural fit.

Memory with Structure

Similarity search finds text that looks like other text. Agents also need to know how things connect: who said what, which task depends on which, and what changed since the last session. Relate lets your agent store what it learns as connected context rather than loose text, so the relationships are explicit and it can follow them.

A single Cypher statement can combine vector search and following connections, so recall covers what is related, not just what is similar.

You choose how long the data lives. Run Relate in memory for a disposable session, or use a directory or single file, where every write is saved transactionally to disk. Storage can be backed by Parquet, JSON, or Markdown files. The single file is easy to move around: share it or check it into GitHub, so others get the full database, or if your project outgrows local usage in Relate, move your shared context over to Neo4j Aura.

Zero to Querying in Seconds

Relate has no server installation step: install it with one command, and run your first query. You don’t need to learn a new query language: your agent already knows the Cypher to query the database well to start immediately.

In practice, builders use it for:

• Agent memory: a lightweight store per session or agent that tracks who said what, which decisions rest on which facts, and what changed since last time. It spins up and tears down with the session, and agents can install it themselves.
• Per-user memory: give each user a separate graph file. Agents have separate working databases per user that restrict access to the allowed datasets.
• Codebase context: a graph of the repo’s symbols, calls, and owners that a coding agent queries on every step to trace what a change touches. It stays local to the repo and the editor, with no service to run.
• Agent sandboxes: In local or managed sandboxes – pull one slice of a larger graph from Aura/Neo4j, analyze it, consume the results, and throw the database away. Relate starts instantly, with no heavy container to bundle – even the Docker container is just 65MB. Memory caps (–logical-graph-size-limit, –expression-memory-limit, –max-traversal-depth) keep a sandboxed database within bounds you set.
• Data analysis in notebooks, data visualization and browser prototypes: fetch data, then build and query graphs inline, right next to your analysis. The WASM build runs in a browser with nothing to install.

What You Get with Neo4j

Relate is a new Rust implementation, built on twenty years of Neo4j graph experience. It is an open-source, lightweight library you embed in your agents, with millisecond startup and submillisecond queries for ephemeral sessions and durable storage for persistent ones. Four things set it apart:

• Full Cypher and GQL coverage – Relate runs more than 30k test scenarios for openCypher, Cypher 25 and GQL to assert that it is compatible with the Neo4j query surface
• Fast and smart graph query engine with many of the approaches that are used in modern databases and also in Neo4j’s query engine.
• Relationships and similarity fit within one query. A single Cypher statement can follow connections and run vector and full-text search together, so your agent doesn’t stitch results from two stores together in glue code.
• We’ve built Relate to be agent-native from the first command. The skill and MCP endpoint ship with Relate, and agent mode returns output the agent can process optimally. Your agent can install it and start querying without any wiring from you.

When a project outgrows a single, local process, the same Cypher works in Neo4j. You can pull a subgraph from Aura into Relate for a task, push results back, and existing Neo4j drivers and tools connect over Bolt or HTTP.

Get Started

Relate is open source and available today, and your agent can set it up itself. Paste this into your coding agent:

Install Relate by Neo4j by following the instructions at relatedb.ai. 
Use Relate as this project's memory: 
store what you learn as connected facts, and query them with Cypher.Code language: PHP (php)

Your agent installs Relate, adds the skill, and runs its first query, and that first invocation completes in milliseconds.

Prefer the terminal? These are the same steps by hand:

curl -sSfL https://relatedb.ai/install.sh | bash
relate skill install
relate --database :memory: "CREATE (a:Agent {name:'planner'})-[:USES]->(t:Tool {name:'search'}) RETURN a.name, t.name"Code language: JavaScript (javascript)

Ready to build? Go to relatedb.ai, install Relate by Neo4j with one command, and explore the playground and cookbooks. Then put it to work in the Relate by Neo4j Hackathon, a month-long online event where you can show what agents can do when their context is connected. Want to hear more? Join us at NODES 2026, where we’ll talk about Relate and the hackathon.