@@ -506,6 +506,8 @@ db.insert_many(type_name: str, rows, commit_every: int = 10_000,
                parallel: bool = False) -> int
 ```
 
+Float vectors take a binary path: for a property declared `ARRAY_OF_FLOATS` whose value in every row of a chunk is a list or a numpy array of numbers of one length, the vectors of the chunk cross as one `float32` matrix beside the JSON, instead of as text. The stored values are the list's (the engine converts a list for such a property to float). A property that is not declared `ARRAY_OF_FLOATS`, or a vector that is ragged, missing or null in a row, stays in the JSON.
+
 Bulk-insert documents with **one FFI crossing per chunk of rows** instead of
 several JNI calls per row. The iterable is read 10,000 rows at a time and each
 chunk is serialized to one JSON string and looped Java-side, so memory stays
@@ -595,6 +597,8 @@ row-wise bridges gained only 2-12% (tuples plus `dict(zip())`, `DataFrame.to_jso
 Same failure contract as `insert_many`: the transaction the call opened is
 rolled back on any failure, a transaction the caller opened is left to the caller.
 
+A column can also be a 2-D numpy `float32` array: a column of vectors. The whole matrix crosses as one `float[]` (one buffer copy) and each document gets one row of it, which is what an `ARRAY_OF_FLOATS` property stores; no list, no JSON text. Another dtype (cast with `astype(np.float32)`), or a matrix with no columns, raises `ValueError`.
+
 **Parameters:**
 
 - `type_name` (str): Target document type (must exist)
 
@@ -332,7 +332,8 @@ also the default. If you explicitly disable eager preparation, the first call to
   ArcadeDB's default/adaptive search behavior. Anything but a positive integer raises
   `ArcadeDBError`.
 - `allowed_rids` (List[str]): Optional list of RID strings (e.g. `["#1:0", "#2:5"]`) to
-  restrict search (default: `None`)
+  restrict search (default: `None`). RIDs given as text become the filter set in one bridge
+  call; a list that holds RID objects is added one by one.
 
 **Returns:**
 
 
@@ -0,0 +1,102 @@
+{
+  "format": 1,
+  "figure": "float-vector-crossing",
+  "environment": {
+    "engine_version": "26.11.1",
+    "wheel_version": "26.11.1.dev0",
+    "cores": "2 (pinned)",
+    "machine": "x86-64 laptop, 16 cores"
+  },
+  "comparisons": [
+    {
+      "case": "insert_many, 100,000 dict rows, 128-d float32, chunks of 20,000",
+      "metric": "time",
+      "unit": "ms",
+      "better": "lower",
+      "a": "before",
+      "b": "one buffer",
+      "a_median": 14214.9033,
+      "b_median": 2620.5005,
+      "ratio": 0.185,
+      "ci_low": 0.18,
+      "ci_high": 0.191,
+      "clean_pairs": 10,
+      "dropped_pairs": 2,
+      "sign_b_better": 10,
+      "sign_b_worse": 0,
+      "sign_p": 0.00195
+    },
+    {
+      "case": "insert_columns, 100,000 rows, 128-d float32",
+      "metric": "time",
+      "unit": "ms",
+      "better": "lower",
+      "a": "before",
+      "b": "one buffer",
+      "a_median": 609.405986,
+      "b_median": 520.802979,
+      "ratio": 0.862,
+      "ci_low": 0.833,
+      "ci_high": 0.947,
+      "clean_pairs": 10,
+      "dropped_pairs": 2,
+      "sign_b_better": 8,
+      "sign_b_worse": 2,
+      "sign_p": 0.109
+    },
+    {
+      "case": "graph_batch create_vertices, 50,000 rows, 128-d float32",
+      "metric": "time",
+      "unit": "ms",
+      "better": "lower",
+      "a": "before",
+      "b": "one buffer",
+      "a_median": 3596.351745,
+      "b_median": 1082.5297249999999,
+      "ratio": 0.3,
+      "ci_low": 0.289,
+      "ci_high": 0.315,
+      "clean_pairs": 10,
+      "dropped_pairs": 2,
+      "sign_b_better": 10,
+      "sign_b_worse": 0,
+      "sign_p": 0.00195
+    },
+    {
+      "case": "find_nearest(k=10) with 5,000 allowed RIDs, 200 queries, 20,000 vectors",
+      "metric": "time",
+      "unit": "ms",
+      "better": "lower",
+      "a": "before",
+      "b": "one buffer",
+      "a_median": 2295.743685,
+      "b_median": 568.9830085000001,
+      "ratio": 0.246,
+      "ci_low": 0.235,
+      "ci_high": 0.257,
+      "clean_pairs": 10,
+      "dropped_pairs": 2,
+      "sign_b_better": 10,
+      "sign_b_worse": 0,
+      "sign_p": 0.00195
+    },
+    {
+      "case": "all four steps of the probe",
+      "metric": "total time",
+      "unit": "ms",
+      "better": "lower",
+      "a": "before",
+      "b": "one buffer",
+      "a_median": 20605.23805,
+      "b_median": 4784.8637,
+      "ratio": 0.232,
+      "ci_low": 0.23,
+      "ci_high": 0.236,
+      "clean_pairs": 10,
+      "dropped_pairs": 2,
+      "sign_b_better": 10,
+      "sign_b_worse": 0,
+      "sign_p": 0.00195
+    }
+  ]
+}
@@ -6,13 +6,14 @@ sources live in `bindings/python/src/java/com/arcadedb/python/`:
 |---|---|
 | `RowBatcher` | Serializes up to N result rows into one JSON-array string per call (batched row transport) |
 | `ColumnBatcher` | Encodes up to N rows into one `byte[]` of typed little-endian column buffers plus null bitmaps (binary columnar transport) |
