--- title: Procedures description: "relate, the embedded Cypher graph database (relatedb.ai): Every procedure relate can CALL, with its signature and YIELD columns, the ontology preview procedures, and the catalog entries listed but not callable." type: reference surfaces: - cypher - cli status: stable verified: 0.1.2 verified_by: - cypher - cli canonical_url: https://relatedb.ai/docs/reference/cypher/procedures/ prerequisites: [] related: - reference/cypher/functions - reference/cypher/search - guides/cypher/ontology - reference/cypher/explain-and-profile - concepts/problems-relate-solves#text-to-cypher last_updated: 2026-11-09 --- # Procedures Every procedure relate can CALL, with its signature and YIELD columns, the ontology preview procedures, and the catalog entries listed but not callable. > Verified against relate 0.1.2. If your `relate --version` is newer, read https://relatedb.ai/docs/reference/changelog/#since-0.1.2 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: `. The cells run on relate's WebAssembly (WASM) build, and the `bash verify` blocks on the CLI. ## Synopsis ```text CALL ([, …]) [YIELD [AS ], … [WHERE ]] [] CALL ([, …]) -- standalone: every column, as rows CALL ([, …]) YIELD * -- standalone only: every column SHOW PROCEDURES [YIELD , …] [WHERE ] [RETURN …] ``` | Rule | Detail | | ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Optional arguments | A parameter written `name = ` in the signature may be left out | | `YIELD *` | Standalone `CALL` only; in a longer statement it fails with `syntax error: UnexpectedSyntax: YIELD * is not allowed in in-query CALL`, and the columns are named instead | | Wrong arity | `syntax error: InvalidNumberOfArguments: expected , got ` | | Unknown or catalog-only name | `syntax error: ProcedureNotFound: ` | | Deprecated procedures | Of the callable procedures, the four index query procedures; under `EXPLAIN` a call raises notification `01N01` with ``Use the `SEARCH` clause instead.`` ([notifications](https://relatedb.ai/docs/reference/cypher/notifications/)). `SHOW PROCEDURES` also marks five catalog-only entries deprecated: `cdc.current`, `cdc.earliest`, `cdc.query`, `dbms.cluster.recreateDatabase` and `dbms.cluster.routing.getRoutingTable` | | `SHOW PROCEDURES` columns | `name`, `description`, `mode`, `worksOnSystem`, `signature`, `argumentDescription`, `returnDescription`, `admin`, `option`, `isDeprecated`, `deprecatedBy` | | Extensions | An extension adds no procedure: it is a `relate run` command that reaches the store over MCP stdio ([write an extension](https://relatedb.ai/docs/guides/extensions/write-an-extension/)) | ## Schema procedures These procedures read the store's [labels](https://relatedb.ai/docs/reference/glossary/#label), [relationship types](https://relatedb.ai/docs/reference/glossary/#relationship-type) and [property](https://relatedb.ai/docs/reference/glossary/#property) keys from the data as it is now. | Signature | `YIELD` columns | Notes | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `db.labels() :: (label :: STRING)` | `label` | The labels some node carries | | `db.relationshipTypes() :: (relationshipType :: STRING)` | `relationshipType` | The types some relationship has | | `db.propertyKeys() :: (propertyKey :: STRING)` | `propertyKey` | The keys some node or relationship has | | `db.schema.nodeTypeProperties() :: (nodeType :: STRING, nodeLabels :: LIST, propertyName :: STRING, propertyTypes :: LIST, mandatory :: BOOLEAN)` | `nodeType`, `nodeLabels`, `propertyName`, `propertyTypes`, `mandatory` | One row per label set and property. `nodeType` is the sorted label set, `:A:B`; `propertyTypes` are `valueType()` names; `mandatory` is `true` when every node of the label set has the key. A label set with no properties gives one row with `propertyName` `null` | | `db.schema.relTypeProperties() :: (relType :: STRING, propertyName :: STRING, propertyTypes :: LIST, mandatory :: BOOLEAN)` | `relType`, `propertyName`, `propertyTypes`, `mandatory` | `relType` is written `[:TYPE]`; same rules as `nodeTypeProperties` | | `db.schema.visualization(options = true :: BOOLEAN\|MAP) :: (nodes :: LIST, relationships :: LIST)` | `nodes`, `relationships` | One row: a virtual node per label, with `name`, `indexes` and `constraints`, and a virtual relationship per start label, type and end label, with `name`. `false` leaves out combinations that no relationship in the data has; `null` gives no row. An empty store gives no row | | `db.createLabel(newLabel :: STRING)` | — | Returns no rows; `db.labels()` lists the label only once a node carries it | ```cypher run name=seed 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) ``` ```table (no rows) · nodes created: 5, relationships created: 5, properties set: 13, labels added: 5 ``` ```cypher run name=labels CALL db.relationshipTypes() YIELD relationshipType RETURN relationshipType ORDER BY relationshipType ``` ```table | relationshipType | |------------------| | "KNOWS" | | "MAINTAINS" | | "WORKS_ON" | 3 rows ``` ```cypher run name=node-type-properties CALL db.schema.nodeTypeProperties() YIELD nodeType, propertyName, propertyTypes, mandatory RETURN nodeType, propertyName, propertyTypes, mandatory ORDER BY nodeType, propertyName ``` ```table | 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 ``` ```cypher run name=rel-type-properties CALL db.schema.relTypeProperties() YIELD relType, propertyName, propertyTypes, mandatory RETURN relType, propertyName, propertyTypes, mandatory ORDER BY relType ``` ```table | relType | propertyName | propertyTypes | mandatory | |----------------|--------------|----------------------|-----------| | "[:KNOWS]" | null | [] | false | | "[:MAINTAINS]" | null | [] | false | | "[:WORKS_ON]" | "since" | ["INTEGER NOT NULL"] | true | 3 rows ``` ```cypher run name=visualization CALL db.schema.visualization() YIELD nodes, relationships RETURN [n IN nodes | n.name] AS labels, [r IN relationships | r.name] AS types ``` ```table | labels | types | |-----------------------|------------------------------------| | ["Person", "Project"] | ["KNOWS", "MAINTAINS", "WORKS_ON"] | 1 row ``` ## Index procedures The query procedures search a [vector index](https://relatedb.ai/docs/reference/glossary/#vector-index) or a full-text index, created with `CREATE VECTOR INDEX` or `CREATE FULLTEXT INDEX` ([search](https://relatedb.ai/docs/reference/cypher/search/)). The `SEARCH` clause replaces them, and all four are deprecated. | Signature | `YIELD` columns | Notes | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | --------------------------------------------------------------------------------------------- | | `db.index.vector.queryNodes(indexName :: STRING, numberOfNearestNeighbours :: INTEGER, query :: LIST) :: (node :: NODE, score :: FLOAT)` | `node`, `score` | The nearest nodes, highest score first; the score is the index's similarity, from 0 to 1 | | `db.index.vector.queryRelationships(indexName :: STRING, numberOfNearestNeighbours :: INTEGER, query :: LIST) :: (relationship :: RELATIONSHIP, score :: FLOAT)` | `relationship`, `score` | The same over a relationship vector index | | `db.index.fulltext.queryNodes(indexName :: STRING, query :: STRING) :: (node :: NODE, score :: FLOAT)` | `node`, `score` | Matching nodes, highest score first, with the query syntax and scores of a full-text `SEARCH` | | `db.index.fulltext.queryRelationships(indexName :: STRING, query :: STRING) :: (relationship :: RELATIONSHIP, score :: FLOAT)` | `relationship`, `score` | The same over a relationship full-text index | | `db.awaitIndexes(timeOutSeconds = 300 :: INTEGER)` | — | Returns at once with no rows; `SHOW INDEXES` reports every index `ONLINE` | ```cypher run name=create-indexes 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 ``` ```table (no rows) · properties set: 3, indexes added: 2 ``` ```cypher run name=vector-query 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 ``` ```table | name | score | |---------|--------| | "Grace" | 0.989 | | "Noor" | 0.7151 | 2 rows ``` ```cypher run name=fulltext-query CALL db.index.fulltext.queryNodes('person_role', 'maintainer') YIELD node, score RETURN node.name AS name, score ``` ```table | name | score | |--------|--------------------| | "Noor" | 0.4458314786416938 | 1 row ``` The same vector search as a `SEARCH` clause: ```cypher run name=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 ``` ```table | name | score | |---------|--------| | "Grace" | 0.989 | | "Noor" | 0.7151 | 2 rows ``` ## Database and server information | Signature | `YIELD` columns | Notes | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `db.info() :: (id :: STRING, name :: STRING, creationDate :: STRING)` | `id`, `name`, `creationDate` | `neo4j`, `neo4j`, `null` | | `dbms.info() :: (id :: STRING, name :: STRING, creationDate :: STRING)` | `id`, `name`, `creationDate` | `relate`, `system`, `1970-01-01T00:00:00Z` | | `dbms.components() :: (name :: STRING, versions :: LIST, edition :: STRING)` | `name`, `versions`, `edition` | Three rows: `Neo4j Kernel`, `Cypher` (`["5", "25"]`) and `Relate`, whose `versions` holds the relate version | | `db.ping() :: (success :: BOOLEAN)` | `success` | `true` | | `dbms.showCurrentUser() :: (username :: STRING, roles :: LIST, flags :: LIST)` | `username`, `roles`, `flags` | `relate`, `["admin"]`, `[]`; relate has no users | | `dbms.listConfig() :: (name :: STRING, description :: STRING, value :: STRING, dynamic :: BOOLEAN, defaultValue :: STRING, startupValue :: STRING, explicitlySet :: BOOLEAN, validValues :: STRING)` | Those eight | Nine fixed settings for Neo4j tools, such as `browser.post_connect_cmd` and `server.metrics.prefix` (`relate`) | | `dbms.clientConfig()` | The `dbms.listConfig` columns | Not listed by `SHOW PROCEDURES`; the browser settings, for Neo4j tools that call it | | `dbms.licenseAgreementDetails()` | `status`, `daysLeftOnTrial`, `totalTrialDays` | Not listed by `SHOW PROCEDURES`; `yes`, `null`, `null` | | `db.stats.retrieve(section :: STRING) :: (section :: STRING, data :: MAP)` | `section`, `data` | Serves only `'GRAPH COUNTS'`, whose `data` holds `constraints` and `indexes`. Any other section fails with `type error: InvalidArgumentValue: db.stats.retrieve cannot serve section '
'` | ```cypher run name=components CALL dbms.components() YIELD name, versions RETURN name, versions ``` ```table | name | versions | |----------------|--------------------| | "Neo4j Kernel" | ["2026.10-relate"] | | "Cypher" | ["5", "25"] | | "Relate" | ["0.1.2"] | 3 rows ``` ```cypher run name=graph-counts CALL db.stats.retrieve('GRAPH COUNTS') YIELD section, data RETURN section, data.indexes AS indexes ``` ```table | section | indexes | |----------------|-------------------------------------------------------------------------------------------| | "GRAPH COUNTS" | [{labels: ["Person"], properties: ["focus"]}, {labels: ["Person"], properties: ["role"]}] | 1 row ``` ## Transaction metadata | Signature | `YIELD` columns | Notes | | --------------------------------------- | --------------- | ----------------------------------------------------------------------------- | | `tx.setMetaData(metadata :: MAP)` | — | Accepts a map and returns no rows | | `tx.getMetaData() :: (metadata :: MAP)` | `metadata` | Returns `{source: "cip230"}`; a map set with `tx.setMetaData` is not returned | ## Ontology procedures The ontology procedures are a [preview feature](https://relatedb.ai/docs/reference/glossary/#preview-feature); 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](https://relatedb.ai/docs/guides/cypher/ontology/) is the task guide. | Signature | Mode | `YIELD` columns | Notes | | -------------------------------------------------------------------- | ------- | --------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | | `db.ontology.set(ontology :: STRING)` | `WRITE` | — | Validates the JSON or YAML document and stores it, replacing any earlier one. Auto-commit only, and the statement may write nothing else | | `db.ontology.get(format = "yaml" :: STRING) :: (ontology :: STRING)` | `READ` | `ontology` | The stored document as YAML, or as the stored text with `'json'`; `null` when none is stored | | `db.ontology.apply()` | `WRITE` | — | Sets the current graph type from the stored document, as `ALTER CURRENT GRAPH TYPE SET` does; fails when the data violates it | | `db.ontology.drop()` | `WRITE` | — | Removes the stored document; succeeds when none is stored. Auto-commit only | The calls on the CLI, in order. This setup step writes the shared example graph to a new single-file store, `team.rl`: ```bash verify 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`: ```bash verify 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: ```bash verify RELATE_PREVIEW=ontology relate --database ./team.rl --read-only --mode jsonl "CALL db.ontology.get() YIELD ontology RETURN ontology" ``` ```text {"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: ```bash verify RELATE_PREVIEW=ontology relate --database ./team.rl "CALL db.ontology.apply()" ``` ```bash verify relate --database ./team.rl --read-only --mode jsonl "SHOW CURRENT GRAPH TYPE" ``` ```text {"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: `. | Group | Names | | ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Change data capture | `cdc.current`, `cdc.earliest`, `cdc.query`, `db.cdc.current`, `db.cdc.earliest`, `db.cdc.query`, `db.cdc.translateId` | | Indexes and tokens | `db.awaitIndex`, `db.index.fulltext.awaitEventuallyConsistentIndexRefresh`, `db.index.fulltext.listAvailableAnalyzers`, `db.prepareForReplanning`, `db.resampleIndex`, `db.resampleOutdatedIndexes`, `db.create.setNodeVectorProperty`, `db.create.setRelationshipVectorProperty`, `db.createProperty`, `db.createRelationshipType` | | Database operations | `db.checkpoint`, `db.clearQueryCaches`, `db.listLocks`, `db.stats.clear`, `db.stats.collect`, `db.stats.retrieveAllAnonymized`, `db.stats.status`, `db.stats.stop` | | Configuration and connections | `dbms.checkConfigValue`, `dbms.setConfigValue`, `dbms.killConnection`, `dbms.killConnections`, `dbms.listActiveLocks`, `dbms.listCapabilities`, `dbms.listConnections`, `dbms.listPools`, `dbms.queryJmx`, `dbms.reloadProcedures`, `dbms.scheduler.failedJobs`, `dbms.scheduler.groups`, `dbms.scheduler.jobs`, `dbms.security.clearAuthCache`, `dbms.security.reloadTLS` | | Clustering and routing | `dbms.cluster.checkConnectivity`, `dbms.cluster.cordonServer`, `dbms.cluster.deallocateDatabaseFromServer`, `dbms.cluster.deallocateDatabaseFromServers`, `dbms.cluster.deallocateNumberOfDatabases`, `dbms.cluster.protocols`, `dbms.cluster.reallocateDatabase`, `dbms.cluster.reallocateNumberOfDatabases`, `dbms.cluster.recreateDatabase`, `dbms.cluster.routing.getRoutingTable`, `dbms.cluster.secondaryReplicationDisable`, `dbms.cluster.setAutomaticallyEnableFreeServers`, `dbms.cluster.statusCheck`, `dbms.promoteReplicaDatabase`, `dbms.recreateDatabase`, `dbms.routing.getRoutingTable`, `dbms.setDefaultAllocationNumbers`, `dbms.setDefaultDatabase`, `dbms.showTopologyGraphConfig`, `dbms.unquarantineDatabase` | | Fleet management | `fleetManagement.debugLogging`, `fleetManagement.disable`, `fleetManagement.inspectToken`, `fleetManagement.registerToken`, `fleetManagement.reportedData`, `fleetManagement.restart`, `fleetManagement.status` | ```cypher run name=catalog-only expect=error CALL db.checkpoint() ``` ```table error: syntax error: ProcedureNotFound: db.checkpoint ``` ## See also - [Functions](https://relatedb.ai/docs/reference/cypher/functions/): the built-in functions, which an expression calls without `CALL`. - [Search](https://relatedb.ai/docs/reference/cypher/search/): the `SEARCH` clause that replaces the index query procedures. - [Model an ontology](https://relatedb.ai/docs/guides/cypher/ontology/): the ontology procedures in a task. - [EXPLAIN and PROFILE](https://relatedb.ai/docs/reference/cypher/explain-and-profile/): the `ProcedureCall` operator a `CALL` plans to. - [Text-to-Cypher](https://relatedb.ai/docs/concepts/problems-relate-solves/#text-to-cypher): the schema procedures as the graph's schema for a model. ## Terms used on this page - **label**: A name that classifies a node, such as `Person`; a node has zero or more, and patterns, indexes and constraints refer to them. - **relationship type**: The single name every relationship carries, such as `KNOWS` or `WORKS_ON`; patterns match on it, and a relationship cannot change it. - **property**: 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. - **vector index**: An index over a property holding embeddings that answers nearest-neighbor searches exactly, by cosine or Euclidean similarity. - **preview 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.