neo4j · stefano-ottolenghi · Oct 9, 2025 · May 27, 2025 · May 28, 2025 · May 30, 2025
diff --git a/modules/ROOT/pages/expressions/predicates/type-predicate-expressions.adoc b/modules/ROOT/pages/expressions/predicates/type-predicate-expressions.adoc
@@ -321,6 +321,9 @@ RETURN $int16param IS :: INTEGER AS isInteger
 
 More information about parameters can be found xref::syntax/parameters.adoc[here].
 
+[NOTE]
+The xref:values-and-types/vector.adoc#vector-type[vector-only coordinate types] cannot be used as the numeric type to verify against in type predicate expressions.
+
 [[type-predicate-syntax-variation]]
 == Syntactical variations of type predicate expressions
 

diff --git a/modules/ROOT/pages/functions/index.adoc b/modules/ROOT/pages/functions/index.adoc
@@ -793,7 +793,7 @@ Vector functions allow you to compute the similarity scores of vector pairs.
 
 1.1+| xref::functions/vector.adoc#functions-vector[`vector()`]
 | `vector(vectorValue :: STRING \| LIST<INTEGER \| FLOAT>, dimension :: INTEGER, coordinateType :: [INTEGER64, INTEGER32, INTEGER16, INTEGER8, FLOAT64, FLOAT32]) :: VECTOR`
-| Constructs a `VECTOR` value with a dimension and coordinate type. label:new[Introduced in Neo4j 2025.xx]
+| Constructs a `VECTOR` value. label:new[Introduced in Neo4j 2025.xx]
 
 1.1+| xref::functions/vector.adoc#functions-similarity-cosine[`vector.similarity.cosine()`]
 | `vector.similarity.cosine(a :: VECTOR \| LIST<INTEGER \| FLOAT>, b :: VECTOR \| LIST<INTEGER \| FLOAT>) :: FLOAT`
@@ -805,7 +805,7 @@ Vector functions allow you to compute the similarity scores of vector pairs.
 
 1.1+| xref::functions/vector.adoc#functions-vector_dimension_count[`vector_dimension_count()`]
 | `(vector :: VECTOR) :: INTEGER`
-| Calculates the size of a vector. label:new[Introduced in Neo4j 2025.xx]
+| Returns the dimension of a `VECTOR`. label:new[Introduced in Neo4j 2025.xx]
 
 1.1+| xref::functions/vector.adoc#functions-vector_distance[`vector_distance()`]
 | `(vector1 :: VECTOR, vector2 :: VECTOR, vectorDistanceMetric :: [EUCLIDEAN, EUCLIDEAN_SQUARED, MANHATTAN, COSINE, DOT, HAMMING]) :: FLOAT`