-| `DocumentBatcher` | Inserts a whole batch of documents from one JSON-rows string (transactional or async parallel writers), or from whole typed columns (`insertColumns`, one `long[]`, `double[]`, `boolean[]`, or `Object[]` per property); also boxes numpy numeric arrays for `append_samples` |
+| `DocumentBatcher` | Inserts a whole batch of documents from one JSON-rows string (transactional or async parallel writers), or from whole typed columns (`insertColumns`, one `long[]`, `double[]`, `boolean[]`, or `Object[]` per property); also boxes numpy numeric arrays for `append_samples`; a float vector of an `ARRAY_OF_FLOATS` property crosses as a binary `FloatVectors.Matrix` beside the JSON (`insertManyJson`) or as a whole 2-D `float32` column |
 | `EdgeBatcher` | Buffers a whole batch of edges into `GraphBatch` from one call (RID strings, or JSON rows for edges with properties) |
 | `VertexBatcher` | Creates a whole batch of vertices from one JSON-rows string, returning all RIDs as one joined string |
 | `TimeSeriesBatcher` | Fills the engine's primitive `TimeSeriesBatch` one column per call, so numeric samples are never boxed |
 | `RowAccess` | Hands a row's names and values to Python in one call (`namesAndValues`), and up to N such rows per call (`nextRows`, the fallback for `to_list()` when the bridge jar lacks `TypedRows`); the values are the engine's own objects, so Python converts them with full type fidelity. Also the first row of a result set with the set closed (`firstAndClose`, behind `ResultSet.first()`) and a property or null (`propertyOrNull`, behind `Result.get()`), each in one call instead of two or three |
 | `TypedRows` | Up to N rows per call as one JSON string, type-faithful (`nextRows`, which also reports whether the result set is drained): DECIMAL, BigInteger, DATE, DATETIME, Instant and zoned values, and sets are tagged and restored exactly by Python, and every other value (RIDs, embedded documents, `float[]` and `double[]`, non-finite floats, maps with non-String keys, years Python cannot hold) is returned in a side array as the engine's own object and converted by Python as before. Behind `ResultSet.to_list()` (up to 1,000 rows or 4 MiB of JSON per call, whichever comes first) and `ResultSet.iter_dicts()` (one row per call, so a lazy caller reads rows when it asks) |
