Differences from Neo4j

relate speaks Neo4j's CypherCypher The declarative graph query language relate runs, written as ASCII-art patterns such as (a)-[:KNOWS]->(b); relate follows Neo4j's Cypher 25 by default. Read more in the glossary, including much of Cypher 25, inside your process. It runs embedded, with no procedure libraries such as APOC and no user accounts, and serves a network surface only when relate serve starts one, so a statement or a connection string written from Neo4j habits can fail in relate. The table lists those habits with the error relate returns, character for character, and the form that works. Everything not in the table behaves as the Cypher overview describes.

Synopsis

Each row is one habit. The relate column quotes the message relate returns: the CLI prints it on stderr and, under --mode json, jsonl or envelope, in the error object's message on stdout; a client raises it. The examples run each one.

The Neo4j column gives the habit's origin in Neo4j as of 2026-11-07, for current releases under Cypher 25 unless a row names a release. It summarizes Neo4j's behavior and was not checked against a Neo4j server; the relate and Write instead columns were checked against relate.

Differences

Examples

The examples run in page order on one in-memory storestore A relate database: a directory, a single .rl file, or :memory:, opened with --database. Read more in the glossary with the shared example graph:

CREATE (ada:Person {name: 'Ada', role: 'engineer'}),
       (grace:Person {name: 'Grace', role: 'engineer'}),
       (noor:Person {name: 'Noor', role: 'maintainer'}),
       (relate:Project {name: 'relate', language: 'Rust'}),
       (tck:Project {name: 'opencypher-tck', language: 'Gherkin'}),
       (ada)-[:WORKS_ON {since: 2024}]->(relate),
       (grace)-[:WORKS_ON {since: 2023}]->(relate),
       (grace)-[:WORKS_ON {since: 2022}]->(tck),
       (noor)-[:MAINTAINS]->(relate),
       (ada)-[:KNOWS]->(grace)

(no rows) · nodes created: 5, relationships created: 5, properties set: 13, labels added: 5

An APOC function fails, and the built-in returns the same string:

MATCH (p:Person) RETURN apoc.text.join(collect(p.name), ', ') AS names

error: syntax error: UnknownFunction: unknown function apoc.text.join()

MATCH (p:Person) WITH p ORDER BY p.name RETURN string.join(collect(p.name), ', ') AS names

| names              |
|--------------------|
| "Ada, Grace, Noor" |
1 row

An APOC schema procedure fails; the db.schema procedures describe the same graph:

CALL apoc.meta.schema() YIELD value RETURN value

error: syntax error: ProcedureNotFound: apoc.meta.schema

CALL db.schema.nodeTypeProperties() YIELD nodeType, propertyName, propertyTypes
RETURN nodeType, propertyName, propertyTypes
ORDER BY nodeType, propertyName

| nodeType   | propertyName | propertyTypes       |
|------------|--------------|---------------------|
| ":Person"  | "name"       | ["STRING NOT NULL"] |
| ":Person"  | "role"       | ["STRING NOT NULL"] |
| ":Project" | "language"   | ["STRING NOT NULL"] |
| ":Project" | "name"       | ["STRING NOT NULL"] |
4 rows

An index procedure fails; CREATE VECTOR INDEX is the statement:

CALL db.index.vector.createNodeIndex('person_focus', 'Person', 'focus', 3, 'cosine')

error: syntax error: ProcedureNotFound: db.index.vector.createNodeIndex

A database name other than the three namespaces fails, and so does creating one:

USE movies MATCH (n) RETURN count(n) AS n

error: semantic error: DatabaseNotFound: Graph not found: movies

CREATE DATABASE movies

error: semantic error: UnsupportedAdministrationCommand: Unsupported administration command: CREATE DATABASE movies

SHOW DATABASES YIELD name, defaultLanguage RETURN name, defaultLanguage

| name                | defaultLanguage |
|---------------------|-----------------|
| "neo4j"             | "CYPHER 25"     |
| "system"            | "CYPHER 25"     |
| "system_ontologies" | "CYPHER 25"     |
3 rows

A path bound beyond the default limit of 500 hops fails before the statement runs:

MATCH (a:Person)-[:KNOWS*1..1000]->(b:Person) RETURN count(*) AS n

error: syntax error: TraversalDepthExceeded: This query allows paths up to 1,000 hops. This is a safety limit protecting against excessive traversal (not a database limit) — lower the path bound, or raise it with --max-traversal-depth (up to 2000).

The cosine scale, and the raw cosine distance next to it:

RETURN vector.similarity.cosine([1, 0], [0, 1]) AS orthogonal,
       vector.similarity.cosine([1, 0], [-1, 0]) AS opposite,
       vector_distance(vector([1, 0], 2, FLOAT32), vector([0, 1], 2, FLOAT32), COSINE) AS rawDistance

| orthogonal | opposite | rawDistance |
|------------|----------|-------------|
| 0.5        | 0.0      | 1.0         |
1 row

A bolt:// address is not a store, on the CLI:

relate --database bolt://localhost:7687 --mode envelope "RETURN 1 AS ok"

The first line is stderr, the second the error object on stdout:

Failed to open Relate: storage error: unsupported URI scheme bolt:// (engine URIs are :memory:, a filesystem path, or file://)
{"error":{"code":"fatal_error","exit_code":1,"kind":"storage","message":"storage error: unsupported URI scheme bolt:// (engine URIs are :memory:, a filesystem path, or file://)","retryable":false}}

LOAD CSV does not fetch a URL, even with a directory allowed:

mkdir import
relate --load-csv-dir ./import --mode envelope "LOAD CSV FROM 'https://example.com/people.csv' AS row RETURN row"

LOAD CSV file unavailable
{"error":{"code":"fatal_error","exit_code":1,"kind":"execution","message":"LOAD CSV file unavailable","retryable":false}}

See also

• Cypher overview: what the dialect covers, and the preview features.
• Search: the SEARCH clause and the vector functions.
• Limitations: the scope choices behind several rows.
• Errors: every message with its exit codeexit code The number a relate run returns to the shell; each nonzero value names a class of failure, such as 2 for usage, 5 for conflict, 6 for a rejected statement. Read more in the glossary and remedy.
• The Cypher dialect: why the dialect differs where it does.
• Migrate from Neo4j: the features beyond the dialect, such as APOC, GDS and clustering, with what to use instead.