Metrics

The geometry and metric come from the checkpoint's own headers, and part p lands whole on shard p modulo the shard count, wherever it was written from.

A cancelled or failed load creates no index.

Until NVMe checkpoints carry keys, it reports unsupported.

Binding-only: names the executor every call passes.

Binding-only: names the executor and the deferred completion every call passes.

Binding-only: calls count.

The rows land in arena, read in place by the result until the arena's next call.

Overlaps safely with concurrent searches on the same handle.

The input scalar type is independent of the stored quantization; the library converts on ingest. A batch is all-or-nothing, and its entries become visible at once: every fallible step runs before the first entry identity is claimed, so a thrown failure leaves the index untouched. Every entry is claimed before the handler's first report, so it reports but cannot cancel.

A build step rather than a repair: a cheap insertion pass followed by one refinement reaches a better graph, in less total time, than one expensive insertion pass - so a wide expansion factor belongs here rather than in insert. Searches may run throughout.

The result reads the arena in place until its next call. Never writes to the graph, so any number of these may overlap with concurrent insertions.

A document is one key holding its token rows, which is what a valuesPerKey above one exists for. rowsPerQuery is the token count each query occupies, queries holds them end to end, and up to wanted documents land in arena as one ragged run, one run per whole query rather than per token, largest score first; a zero wanted keeps every document the query scored. Approximate downward only: a token whose neighborhood the walk never entered contributes no maximum, so a key can score below its exact value but never above it. Runs on an inner-product index alone.

See https://arxiv.org/abs/2004.12832 - ColBERT, which introduced this scoring.

Pairs arrive in traversal order rather than sorted, and carry no duplicates. A non-zero wanted keeps the first pairs each row's walk scored, and required says how many there were. The keys, products and row offsets land in arena as one ragged run. Runs on an inner-product index alone, since a product needs logits rather than distances.

Row t · headCount + h of queries, outputs and carry is head h of token t: the headCount query heads of grouped-query attention share the index's one key-value head and one walk per token. The index stores no values, so lookup resolves the keys of every scored batch to rows of its values.

The outputs land in arena as Value rows, and come back divided by the partition. Passing a carry asks for the softmax state, one entry per query row, which folds this branch into another over the same queries by partial-softmax rescaling. Runs on an inner-product index alone, and refuses a VRAM one with device, whose walk needs a device function as its lookup.

See https://arxiv.org/abs/2205.14135 - Flash Attention, whose recurrence this reuses.

Every donor absorbed is consumed, and every later verb on one reports uninitialized; an absorb stopped early hands the rest back to their indexes once final. A donor named twice refuses with invalidArgument, and the receiver itself with configMismatch, as the library does.

Receivers must be empty and share the index's residency, scalar, class, metric, geometry and shard count, or the call answers configMismatch, and a refusal moves nothing.

Only RAM samples yet.

Demands a mutation-free window; concurrent readers keep searching throughout.

Each shard's publication watermark is read as the walk enters it, so an entry once passed is never revisited. Without starts it yields every entry as stored; with them, the start keys' own entries first in order, then the entries those link to breadth-first, each once.