-| `GraphCalls` | Every edge of `Vertex.getEdges(direction, labels)` in one call (`outEdges`, `inEdges`, `bothEdges`, behind `Vertex.get_out_edges()` and its siblings), and the record and score of every vector search hit in one call (`hits`, behind `LSMVectorIndex` search results) |
+| `FloatVectors` | Float vectors as one binary buffer instead of JSON text or a JPype call per element: `Matrix` (n vectors in one `float[]`, a row copied into each document), and `declared` (which properties of a type are `ARRAY_OF_FLOATS`); behind `insert_many()`, `insert_columns()` and `GraphBatch.create_vertices()` |
+| `GraphCalls` | Every edge of `Vertex.getEdges(direction, labels)` in one call (`outEdges`, `inEdges`, `bothEdges`, behind `Vertex.get_out_edges()` and its siblings), and the record and score of every vector search hit in one call (`hits`, behind `LSMVectorIndex` search results), and the `allowed_rids` set of a vector search from RID strings in one call (`ridSet`) |
 | `DbCalls` | One-row statements and lookups in one call: `commandNamed`, `queryNamed`, `commandPositional`, and `queryPositional` take the parameters as the varargs of a single non-overloaded method and build the map Java-side (behind `Database.command()` and `Database.query()`), and `lookupFirst` is the whole of `Database.lookup_by_key()` |
 | `PythonFunctions` | Registers a Python callable as an engine `SQLFunction` in the process-wide function factory (so SQL and openCypher resolve it): the arity check, one `CommandExecutionException` naming the function for any failure of the callable, and a revoked flag so an unregistered function fails clearly. Behind `Database.register_function()` and `unregister_function()`. Each call is one JNI round trip |
 | `PythonRecordEvents` | One listener class for the six write events (before and after create, update, delete) that forwards each to a Python callback; a `false` from a before event is the veto, and a failure is wrapped in a `DatabaseOperationException` naming the event. Behind `Database.on()` |
@@ -41,10 +42,10 @@ crossing per batch**, receiving a bulk payload it can decode at C speed: the
 | `ResultSet.to_json_list()` / `iter_json_batches()` | `RowBatcher` |
 | `ResultSet.to_list()` (rows in batches), `ResultSet.iter_dicts()` (one row per call) | `TypedRows` |
 | `Result.to_dict()` (one row) | `RowAccess` |
-| `Vertex.get_out_edges()` / `get_in_edges()` / `get_both_edges()`, vector search results | `GraphCalls` |
+| `Vertex.get_out_edges()` / `get_in_edges()` / `get_both_edges()`, vector search results and their `allowed_rids` set | `GraphCalls` |
 | `ResultSet.to_columns()` / fast `to_dataframe()` / `to_arrow()` | `ColumnBatcher` |
-| `Database.insert_many()` | `DocumentBatcher` |
-| `Database.insert_columns()` | `DocumentBatcher` |
+| `Database.insert_many()` | `DocumentBatcher`, `FloatVectors` (vector properties) |
+| `Database.insert_columns()` | `DocumentBatcher`, `FloatVectors` (a 2-D `float32` column) |
 | `Database.insert_dataframe()` / `insert_arrow()` | `DocumentBatcher` (document types, through `insert_columns()`), `VertexBatcher` (vertex types, through `GraphBatch.create_vertices()`); the Arrow-to-column conversion is Python (`dataframe.py`) |
 | `ResultSet.to_polars()` | `ColumnBatcher` (through `to_arrow()`) |
 | `AsyncExecutor.append_samples()` (numpy numeric-column boxing) | `DocumentBatcher` |
 
@@ -273,6 +273,43 @@ Notes:
 - For euclidean, skip normalization if magnitude should matter. For dot_product,
   normalize: the engine expects unit-length vectors.
 
