Capability

GPU vector search and corpus analytics

Vectors that stay out of the database yet verifiably tied to it, searched and scored on the GPU

Rust · CUDA driver APINative Blackwell binariesPostgreSQL as the source of truth
The database holds the rows · the GPU holds the lease
38health metrics per cluster,
each with a CPU twin
  • 0.85recall at ten against exact search, the inverted-file floor asserted in continuous integration
  • 10⁻⁴relative tolerance between every kernel and its CPU reference
  • ~100 sto rebuild the GPU files from four million rows, the cost a delta build avoids

Embeddings are often too large and too hot for the relational database, and the moment they leave it there is no way to say which row a vector belongs to, or whether the index being searched is any good.

I built vector storage leased to the GPU that stays verifiably tied to its relational source, with index-quality reporting so retrieval health is visible. See An index you can rebuild from its receipt and The database decides when an index goes stale.

The receipt every build carries
Configuration
Training set
Artifact, first build
Artifact, rebuilt
Artifact, shuffled input
When the data moves

A shard's journal advances on an append (orange) and a trigger in the database marks every index over it stale, with the reason. The loader checks kernel version, configuration hash and artifact hash before it trusts a file; a mismatch is a refusal with a reason.

The write that changes the data is the write that invalidates the index; nothing has to remember to rebuild.
Rebuild only what moved · decided by shape, never by age
unchanged cluster: byte range copied from the old file
changed cluster: rewritten from the database
Pending rows against the table

Below the mark, a delta build, byte-identical to the full build of the same data; past it, or past 100,000 pending rows, or with no active generation yet, a full one.

Centroid, member and candidate files build apart and activate together in one transaction, so a reader never sees a new centroid file beside an old member file.

A GPU kernel that computes a statistic is a poor definition of that statistic.

Under it is a CUDA engine written from Rust against the driver API for the newest NVIDIA architecture, with a CPU reference and equivalence tests for every kernel, and exact, inverted-file and lattice search. The design is one of my filed inventions, Family Four.

A probe touches every member of the clusters it searchesThe side-band: each scored member's distance to its own centroid

Pre-filled with NaN, so an unwritten slot (grey) is detectable; a reducer turns the rest into cohesion and inertia per cluster. Search output stays byte-identical to the unfused path, and the unfused kernels are left byte-frozen beside it.

Exact, inverted-file, lattice and fused search share one top-k engine. All clusters go in one launch with no sampling: the earlier kernels sampled fifty members, these read every one.