Procedures

A procedure is a built-in routine that CALL runs; it returns rows with named columns that YIELD picks. relate has 21 callable procedures that SHOW PROCEDURES lists, four ontology procedures behind a preview opt-in, and two callable procedures it does not list. SHOW PROCEDURES returns 88 rows by default; the other 67 are catalog entries kept for tools that read Neo4j's catalog, and a CALL to one fails with syntax error: ProcedureNotFound: <name>. The cells run on relate's WebAssembly (WASM) build, and the bash verify blocks on the CLI.

Synopsis

CALL <name>([<argument>, …]) [YIELD <column> [AS <alias>], … [WHERE <predicate>]] [<more clauses>]
CALL <name>([<argument>, …])                -- standalone: every column, as rows
CALL <name>([<argument>, …]) YIELD *        -- standalone only: every column
SHOW PROCEDURES [YIELD <column>, …] [WHERE <predicate>] [RETURN …]

Schema procedures

These procedures read the store's labelslabel A name that classifies a node, such as Person; a node has zero or more, and patterns, indexes and constraints refer to them. Read more in the glossary, relationship typesrelationship type The single name every relationship carries, such as KNOWS or WORKS_ON; patterns match on it, and a relationship cannot change it. Read more in the glossary and propertyproperty A named value stored on a node or relationship, such as name: 'Ada'; values are scalars, temporal and spatial values, vectors, or lists of them. Read more in the glossary keys from the data as it is now.

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

CALL db.relationshipTypes() YIELD relationshipType
RETURN relationshipType ORDER BY relationshipType

| relationshipType |
|------------------|
| "KNOWS"          |
| "MAINTAINS"      |
| "WORKS_ON"       |
3 rows

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

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

CALL db.schema.relTypeProperties()
YIELD relType, propertyName, propertyTypes, mandatory
RETURN relType, propertyName, propertyTypes, mandatory ORDER BY relType

| relType        | propertyName | propertyTypes        | mandatory |
|----------------|--------------|----------------------|-----------|
| "[:KNOWS]"     | null         | []                   | false     |
| "[:MAINTAINS]" | null         | []                   | false     |
| "[:WORKS_ON]"  | "since"      | ["INTEGER NOT NULL"] | true      |
3 rows

CALL db.schema.visualization() YIELD nodes, relationships
RETURN [n IN nodes | n.name] AS labels, [r IN relationships | r.name] AS types

| labels                | types                              |
|-----------------------|------------------------------------|
| ["Person", "Project"] | ["KNOWS", "MAINTAINS", "WORKS_ON"] |
1 row

Index procedures

The query procedures search a vector indexvector index An index over a property holding embeddings that answers nearest-neighbor searches exactly, by cosine or Euclidean similarity. Read more in the glossary or a full-text index, created with CREATE VECTOR INDEX or CREATE FULLTEXT INDEX (search). The SEARCH clause replaces them, and all four are deprecated.

CREATE VECTOR INDEX person_focus FOR (p:Person) ON (p.focus)
  OPTIONS {indexConfig: {`vector.dimensions`: 3}};
CREATE FULLTEXT INDEX person_role FOR (p:Person) ON EACH [p.role];
MATCH (p:Person)
SET p.focus = CASE p.name
  WHEN 'Ada' THEN vector([0.9, 0.1, 0.2], 3, FLOAT32)
  WHEN 'Grace' THEN vector([0.3, 0.9, 0.1], 3, FLOAT32)
  ELSE vector([0.2, 0.3, 0.9], 3, FLOAT32) END

(no rows) · properties set: 3, indexes added: 2

CALL db.index.vector.queryNodes('person_focus', 2, [0.1, 0.9, 0.1]) YIELD node, score
RETURN node.name AS name, round(score, 4) AS score

| name    | score  |
|---------|--------|
| "Grace" | 0.989  |
| "Noor"  | 0.7151 |
2 rows

CALL db.index.fulltext.queryNodes('person_role', 'maintainer') YIELD node, score
RETURN node.name AS name, score

| name   | score              |
|--------|--------------------|
| "Noor" | 0.4458314786416938 |
1 row

The same vector search as a SEARCH clause:

MATCH (p:Person)
SEARCH p IN (VECTOR INDEX person_focus FOR [0.1, 0.9, 0.1] LIMIT 2) SCORE AS score
RETURN p.name AS name, round(score, 4) AS score

