Your agent works with many different types of data: documents and files, messages and tickets, and its own notes and actions. And data doesn’t stand alone: documents may be cited in tickets, messages can lead to decisions, and actions trace back to notes or conversations. In order for agents to work with connected data at every step, they need storage that’s quick to reach and queries that are lightweight to run. Traditional databases with servers or services requiring account signups don’t meet these needs, so developers fall back to Python dicts or JSON files, which keep facts but lose how they connect.
Today, at NODES 2026, we’re launching Relate by Neo4j: an open-source, embedded graph database that keeps the connections along with the facts. It helps your agents build and understand relationships in any data, running inside whatever your agent is already using: as a library in your application, a CLI tool in your sandbox, or a WebAssembly build in your browser. A single command installs it, and there’s no server to deploy. Relate starts and stops with your application, with nothing to keep running.
Built for Agents
Agents increasingly choose their own tools, and they choose the ones that are easiest to start with. So we designed Relate for the agent first. A single line installs Relate and adds its skill to a coding agent, and from then on the agent can turn data into a connected graph for queries on its own. For agents you build, add Relate as a library in Python, Javascript, Rust, Java, Go, or Swift, and the database ships with your agent, with no server to deploy. Agents that never open a shell can connect over MCP: relate serve turns a database into tools for reading schema and running queries.
Relate also knows when it’s talking to an agent. Under a coding agent, it switches to agent mode on its own, returning compact TOON (a table format that uses fewer tokens) output and capped rows per query. Errors have actionable exit codes and explanations. And a built-in relate agent-context provides command reference for the version installed so that the agent doesn’t guess at flags.
Watch an Agent Use Relate
This demo is one example of using Relate for transitive dependency analysis, checking a project for security risk and staleness across languages. 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:
Zero to Querying in Seconds
There’s no need to learn a new query language to use Relate – it speaks Cypher, the most widely used graph query language, so your agent already knows how to query it. Here are some useful things to build with and for agents:
- Agent coordination: several agents share one record of work on what’s ready, who’s on what, what blocks what, and what they’ve found out. Agents don’t attempt to claim the same tasks and they see priority shifts as soon as they happen.
- Embedded apps: add a graph to desktop, mobile, or edge apps without a server. Relate can run on the device and can work offline, keeping user data private.
- Agent sandboxes: In a local sandbox, pull one slice of a larger graph from Aura/Neo4j, and optionally add local data to analyze and process. Each sandbox is a file and nothing leaves the machine. Cap its memory and dispose of it as needed.
- Notebooks, data visualization and browser apps: fetch data, then build and query graphs right next to your analysis. The WebAssembly (WASM) build runs in a browser with nothing to install.
- Agent and per-user 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.
- Codebase context: a local graph of your repo’s files, git history, and owners that a coding agent queries to see what a change touches and who to ask. It stays local to the repo and the editor, with no service to run
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.
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:
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:
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.