diff --git a/modules/ROOT/pages/functions/vector.adoc b/modules/ROOT/pages/functions/vector.adoc
@@ -11,40 +11,30 @@ Vector functions allow you to construct xref:values-and-types/vector.adoc[`VECTO
 
 .Details
 |===
-| *Syntax* 3+| `vector(vectorValue[, dimension, coordinateType])`
-| *Description* 3+| Constructs a `VECTOR` value with a dimension and coordinate type.
+| *Syntax* 3+| `vector(vectorValue, dimension, coordinateType)`
+| *Description* 3+| Constructs a `VECTOR` value.
 .4+| *Arguments* | *Name* | *Type* | *Description*
-| `vectorValue` | `STRING` \| `LIST<INTEGER \| FLOAT>` | The numeric values to create the vector coordinate from.
- or `FLOAT` values, or a `STRING` defining the coordinates in the resulting `VECTOR`.
-| `dimension` | `INTEGER` | The number of dimensions (coordinates) in the vector.
+| `vectorValue` | `STRING` \| `LIST<INTEGER \| FLOAT>` | The numeric values to create the vector coordinates from.
+| `dimension` | `INTEGER` | The dimension (number of coordinates) of the vector.
 | `coordinateType` | `[INTEGER64, INTEGER32, INTEGER16, INTEGER8, FLOAT64, FLOAT32]` | The type of each coordinate in the vector.
 | *Returns* 3+| `VECTOR`
 |===
 
 [NOTE]
 The `VECTOR` values generated by the `vector()` function can be xref:values-and-types/vector.adoc#store-vector-properties[stored as properties].
 As such, the `vector()` function can be used to store the embeddings generated by Neo4j's xref:genai-integrations.adoc[GenAI plugin] as `VECTOR` property values.
-`VECTOR` properties can semantically searched by a xref:indexes/semantic-indexes/vector-indexes.adoc[vector index].
-
-
+`VECTOR` properties can be semantically searched by a xref:indexes/semantic-indexes/vector-indexes.adoc[vector index].
 
 .Considerations
 |===
 
 | If a `STRING` is used in `vectorValue`, it must start and end with square brackets (`[]`).
 The values inside the brackets must be a number represented in either decimal or scientific notation and must be comma separated.
-| `null`, NaN, and infinity values are not allowed in `vectorValue`.
+| `null`, `NaN`, and `Infinity` values are not allowed as elements in the `LIST` used as `vectorValue`.
 | If `vectorValue` contain elements that are not of the specified `coordinateType`, they will be coerced to that coordinate type if possible.
 This includes the potential of lossy conversion in cases where a larger type, e.g. `INTEGER64` does not fit into the specified type, e.g. `FLOAT32`.
-| If `dimension` is omitted, it is calculated by taking the size of the `vectorValue`.
-For example a `vectorValue` with 1024 elements generates a `VECTOR` value with the dimension `1024`.
 | `dimension` must be greater than `0` and less than or equal to `4096`.
-| If `coordinateType` is omitted, the type will be determined by Cypher.
-If the `LIST` used as `vectorValue` is mixed containing exclusively `INTEGER` values, then the largest of those types will be set as the `coordinateType`.
-For example, `LIST<INTEGER64 \| INTEGER32`> generates a `VECTOR` value with a `coordinateType` of `INTEGER64`.
-If the `vectorValue` contains both `FLOAT` and `INTEGER` values, then the `coordinateType` will be that of the largest `FLOAT` present in `vectorValue`.
-For example, `LIST<INTEGER64 \| FLOAT64`> generates a `VECTOR` value with a `coordinateType` of `FLOAT64`.
-| A `null` `vectorValue`, `dimension`, or `coordinateType` will return `null`.
+| A `null` `vectorValue` or `dimension` will return `null`.
 |===
 
 .vector()
@@ -62,7 +52,7 @@ RETURN vector, valueType(vector) AS vectorType
 |===
 | vector | vectorType
 
-| [1, 2, 3] | "VECTOR<INTEGER64 NOT NULL>(3) NOT NULL"
+| [1, 2, 3] | "VECTOR<INTEGER NOT NULL>(3) NOT NULL"
 
 2+d|Rows: 1
 |===
@@ -85,39 +75,21 @@ RETURN vector, valueType(vector) AS vectorType
 2+d|Rows: 1
 |===
 
-.Construct a `VECTOR` value omitting both `dimension` and `coordinateType`
-[source, cypher]
-----
-WITH vector([1, 2.5, 3]) AS vector
-RETURN vector, valueType(vector) AS vectorType
-----
-
-.Result
-[role="queryresult",options="header,footer",cols="2*<m"]
-|===
-| vector | vectorType
-
-| [1, 2, 3] | "VECTOR<FLOAT64 NOT NULL>(3) NOT NULL"
-
-2+d|Rows: 1
-|===
-
 .`null` values
 [source, cypher]
 ----
 RETURN vector(null, 3, FLOAT32) AS nullVectorValue,
-       vector([1, 2, 3], null, INTEGER8) AS nullDimension,
-       vector([1, 2, 3], 3, null) AS nullCoordinateType
+       vector([1, 2, 3], null, INTEGER8) AS nullDimension
 ----
 
 .Result
-[role="queryresult",options="header,footer",cols="3*<m"]
+[role="queryresult",options="header,footer",cols="2*<m"]
 |===
-| nullVectorValue | nullDimension | nullCoordinateType
+| nullVectorValue | nullDimension
 
-| null | null | null
+| null | null
 
-3+d|Rows: 1
+2+d|Rows: 1
 |===
 
 =====
@@ -130,8 +102,8 @@ RETURN vector(null, 3, FLOAT32) AS nullVectorValue,
 | *Syntax* 3+| `vector.similarity.cosine(a, b)`
 | *Description* 3+| Returns a `FLOAT` representing the similarity between the argument vectors based on their cosine.
 .3+| *Arguments* | *Name* | *Type* | *Description*
-| `a` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` | A list representing the first vector.
-| `b` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` | A list representing the second vector.
+| `a` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` |  A vector or list value representing the first vector.
+| `b` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` | A vector or list value representing the second vector.
 | *Returns* 3+| `FLOAT`
 |===
 
@@ -161,8 +133,8 @@ The similarity score range from `0` and `1`, with scores closer to `1` indicatin
 | *Syntax* 3+| `vector.similarity.euclidean(a, b)`
 | *Description* 3+| Returns a `FLOAT` representing the similarity between the argument vectors based on their Euclidean distance.
 .3+| *Arguments* | *Name* | *Type* | *Description*
-| `a` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` | A list representing the first vector.
-| `b` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` | A list representing the second vector.
+| `a` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` | A vector or list value representing the first vector.
+| `b` | `VECTOR` \| `LIST<INTEGER \| FLOAT>` |  A vector or list value representing the second vector.
 | *Returns* 3+| `FLOAT`
 |===
 
@@ -246,7 +218,7 @@ This returns the two nearest neighbors.
 .Details
 |===
 | *Syntax* 3+| `vector_dimension_count(vector)`
-| *Description* 3+| Calculates the dimension of a `VECTOR`.
+| *Description* 3+| Returns the dimension of a `VECTOR`.
 .2+| *Arguments* | *Name* | *Type* | *Description*
 | `vector` | `VECTOR` | The vector to calculate the dimension of.
 | *Returns* 3+| `INTEGER`
@@ -256,7 +228,7 @@ This returns the two nearest neighbors.
 |===
 
 | If `vector` is not a xref:values-and-types/vector.adoc[`VECTOR`] value, an error will be thrown.
-| Alias to the xref:functions/scalar.adoc#functions-size[`size()`] function.
+| The xref:functions/scalar.adoc#functions-size[`size()`] function can also be used to return the dimension of a `VECTOR` value.
 
 |===
 
@@ -378,7 +350,7 @@ RETURN vector_distance(vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), vector([5.0, 2.5,
 .Details
 |===
 | *Syntax* 3+| `vector_norm(vector, vectorDistanceMetric)`
-| *Description* 3+|  Returns a `FLOAT` representing the norm (distance) between the given vector and an origin vector of the same dimension with all coordinates set to zero, calculated using the specified `vectorDistanceMetric`.
+| *Description* 3+|  Returns a `FLOAT` representing the distance between the given vector and an origin vector, which is a vector with the same dimension with all coordinates set to zero, calculated using the specified `vectorDistanceMetric`.
 .4+| *Arguments* | *Name* | *Type* | *Description*
 | `vector` | `VECTOR` | A vector for which the norm to the origin vector will be computed.
 | `vectorDistanceMetric` | `[EUCLIDEAN, MANHATTAN]` | The vector distance algorithm to calculate the distance by.
@@ -422,7 +394,7 @@ RETURN vector_norm(vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), EUCLIDEAN) AS norm
 .Measure the norm between a vector and an origin vector using the `EUCLIDEAN` distance algorithm
 [source, cypher]
 ----
-RETURN vector_norm(Vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), 'MANHATTAN') AS norm
+RETURN vector_norm(vector([1.0, 5.0, 3.0, 6.7], 4, FLOAT), MANHATTAN) AS norm
 ----
 
 .Result

diff --git a/modules/ROOT/pages/genai-integrations.adoc b/modules/ROOT/pages/genai-integrations.adoc
@@ -42,7 +42,7 @@ Dump files can be imported for both link:{neo4j-docs-base-uri}/aura/auradb/impor
 The embeddings on this are generated using link:https://platform.openai.com/docs/guides/embeddings[OpenAI] (model `text-embedding-ada-002`), producing 1536-dimensional vectors.
 
 [[single-embedding]]
-== Generate a single embedding
+== Generate a single embedding and store it
 
 Use the `genai.vector.encode()` function to generate a vector embedding for a single value.
 
@@ -66,23 +66,23 @@ This function sends one API request every time it is called, which may result in
 If you want to generate many embeddings at once, use xref:genai-integrations.adoc#multiple-embeddings[].
 ====
 
-[role=label--new-2025.xx label--enterprise-edition]
-[[store-single-embedding-vector]]
-=== Store a single embedding as a VECTOR property
+
+[.tabbed-example]
+====
+[.include-with-Store-embedding-as-a-vector]
+======
 
 `genai.vector.encode()` returns a `LIST<FLOAT>`.
-To convert and store this value as a xref:values-and-types/vector.adoc[`VECTOR` property type], use the xref:functions/vector.adoc#functions-vector[`vector()`] function.
+To convert and store this value as a xref:values-and-types/vector.adoc[`VECTOR` property type (introduced in Neo4j 2025.xx)], use the xref:functions/vector.adoc#functions-vector[`vector()`] function.
+Storing `VECTOR` values on an on-prem instance requires Enterprise Edition and using Neo4j's link:{neo4j-docs-base-uri}/operations-manual/current/database-internals/store-formats/#store-format-overview[block format].
 
 .Signature for `vector()` label:function[]
 [source]
 ----
 vector(vectorValue :: STRING | LIST<INTEGER | FLOAT>, dimension :: INTEGER, coordinateType :: [INTEGER64, INTEGER32, INTEGER16, INTEGER8, FLOAT64, FLOAT32]) :: VECTOR
 ----
 
-.Create an embedding from a single property and store it as a `VECTOR` property value
-====
-
-.Create an `VECTOR` embedding property for the Godfather
+.Create a `VECTOR` embedding property for the Godfather
 [source,cypher,role=test-skip]
 ----
 MATCH (m:Movie {title:'Godfather, The'})
@@ -96,24 +96,11 @@ RETURN m.embedding AS embedding
 <1> Concatenate the `title` and `plot` of the `Movie` into a single `STRING`.
 <2> Create a 1536 dimensional embedding from the `titleAndPlot`.
 <3> Store the `propertyVector` as a new `VECTOR` `embedding` property on The Godfather node.
+======
 
-.Result
-[source, "queryresult"]
-----
-+----------------------------------------------------------------------------------------------------+
-| embedding                                                                                          |
-+----------------------------------------------------------------------------------------------------+
-| [0.005239539314061403, -0.039358530193567276, -0.0005175105179660022, -0.038706034421920776, ... ] |
-+----------------------------------------------------------------------------------------------------+
-----
-
-[NOTE]
-This result only shows the first 4 of the 1536 numbers in the embedding.
-
-====
 
-[[store-single-embedding-list-float]]
-=== Store a single embedding as a LIST<FLOAT> property
+[.include-with-Store-embedding-as-a-list]
+======
 
 Use the `db.create.setNodeVectorProperty` procedure to store an embedding as a `LIST<FLOAT>` value to a node property.
 
@@ -137,9 +124,6 @@ db.create.setRelationshipVectorProperty(relationship :: RELATIONSHIP, key :: STR
 
 The embeddings are stored as properties on nodes or relationships with the type `LIST<INTEGER | FLOAT>`.
 
-.Create an embedding from a single property and store it as a `LIST<FLOAT>` property value
-====
-
 .Create a `LIST<FLOAT>` embedding property for the Godfather
 [source,cypher,role=test-skip]
 ----
@@ -155,6 +139,10 @@ RETURN m.embedding AS embedding
 <2> Create a 1536 dimensional embedding from the `titleAndPlot`.
 <3> Store the `propertyVector` as a new `LIST<FLOAT> `embedding` property on The Godfather node.
 
+======
+====
+
+
 .Result
 [source, "queryresult"]
 ----
@@ -168,10 +156,8 @@ RETURN m.embedding AS embedding
 [NOTE]
 This result only shows the first 4 of the 1536 numbers in the embedding.
 
-====
-
 [[multiple-embeddings]]
-== Generate a batch of embeddings
+== Generate a batch of embeddings and store them
 
 Use the `genai.vector.encodeBatch()` procedure to generate many vector embeddings with a single API request.
 This procedure takes a list of resources as an input, and returns the same number of result rows, instead of a single one.
@@ -202,18 +188,25 @@ Each returned row contains the following columns:
 * The `resource` (a `STRING`) is the name of the input resource.
 * The `vector` (a `LIST<FLOAT>`) is the generated vector embedding for this resource.
 
-[[store-multiple-embeddings-vector]]
-[role=label--new-2025.xx label--enterprise-edition]
-=== Store multiple embeddings as VECTOR property values
 
-`genai.vector.encodeBatch()` returns a `LIST<FLOAT>` value.
-To convert and store this value as a xref:values-and-types/vector.adoc[`VECTOR` property type], use the xref:functions/vector.adoc#functions-vector[`vector()`] function.
-The full function signature can be seen xref:genai-integrations.adoc#store-single-embedding-vector[above].
 
-.Create embeddings from a limited number of properties and store them as `VECTOR` properties
+[.tabbed-example]
 ====
+[.include-with-Store-embeddings-as-vectors]
+======
 
-[source, cypher, role=test-skip]
+`genai.vector.encode()` returns a `LIST<FLOAT>`.
+To convert and store this value as a xref:values-and-types/vector.adoc[`VECTOR` property type (introduced in Neo4j 2025.xx)], use the xref:functions/vector.adoc#functions-vector[`vector()`] function.
+Storing `VECTOR` values on an on-prem instance requires Enterprise Edition and using Neo4j's link:{neo4j-docs-base-uri}/operations-manual/current/database-internals/store-formats/#store-format-overview[block format].
+
+.Signature for `vector()` label:function[]
+[source]
+----
+vector(vectorValue :: STRING | LIST<INTEGER | FLOAT>, dimension :: INTEGER, coordinateType :: [INTEGER64, INTEGER32, INTEGER16, INTEGER8, FLOAT64, FLOAT32]) :: VECTOR
+----
+
+.Create embeddings from a limited number of properties and store them as `VECTOR` properties
+[source,cypher,role=test-skip]
 ----
 MATCH (m:Movie WHERE m.plot IS NOT NULL)
 WITH m
@@ -228,10 +221,8 @@ CALL db.create.setNodeVectorProperty(moviesList[index], 'embedding', vector) //
 <1> xref:functions/aggregating.adoc#functions-collect[Collect] all  20 `Movie` nodes into a `LIST<NODE>`.
 <2> Use a xref:expressions/list-expressions.adoc#list-comprehension[list comprehension] (`[]`) to extract the `title` and `plot` properties of the movies in `moviesList` into a new `LIST<STRING>`.
 <3> `db.create.setNodeVectorProperty` is run for each `vector` returned by `genai.vector.encodeBatch()`, and stores that vector as a property named `embedding` on the corresponding node.
-====
 
 .Create embeddings from a large number properties and store them as `VECTOR` properties
-====
 [source, cypher, role=test-skip]
 ----
 MATCH (m:Movie WHERE m.plot IS NOT NULL)
@@ -263,18 +254,35 @@ For more information on concurrency in transactions, see xref:subqueries/subquer
 This example may not scale to larger datasets, as `collect(m)` requires the whole result set to be loaded in memory.
 For an alternative method more suitable to processing large amounts of data, see link:https://neo4j.com/docs/genai/tutorials/embeddings-vector-indexes/[GenAI documentation - Embeddings & Vector Indexes Tutorial -> Create embeddings with cloud AI providers].
 
-====
+======
 
-[[store-multiple-embeddings-list-float]]
-=== Store multiple embeddings as `LIST<FLOAT>` properties
+
+[.include-with-Store-embeddings-as-lists]
+======
 
 Use the `db.create.setNodeVectorProperty` procedure to store an embedding as a `LIST<FLOAT>` value to a node property.
+
+.Signature for `db.create.setNodeVectorProperty` label:procedure[]
+[source,syntax]
+----
+db.create.setNodeVectorProperty(node :: NODE, key :: STRING, vector :: ANY)
+----
+
 Use the `db.create.setRelationshipVectorProperty` procedure to store an embedding as a `LIST<FLOAT>` value to a relationship property.
-The full procedure signatures can be seen xref:genai-integrations.adoc#store-single-embedding-list-float[above].
 
-.Create embeddings from a limited number of properties and store them as `LIST<FLOAT>` properties
-====
+.Signature for `db.create.setRelationshipVectorProperty` label:procedure[] 
+[source,syntax]
+----
+db.create.setRelationshipVectorProperty(relationship :: RELATIONSHIP, key :: STRING, vector :: ANY)
+----
+
+* `node` or `relationship` is the entity in which the new property will be stored.
+* `key` (a `STRING`) is the name of the new property containing the embedding.
+* `vector` is the object containing the embedding.
+
+The embeddings are stored as properties on nodes or relationships with the type `LIST<INTEGER | FLOAT>`.
 
+.Create embeddings from a limited number of properties and store them as `LIST<FLOAT>` properties
 [source, cypher, role=test-skip]
 ----
 MATCH (m:Movie WHERE m.plot IS NOT NULL)
@@ -290,10 +298,8 @@ CALL db.create.setNodeVectorProperty(moviesList[index], 'embedding', vector) //
 <1> xref:functions/aggregating.adoc#functions-collect[Collect] all  20 `Movie` nodes into a `LIST<NODE>`.
 <2> Use a xref:expressions/list-expressions.adoc#list-comprehension[list comprehension] (`[]`) to extract the `title` and `plot` properties of the movies in `moviesList` into a new `LIST<STRING>`.
 <3> `db.create.setNodeVectorProperty` is run for each `vector` returned by `genai.vector.encodeBatch()`, and stores that vector as a property named `embedding` on the corresponding node.
-====
 
 .Create embeddings from a large number properties and store them as `LIST<FLOAT>` values
-====
 [source, cypher, role=test-skip]
 ----
 MATCH (m:Movie WHERE m.plot IS NOT NULL)
@@ -325,6 +331,7 @@ For more information on concurrency in transactions, see xref:subqueries/subquer
 This example may not scale to larger datasets, as `collect(m)` requires the whole result set to be loaded in memory.
 For an alternative method more suitable to processing large amounts of data, see link:https://neo4j.com/docs/genai/tutorials/embeddings-vector-indexes/[GenAI documentation - Embeddings & Vector Indexes Tutorial -> Create embeddings with cloud AI providers].
 
+======
 ====
 
 [[ai-providers]]