| name    | score  |
|---------|--------|
| "Grace" | 0.989  |
| "Noor"  | 0.7151 |
2 rows

Database and server information

CALL dbms.components() YIELD name, versions RETURN name, versions

| name           | versions           |
|----------------|--------------------|
| "Neo4j Kernel" | ["2026.10-relate"] |
| "Cypher"       | ["5", "25"]        |
| "Relate"       | ["0.1.2"]          |
3 rows

CALL db.stats.retrieve('GRAPH COUNTS') YIELD section, data
RETURN section, data.indexes AS indexes

| section        | indexes                                                                                   |
|----------------|-------------------------------------------------------------------------------------------|
| "GRAPH COUNTS" | [{labels: ["Person"], properties: ["focus"]}, {labels: ["Person"], properties: ["role"]}] |
1 row

Transaction metadata

Ontology procedures

The ontology procedures are a preview featurepreview feature A Cypher feature from a not-yet-settled proposal that relate ships switched off; it runs only when RELATE_PREVIEW names it when the store opens. Read more in the glossary; set RELATE_PREVIEW=ontology in the environment of the process that opens the store to call them. They keep one Ontology Graph Spec 1.1.0 document per store, for the neo4j namespace. Without the opt-in, SHOW PROCEDURES leaves them out and a call fails with semantic error: SemanticError: preview feature 'ontology' is not enabled: set RELATE_PREVIEW=ontology. The WASM build has no process environment, so the cells on this page cannot call them. Model an ontology is the task guide.

The calls on the CLI, in order. This setup step writes the shared example graph to a new single-file store, team.rl:

relate --database ./team.rl "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)"

db.ontology.set writes a document that requires a name on every Person:

RELATE_PREVIEW=ontology relate --database ./team.rl "CALL db.ontology.set('{\"schema\": \"https://neo4j.com/docs/ontology-graph-spec/1.1.0/schema.json\", \"version\": \"1\", \"id\": \"team\", \"nodes\": {\"Person\": {\"label\": \"Person\", \"properties\": {\"name\": {\"type\": \"STRING\", \"must_exist\": true}}}}}')"

db.ontology.get, read-only:

RELATE_PREVIEW=ontology relate --database ./team.rl --read-only --mode jsonl "CALL db.ontology.get() YIELD ontology RETURN ontology"

{"ontology":"---\nschema: \"https://neo4j.com/docs/ontology-graph-spec/1.1.0/schema.json\"\nversion: \"1\"\nid: team\nnodes:\n  Person:\n    label: Person\n    properties:\n      name:\n        type: STRING\n        must_exist: true"}
{"planCache":"miss","timings":{"elapsed_ms":0.487917,"execute_ms":0.357958,"lex_parse_ms":0.021083,"lower_ms":0.030334,"parse_ms":0.080834,"plan_ms":0.0425,"result_generation_ms":0.00020800000000000001,"rewrite_ms":0.006875}}

db.ontology.apply writes the graph type, which SHOW CURRENT GRAPH TYPE then prints:

RELATE_PREVIEW=ontology relate --database ./team.rl "CALL db.ontology.apply()"

relate --database ./team.rl --read-only --mode jsonl "SHOW CURRENT GRAPH TYPE"

{"specification":"{\n  (:`Person` => {`name` :: STRING NOT NULL})\n}"}
{"planCache":"miss","timings":{"elapsed_ms":0.43029199999999995,"execute_ms":0.328833,"lex_parse_ms":0.017207999999999998,"lower_ms":0.028292,"parse_ms":0.07125,"plan_ms":0.025083,"result_generation_ms":0.000167,"rewrite_ms":0.005958000000000001}}

Catalog-only entries

SHOW PROCEDURES lists these 67 names so that tools built for Neo4j find the rows they expect. None of them runs: each CALL fails with syntax error: ProcedureNotFound: <name>.

CALL db.checkpoint()

error: syntax error: ProcedureNotFound: db.checkpoint

See also

• Functions: the built-in functions, which an expression calls without CALL.
• Search: the SEARCH clause that replaces the index query procedures.
• Model an ontology: the ontology procedures in a task.
• EXPLAIN and PROFILE: the ProcedureCall operator a CALL plans to.
• Text-to-Cypher: the schema procedures as the graph's schema for a model.