+### Loading many vectors
+
+Declare the property `ARRAY_OF_FLOATS`, then load the vectors in bulk. The vectors of a chunk cross the bridge as one `float32` buffer, not as JSON text and not one JPype call per element:
+
+```python
+db.command("sql", "CREATE DOCUMENT TYPE Doc")
+db.command("sql", "CREATE PROPERTY Doc.embedding ARRAY_OF_FLOATS")
+
+# rows with a list or a numpy array per vector (the property must be declared ARRAY_OF_FLOATS)
+db.insert_many("Doc", [{"id": i, "embedding": x[i]} for i in range(len(x))])
+
+# or whole columns: a 2-D float32 matrix is one column of vectors
+db.insert_columns("Doc", {"id": ids, "embedding": x})  # x: float32, shape (n, dims)
+
+# a graph load takes the same rows
+with db.graph_batch() as gb:
+    gb.create_vertices("Vx", [{"id": i, "embedding": x[i]} for i in range(len(x))])
+```
+
+A `float64` list or array stores the same values it always did (the engine converts it to float for this property). Declaring the property is what makes the path apply: an undeclared property keeps the exact doubles in a list. A numpy array is accepted wherever a vector is a property value (`Document.set`, `insert_many`, `create_vertices`).
+
+The figures below compare the bindings before this change (A, JSON text or one JPype call per element) with the bindings after it (B, one binary buffer), built from one base wheel so the engine jars and the JVM are identical. The workload is 128-d `float32` vectors on an `ARRAY_OF_FLOATS` property, a JVM heap of 4 GB, one fresh process per run. `insert_columns` takes a different path in A: a wheel without 2-D columns offers one `float[]` per row, so its row compares that best case with the 2-D column.
+
+<!-- ab-table: float-vector-crossing -->
+| Case | Metric | A | B | A median | B median | B vs A (95% interval) | Sign test (B) | Verdict | Clean pairs |
+|---|---|---|---|---|---|---|---|---|---|
+| insert_many, 100,000 dict rows, 128-d float32, chunks of 20,000 | time (ms, lower is better) | before | one buffer | 14,215 | 2,621 | 0.185 (0.180 to 0.191) | 10 better, 0 worse, p = 0.00195 | B better by 81 to 82 percent | 10 (2 dropped) |
+| insert_columns, 100,000 rows, 128-d float32 | time (ms, lower is better) | before | one buffer | 609 | 521 | 0.862 (0.833 to 0.947) | 8 better, 2 worse, p = 0.109 | B better by 5 to 17 percent | 10 (2 dropped) |
+| graph_batch create_vertices, 50,000 rows, 128-d float32 | time (ms, lower is better) | before | one buffer | 3,596 | 1,083 | 0.300 (0.289 to 0.315) | 10 better, 0 worse, p = 0.00195 | B better by 68 to 71 percent | 10 (2 dropped) |
+| find_nearest(k=10) with 5,000 allowed RIDs, 200 queries, 20,000 vectors | time (ms, lower is better) | before | one buffer | 2,296 | 569 | 0.246 (0.235 to 0.257) | 10 better, 0 worse, p = 0.00195 | B better by 74 to 76 percent | 10 (2 dropped) |
+| all four steps of the probe | total time (ms, lower is better) | before | one buffer | 20,605 | 4,785 | 0.232 (0.230 to 0.236) | 10 better, 0 worse, p = 0.00195 | B better by 76 to 77 percent | 10 (2 dropped) |
+
+Medians are over the clean pairs of interleaved runs, one fresh process per run, round 0 dropped. B vs A is the median of the per-round ratios with its bootstrap 95% interval; above 1.000 means B is worse (B / A for a time, A / B for a rate). A verdict needs the interval to exclude 1.000 and at least 7 clean pairs.
+
+Engine 26.11.1, wheel 26.11.1.dev0, cores 2 (pinned), machine x86-64 laptop, 16 cores.
+<!-- /ab-table -->
+
 ## Preferred Search Surface: SQL / Cypher
 
 For new code, prefer query APIs for search. Bind the query vector as a parameter
 
@@ -73,6 +73,7 @@
     "udf-cost": "Python function in SQL against the equivalent SQL expression",
     "callback-cost": "Per-record callback cost of Database.on(...)",
     "heap-pinned": "JVM heap pinned (-Xms equal to -Xmx) against unpinned",
+    "float-vector-crossing": "Float vectors across the bridge as one binary buffer against JSON text or one JPype call per element",
 }
 
 OPEN = re.compile(r"<!-- ab-table: (?P<id>[A-Za-z0-9_-]+) -->")
Original file line number	Diff line number	Diff line change
`@@ -73,6 +73,7 @@`
`73`	`73`	`"udf-cost": "Python function in SQL against the equivalent SQL expression",`
`74`	`74`	`"callback-cost": "Per-record callback cost of Database.on(...)",`
`75`	`75`	`"heap-pinned": "JVM heap pinned (-Xms equal to -Xmx) against unpinned",`
	`76`	`+ "float-vector-crossing": "Float vectors across the bridge as one binary buffer against JSON text or one JPype call per element",`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`OPEN = re.compile(r"<!-- ab-table: (?P<id>[A-Za-z0-9_-]+) -->")`