Add: GPU MaxSim retrievers and ground-truth pipeline

- retrievers.py with shared CuPy kernels (segment_max + segment_sum
RawKernels) and DenseRetriever / MaxSimRetriever classes; same kernels
drive ground_truth.py via gt_stripe_{dense,maxsim} per-GPU workers.
- ground_truth.py gains --mode {dense,maxsim}; both modes write per-shard
.body.ground_truth.{ibin,fbin} files with global row IDs (article IDs
for dense, section IDs for maxsim).
- build_index.py absorbs sweep_matryoshka.py via --no-save +
--ef-search-sweep flags; default behavior unchanged.
- embed_sections.py is now the unified pool scheduler (the per-wiki
variant is gone).
- wikiverse.py renamed to usearchwiki.py.

Validated end-to-end against NumPy on non-degenerate synthetic data
(top-10 sets match exactly, max score diff 2e-4) and cross-checked
against NumKong CPU MaxSim (rankings agree exactly; scores differ only
because NumKong returns angular distance while the GPU returns cosine).

README.md

@@ -149,7 +149,7 @@ unum-cloud/USearchWiki/
 ├── README.md
 ├── LICENSE
 ├── .gitattributes
-├── wikiverse.py                              # consumer module: load_lang, read_bin, discover_collection, ...
+├── usearchwiki.py                            # consumer module: load_lang, read_bin, discover_collection, ...
 ├── embed_articles.py                         # one dense vector per article, via TEI
 ├── embed_sections.py                         # late-chunking ColBERT: one vector per section
 ├── late_chunking.py                          # section-aware windowing primitives
@@ -233,7 +233,7 @@ git lfs checkout
 ### Loading embeddings in Python
 
 ```python
-from wikiverse import read_bin
+from usearchwiki import read_bin
 matrix = read_bin("qwen3-embedding-0.6b/enwiki/000_00000.body.f16bin", dtype="f16")
 # matrix.shape == (rows_in_shard, 1024)
 ```

build_index.py

@@ -1,23 +1,21 @@
 """Build a USearch index from per-shard `.f16bin` files in canonical order.
 
-For dense article-level collections (one vector per article, multi=False).
-The ColBERT section-level case (multi=True, vectors keyed by article) will
-be a separate addition once the section embeddings finish computing.
+Two modes:
+  - default: build the index, save to disk as `{suffix}.usearch`.
+  - `--no-save --ef-search-sweep ef1,ef2,...`: build the index in memory,
+    evaluate Recall@k_recall and NDCG@k_ndcg across the ef sweep, append a
+    row per ef to `--stats-jsonl`, then drop the index without saving. This
+    is the Matryoshka-style quality-vs-width sweep — useful when you want
+    the *numbers* but not the artefacts.
 
 Memory-maps the LFS-resolved `.f16bin` blobs so the OS pages vectors in
 lazily — keeps RSS bounded when running multiple builds in parallel.
-
-Inspired by ashvardanian/RetriEval's USearch wrapper:
-  - reserve capacity up front
-  - parallel `add()` with a fixed thread count
-  - cosine metric, f16 quantization (matching storage dtype)
-  - HNSW hyperparameters connectivity / expansion_add
-  - ef_search is a *query-time* knob, not set here
 """
 
 from __future__ import annotations
 
 import argparse
+import json
 import os
 import struct
 import sys
@@ -29,45 +27,59 @@ import numpy as np
 REPO_ROOT = Path(__file__).resolve().parent
 sys.path.insert(0, str(REPO_ROOT))
 
-from wikiverse import (  # noqa: E402
+from usearchwiki import (  # noqa: E402
     CollectionShard,
     discover_collection,
     resolve_lfs_pointer,
 )
 
 
-def memmap_shard(shard: CollectionShard, dimensions: int) -> np.ndarray:
+def memmap_shard(
+    shard: CollectionShard,
+    dimensions_full: int,
+    dimensions_target: int | None = None,
+) -> np.ndarray:
     """Memory-map a `.f16bin` shard skipping its 8-byte header.
 
-    Returns a read-only `(rows, dimensions)` float16 view. The OS pages in
-    only the bytes actually accessed during `index.add()`.
+    When `dimensions_target == dimensions_full` the result is a read-only
+    memmap'd view (zero-copy). When `dimensions_target < dimensions_full`
+    the leading `dimensions_target` columns are sliced and L2-renormalized
+    in FP32 before being cast back to FP16 — the standard Matryoshka
+    truncation recipe.
     """
     blob = resolve_lfs_pointer(shard.path)
-    return np.memmap(
+    full = np.memmap(
         blob,
         dtype=np.float16,
         mode="r",
         offset=8,
-        shape=(shard.row_count, dimensions),
+        shape=(shard.row_count, dimensions_full),
     )
+    if dimensions_target is None or dimensions_target == dimensions_full:
+        return full
+    sliced = np.asarray(full[:, :dimensions_target], dtype=np.float32)
+    norms = np.linalg.norm(sliced, axis=1, keepdims=True)
+    norms[norms == 0] = 1.0
+    return (sliced / norms).astype(np.float16)
 
 
 def add_shards(
     index,
     shards: list[CollectionShard],
-    dimensions: int,
+    dimensions_full: int,
+    dimensions_target: int,
     threads: int,
     log_every: int,
 ) -> int:
-    """Stream every shard's vectors into the index. Keys are sequential
-    global row IDs assigned in shard-walk order (== `shard.row_offset + i`).
+    """Stream every shard's vectors into the index. Keys are sequential global
+    row IDs assigned in shard-walk order (`shard.row_offset + i`).
     """
     cumulative_rows = 0
     started = time.monotonic()
     bytes_added_since_log = 0
     last_log_at = started
     for shard_index, shard in enumerate(shards):
-        vectors = memmap_shard(shard, dimensions)
+        vectors = memmap_shard(shard, dimensions_full, dimensions_target)
         keys = np.arange(
             shard.row_offset, shard.row_offset + shard.row_count, dtype=np.uint64
         )
@@ -92,13 +104,141 @@ def add_shards(
     return cumulative_rows
 
 
+def evaluate_and_log(
+    index,
+    args,
+    shards: list[CollectionShard],
+    model_root: Path,
+    dimensions_full: int,
+    target_dim: int,
+    total_vectors: int,
+    build_seconds: float,
+) -> None:
+    """Run a Recall@k_recall + NDCG@k_ndcg sweep across the ef_search values
+    and append one JSONL row per ef to `args.stats_jsonl`. Uses the eval
+    helpers from `eval_recall` (gather queries, gather GT, metrics_at_k).
+    """
+    from eval_recall import gather_ground_truth, gather_query_vectors
+
+    rng = np.random.default_rng(args.seed)
+    query_ids = np.sort(
+        rng.choice(total_vectors, size=args.num_queries, replace=False)
+    ).astype(np.int64)
+    query_vectors_full = gather_query_vectors(shards, dimensions_full, query_ids)
+    if target_dim != dimensions_full:
+        query_vectors = np.asarray(query_vectors_full[:, :target_dim], dtype=np.float32)
+        norms = np.linalg.norm(query_vectors, axis=1, keepdims=True)
+        norms[norms == 0] = 1.0
+        query_vectors = (query_vectors / norms).astype(np.float16)
+    else:
+        query_vectors = query_vectors_full
+
+    expected_keys = gather_ground_truth(
+        model_root, args.output_suffix, shards, query_ids, args.k_ndcg
+    )
+
+    ef_values = [int(x) for x in args.ef_search_sweep.split(",") if x.strip()]
+    print(
+        f"sweeping ef_search over {ef_values} "
+        f"(recall@{args.k_recall}, ndcg@{args.k_ndcg}) ...",
+        flush=True,
+    )
+    print(
+        f"{'ef_search':>10}  {'recall@'+str(args.k_recall):>12}  "
+        f"{'ndcg@'+str(args.k_ndcg):>12}  {'recall q/s':>12}  {'ndcg q/s':>12}",
+        flush=True,
+    )
+
+    args.stats_jsonl.parent.mkdir(parents=True, exist_ok=True)
+    rows = []
+    build_rate = total_vectors / max(build_seconds, 1e-3)
+    index_bytes_estimate = (
+        total_vectors * target_dim * 2
+        + total_vectors * args.connectivity * 4 * 2
+    )
+
+    def search_top(count: int) -> tuple[np.ndarray, float]:
+        started = time.monotonic()
+        results = index.search(query_vectors, count=count, threads=args.threads)
+        elapsed = time.monotonic() - started
+        raw_keys = np.asarray(results.keys, dtype=np.int64)
+        target = count - 1
+        actual = np.empty((args.num_queries, target), dtype=np.int64)
+        for row in range(args.num_queries):
+            without_self = raw_keys[row][raw_keys[row] != query_ids[row]][:target]
+            if without_self.shape[0] < target:
+                actual[row] = -1
+                actual[row, : without_self.shape[0]] = without_self
+            else:
+                actual[row] = without_self
+        return actual, elapsed
+
+    expected_recall = expected_keys[:, : args.k_recall]
+    expected_ndcg = expected_keys[:, : args.k_ndcg]
+    discount = 1.0 / np.log2(np.arange(2, args.k_ndcg + 2))
+    idcg = float(discount.sum())
+
+    for ef in ef_values:
+        index.expansion_search = ef
+        actual_recall, elapsed_recall = search_top(args.k_recall + 1)
+        membership_recall = (
+            actual_recall[:, :, None] == expected_recall[:, None, :]
+        ).any(axis=2)
+        recall = float(membership_recall.sum(axis=1).mean()) / args.k_recall
+
+        actual_ndcg, elapsed_ndcg = search_top(args.k_ndcg + 1)
+        membership_ndcg = (
+            actual_ndcg[:, :, None] == expected_ndcg[:, None, :]
+        ).any(axis=2)
+        dcg = (membership_ndcg * discount).sum(axis=1)
+        ndcg = float((dcg / idcg).mean())
+
+        rate_recall = args.num_queries / max(elapsed_recall, 1e-3)
+        rate_ndcg = args.num_queries / max(elapsed_ndcg, 1e-3)
+        print(
+            f"{ef:>10}  {recall*100:>11.4f}%  {ndcg*100:>11.4f}%  "
+            f"{rate_recall:>12,.0f}  {rate_ndcg:>12,.0f}",
+            flush=True,
+        )
+        rows.append(
+            {
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+                "model_subdir": args.model_subdir,
+                "output_suffix": args.output_suffix,
+                "dimensions_full": dimensions_full,
+                "dimensions_indexed": target_dim,
+                "connectivity": args.connectivity,
+                "expansion_add": args.expansion_add,
+                "expansion_search": ef,
+                "metric": args.metric,
+                "dtype": args.dtype,
+                "total_vectors": int(total_vectors),
+                "num_queries": int(args.num_queries),
+                "k_recall": int(args.k_recall),
+                "k_ndcg": int(args.k_ndcg),
+                "recall": recall,
+                "ndcg": ndcg,
+                "queries_per_second_recall": rate_recall,
+                "queries_per_second_ndcg": rate_ndcg,
+                "build_seconds": build_seconds,
+                "build_vec_per_second": build_rate,
+                "index_bytes_estimate": int(index_bytes_estimate),
+                "build_threads": int(args.threads),
+            }
+        )
+
+    with open(args.stats_jsonl, "a") as file:
+        for row in rows:
+            file.write(json.dumps(row) + "\n")
+    print(
+        f"appended {len(rows)} rows to {args.stats_jsonl}",
+        flush=True,
+    )
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--output",
-        default="/home/ubuntu/WikiVerse",
-        help="root directory holding {model-subdir}/{wiki}/*.f16bin",
-    )
+    parser.add_argument("--output", default="/home/ubuntu/USearchWiki")
     parser.add_argument(
         "--model-subdir",
         required=True,
@@ -126,13 +266,13 @@ def main() -> None:
         "--connectivity",
         type=int,
         default=16,
-        help="HNSW M, neighbors per node (16 is the typical floor for ANN)",
+        help="HNSW M, neighbors per node",
     )
     parser.add_argument(
         "--expansion-add",
         type=int,
         default=256,
-        help="HNSW efConstruction; bumped from the default 128 to chase >=99% recall@10",
+        help="HNSW efConstruction; bumped from 128 to chase >=99% recall@10",
     )
     parser.add_argument(
         "--metric",
@@ -151,6 +291,35 @@ def main() -> None:
         default=10,
         help="print a progress line every N shards",
     )
+    parser.add_argument(
+        "--truncate-dim",
+        type=int,
+        default=0,
+        help="truncate stored embeddings to the leading N dimensions (Matryoshka). "
+        "0 means no truncation.",
+    )
+    parser.add_argument(
+        "--no-save",
+        action="store_true",
+        help="build the index in memory and drop it; do not write `{suffix}.usearch`. "
+        "Useful for the Matryoshka quality sweep where indexes are evaluated then thrown away.",
+    )
+    parser.add_argument(
+        "--ef-search-sweep",
+        default="",
+        help="comma-separated ef_search values to evaluate post-build. When set, runs "
+        "Recall@k_recall + NDCG@k_ndcg and appends a JSONL row per ef to --stats-jsonl.",
+    )
+    parser.add_argument("--num-queries", type=int, default=10000)
+    parser.add_argument("--k-recall", type=int, default=10)
+    parser.add_argument("--k-ndcg", type=int, default=100)
+    parser.add_argument(
+        "--stats-jsonl",
+        type=Path,
+        default=Path("/home/ubuntu/wikiverse-data/logs/index-stats.jsonl"),
+        help="JSONL file to append per-ef sweep rows to (only used with --ef-search-sweep)",
+    )
+    parser.add_argument("--seed", type=int, default=0)
     args = parser.parse_args()
 
     from usearch.index import Index  # local import: heavy dependency
@@ -161,9 +330,6 @@ def main() -> None:
     shards = discover_collection(model_root, args.output_suffix)
     if not shards:
         raise SystemExit(f"no .{args.output_suffix}.f16bin shards under {model_root}")
-    # Read dimensions from the first shard's header. (Within a model the
-    # collection is consistent by construction; if it weren't, `index.add`
-    # would raise on the first mismatched shard anyway.)
     first_blob = resolve_lfs_pointer(shards[0].path)
     with open(first_blob, "rb") as file:
         _, dimensions = struct.unpack("<II", file.read(8))
@@ -176,21 +342,25 @@ def main() -> None:
         flush=True,
     )
 
-    output_index_path = (
-        args.output_index
-        if args.output_index is not None
-        else model_root / f"{args.output_suffix}.usearch"
-    )
+    if args.truncate_dim and args.truncate_dim != dimensions:
+        if args.truncate_dim > dimensions:
+            raise SystemExit(
+                f"--truncate-dim {args.truncate_dim} > native {dimensions}"
+            )
+        target_dim = args.truncate_dim
+    else:
+        target_dim = dimensions
 
     print(
         f"opening USearch index "
-        f"(dim={dimensions}, metric={args.metric}, dtype={args.dtype}, "
+        f"(dim={target_dim}, metric={args.metric}, dtype={args.dtype}, "
         f"M={args.connectivity}, ef_add={args.expansion_add}, "
-        f"multi=False, threads={args.threads})",
+        f"multi=False, threads={args.threads}, "
+        f"truncated_from={dimensions if target_dim != dimensions else None})",
         flush=True,
     )
     index = Index(
-        ndim=dimensions,
+        ndim=target_dim,
         metric=args.metric,
         dtype=args.dtype,
         connectivity=args.connectivity,
@@ -203,27 +373,48 @@ def main() -> None:
     added = add_shards(
         index=index,
         shards=shards,
-        dimensions=dimensions,
+        dimensions_full=dimensions,
+        dimensions_target=target_dim,
         threads=args.threads,
         log_every=args.log_every,
     )
-    elapsed_build = time.monotonic() - started
-    rate = added / max(elapsed_build, 1e-3)
+    build_seconds = time.monotonic() - started
+    rate = added / max(build_seconds, 1e-3)
     print(
-        f"added {added:,} vectors in {elapsed_build:.0f}s "
+        f"added {added:,} vectors in {build_seconds:.0f}s "
         f"({rate:,.0f} vec/s), index size now {len(index):,}",
         flush=True,
     )
 
-    output_index_path.parent.mkdir(parents=True, exist_ok=True)
-    started = time.monotonic()
-    index.save(str(output_index_path))
-    elapsed_save = time.monotonic() - started
-    file_size_gb = output_index_path.stat().st_size / 1e9
-    print(
-        f"saved {output_index_path} ({file_size_gb:.2f} GB) in {elapsed_save:.0f}s",
-        flush=True,
-    )
+    if args.ef_search_sweep.strip():
+        evaluate_and_log(
+            index=index,
+            args=args,
+            shards=shards,
+            model_root=model_root,
+            dimensions_full=dimensions,
+            target_dim=target_dim,
+            total_vectors=total_vectors,
+            build_seconds=build_seconds,
+        )
+
+    if not args.no_save:
+        output_index_path = (
+            args.output_index
+            if args.output_index is not None
+            else model_root / f"{args.output_suffix}.usearch"
+        )
+        output_index_path.parent.mkdir(parents=True, exist_ok=True)
+        started = time.monotonic()
+        index.save(str(output_index_path))
+        elapsed_save = time.monotonic() - started
+        file_size_gb = output_index_path.stat().st_size / 1e9
+        print(
+            f"saved {output_index_path} ({file_size_gb:.2f} GB) in {elapsed_save:.0f}s",
+            flush=True,
+        )
+    else:
+        print("--no-save set; dropping index without writing to disk", flush=True)
 
 
 if __name__ == "__main__":

embed_articles.py

@@ -21,7 +21,7 @@ from pathlib import Path
 import httpx
 import numpy as np
 
-from wikiverse import Shard, load_lang, load_shard_texts, write_bin
+from usearchwiki import Shard, load_lang, load_shard_texts, write_bin
 
 
 def select_shards(all_shards: list[Shard], gpu_id: int, world_size: int) -> list[Shard]:

embed_sections.py

@@ -1,28 +1,36 @@
 """Late-chunking section embeddings via GTE-ModernColBERT-v1 (pylate).
 
-For each parquet shard:
-  1. Load articles (text + id).
-  2. For each article: find section char spans, tokenize ("[D] " + text)
-     once, plan windows via late_chunking, forward each window through the
-     transformer + projection + L2 normalization, mean-pool the core token
+Pool scheduler: enumerates every (wiki, shard) tuple in the corpus, filters
+out already-completed outputs, and dispatches the rest across `num_gpus`
+long-running worker processes via a shared `mp.Queue`. Each worker loads the
+pylate model once and processes shards as they arrive, so small single-shard
+wikis don't leave 7 GPUs idle.
+
+For each parquet shard a worker:
+  1. Loads articles (text + id).
+  2. Per article: finds section char spans, tokenizes ("[D] " + text) once,
+     plans windows via `late_chunking`, forwards each window through the
+     transformer + projection + L2 normalization, mean-pools the core token
      vectors per section.
-  3. Write per-shard `{wiki}/{stem}.body.sections.f16bin` (concatenated section
-     embeddings) and `{wiki}/{stem}.body.sections.offsets.ibin` (cumulative
-     offsets giving each article's section slice).
+  3. Writes per-shard `{wiki}/{stem}.body.sections.f16bin` (concatenated
+     section embeddings) and `{wiki}/{stem}.body.sections.offsets.ibin`
+     (cumulative offsets giving each article's section slice).
 
-One process per GPU; partition shards by `shard_index % world_size == gpu_id`.
+Resume-safe by construction: shards whose output files already exist are
+skipped before being added to the queue.
 
 Usage:
-  CUDA_VISIBLE_DEVICES=0 python embed_sections.py \\
+  python embed_sections.py \\
       --cache-dir /home/ubuntu/wikiverse-data/hf-cache \\
-      --output /home/ubuntu/WikiVerse \\
+      --output /home/ubuntu/USearchWiki \\
       --model-subdir gte-moderncolbert-v1 \\
-      --wiki enwiki --gpu-id 0 --world-size 8
+      --num-gpus 8
 """
 
 from __future__ import annotations
 
 import argparse
+import multiprocessing as mp
 import os
 import struct
 import sys
@@ -45,11 +53,7 @@ from late_chunking import (  # noqa: E402
     pool_section_vectors,
     section_token_spans_from_offsets,
 )
-from wikiverse import Shard, load_lang  # noqa: E402
-
-
-def select_shards(all_shards: list[Shard], gpu_id: int, world_size: int) -> list[Shard]:
-    return [s for i, s in enumerate(all_shards) if i % world_size == gpu_id]
+from usearchwiki import Shard, find_snapshot, load_lang  # noqa: E402
 
 
 def load_pylate_model(model_id: str, device: str, document_length: int):
@@ -108,7 +112,6 @@ def plan_articles_batched(
     if not prefixed_texts:
         return per_article_windows, per_article_n_sections
 
-    # One Rust-side tokenizer call for the whole batch.
     encodings = tokenizer(
         prefixed_texts,
         add_special_tokens=False,
@@ -152,15 +155,9 @@ def encode_articles_batch(
     document_prefix: str,
     max_batch_tokens: int,
 ) -> list[np.ndarray]:
-    """Encode a batch of articles into per-article (n_sections, dim) FP16 arrays.
-
-    Pads windows from across the batch into one or more padded forward passes,
-    splitting into sub-batches whenever the padded total exceeds
-    `max_batch_tokens` (so a few very long articles don't blow up GPU memory).
-    """
+    """Encode a batch of articles into per-article (n_sections, dim) FP16 arrays."""
     embedding_dim = model[1].linear.out_features
 
-    # Plan windows for every article via a single batched tokenizer call.
     per_article_windows, per_article_n_sections = plan_articles_batched(
         texts=texts,
         tokenizer=model.tokenizer,
@@ -169,17 +166,14 @@ def encode_articles_batch(
         margin=margin,
     )
 
-    # Flatten window list across articles, tag each with its article index.
     all_windows: list[tuple[int, int, Window]] = []
     for article_index, windows in enumerate(per_article_windows):
         for window_index, window in enumerate(windows):
             all_windows.append((article_index, window_index, window))
 
-    # Outputs scratch: one numpy array per (article, window) once we have it.
     output_token_arrays: dict[tuple[int, int], np.ndarray] = {}
 
     if all_windows:
-        # Sort windows by length to keep padding overhead per sub-batch low.
         all_windows.sort(key=lambda triple: triple[2].length)
 
         sub_batch: list[tuple[int, int, Window]] = []
@@ -231,7 +225,6 @@ def encode_articles_batch(
             sub_batch_max_len = max(sub_batch_max_len, wrapped_len)
         flush(sub_batch)
 
-    # Pool per article.
     section_matrices: list[np.ndarray] = []
     for article_index, (windows, n_sections) in enumerate(
         zip(per_article_windows, per_article_n_sections, strict=True)
@@ -357,7 +350,6 @@ def process_shard(
             )
 
     elapsed = time.monotonic() - started
-    embedding_dim = model[1].linear.out_features
 
     write_shard_outputs(
         shard_dir=output_root / shard.wikiname,
@@ -375,103 +367,177 @@ def process_shard(
     }
 
 
+def worker(gpu_id: int, work_queue, args_dict: dict) -> None:
+    """Pin to one GPU, load the model once, drain shards from the queue."""
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
+    device = "cuda:0"
+    model = load_pylate_model(
+        args_dict["model_id"], device, args_dict["context_limit"]
+    )
+    cls_id = model.tokenizer.cls_token_id
+    sep_id = model.tokenizer.sep_token_id
+    pad_id = model.tokenizer.pad_token_id
+    document_prefix = model.document_prefix
+    output_root = Path(args_dict["output"]) / args_dict["model_subdir"]
+
+    n_processed = 0
+    n_failed = 0
+    started = time.monotonic()
+    while True:
+        try:
+            item = work_queue.get(timeout=5.0)
+        except Exception:
+            print(f"[gpu{gpu_id}] queue idle 5s, exiting", flush=True)
+            break
+        if item is None:
+            break
+        shard: Shard = item
+        try:
+            stats = process_shard(
+                shard=shard,
+                output_root=output_root,
+                model=model,
+                cls_id=cls_id,
+                sep_id=sep_id,
+                pad_id=pad_id,
+                device=device,
+                context_limit=args_dict["context_limit"],
+                margin=args_dict["margin"],
+                document_prefix=document_prefix,
+                suffix=args_dict["suffix"],
+                text_column=args_dict["text_column"],
+                id_column=args_dict["id_column"],
+                article_batch_size=args_dict["article_batch_size"],
+                max_batch_tokens=args_dict["max_batch_tokens"],
+            )
+            n_processed += 1
+            rate = stats["n_articles"] / max(stats["elapsed_seconds"], 1e-3)
+            print(
+                f"[gpu{gpu_id}] {shard.wikiname}/{shard.stem}: "
+                f"{stats['n_articles']} articles "
+                f"({stats['n_zero_articles']} zero), "
+                f"{stats['n_sections_total']:,} sections in "
+                f"{stats['elapsed_seconds']:.0f}s -> {rate:.1f} doc/s",
+                flush=True,
+            )
+        except Exception as exc:
+            n_failed += 1
+            print(
+                f"[gpu{gpu_id}] {shard.wikiname}/{shard.stem}: FAILED: {exc!r}",
+                flush=True,
+            )
+
+    elapsed = time.monotonic() - started
+    print(
+        f"[gpu{gpu_id}] worker DONE: {n_processed} shards processed, "
+        f"{n_failed} failed, {elapsed:.0f}s",
+        flush=True,
+    )
+
+
 def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--cache-dir", default="/home/ubuntu/wikiverse-data/hf-cache")
-    parser.add_argument("--output", default="/home/ubuntu/WikiVerse")
+    parser.add_argument("--output", default="/home/ubuntu/USearchWiki")
     parser.add_argument("--model-subdir", default="gte-moderncolbert-v1")
     parser.add_argument("--model-id", default="lightonai/GTE-ModernColBERT-v1")
-    parser.add_argument(
-        "--wiki", required=True, help="single language code (enwiki, dewiki, ...)"
-    )
-    parser.add_argument("--gpu-id", type=int, default=0)
-    parser.add_argument("--world-size", type=int, default=1)
+    parser.add_argument("--num-gpus", type=int, default=8)
     parser.add_argument("--context-limit", type=int, default=8192)
     parser.add_argument("--margin", type=int, default=256)
     parser.add_argument("--text-column", default="text", choices=["text", "title"])
     parser.add_argument("--output-suffix", default="body")
     parser.add_argument("--id-column", default="id")
-    parser.add_argument(
-        "--article-batch-size",
-        type=int,
-        default=64,
-        help="number of articles' windows to plan in one cross-article batch",
-    )
-    parser.add_argument(
-        "--max-batch-tokens",
-        type=int,
-        default=131072,
-        help="cap on `padded_batch_size * padded_max_length` per forward pass; "
-        "splits the cross-article batch into sub-batches when needed to keep "
-        "GPU memory bounded",
-    )
+    parser.add_argument("--article-batch-size", type=int, default=64)
+    parser.add_argument("--max-batch-tokens", type=int, default=131072)
     args = parser.parse_args()
 
-    # Pin to the assigned GPU before importing pylate.
-    os.environ.setdefault("CUDA_VISIBLE_DEVICES", str(args.gpu_id))
-    device = "cuda:0"  # post-CUDA_VISIBLE_DEVICES, our GPU is always cuda:0.
+    snapshot = find_snapshot(args.cache_dir)
+    wiki_names = sorted(
+        d.name for d in (snapshot / "data").iterdir() if d.is_dir()
+    )
+    print(
+        f"discovering shards across {len(wiki_names)} wikis under "
+        f"{snapshot.parent.name}/{snapshot.name} ...",
+        flush=True,
+    )
 
     output_root = Path(args.output) / args.model_subdir
-    output_root.mkdir(parents=True, exist_ok=True)
-
-    shards = load_lang(args.cache_dir, args.wiki)
-    owned = select_shards(shards, args.gpu_id, args.world_size)
-    pending = [
-        s
-        for s in owned
-        if not (
-            output_root / s.wikiname / f"{s.stem}.{args.output_suffix}.sections.f16bin"
-        ).exists()
-    ]
+    pending: list[Shard] = []
+    skipped = 0
+    for wiki_name in wiki_names:
+        try:
+            shards = load_lang(args.cache_dir, wiki_name)
+        except Exception:
+            continue
+        for shard in shards:
+            existing = (
+                output_root
+                / shard.wikiname
+                / f"{shard.stem}.{args.output_suffix}.sections.f16bin"
+            )
+            if existing.exists():
+                skipped += 1
+                continue
+            pending.append(shard)
+    pending.sort(key=lambda shard: shard.path.stat().st_size, reverse=True)
     print(
-        f"[gpu{args.gpu_id}] {args.wiki}: {len(owned)} owned, {len(pending)} pending",
+        f"  {skipped} shards already done; {len(pending)} pending; "
+        f"largest parquet: {pending[0].path.stat().st_size / 1e6:.0f} MB"
+        if pending
+        else f"  {skipped} shards already done; nothing pending",
         flush=True,
     )
     if not pending:
         return
 
-    model = load_pylate_model(args.model_id, device, args.context_limit)
-    cls_id = model.tokenizer.cls_token_id
-    sep_id = model.tokenizer.sep_token_id
-    pad_id = model.tokenizer.pad_token_id
-    document_prefix = model.document_prefix
+    args_dict = {
+        "model_id": args.model_id,
+        "context_limit": args.context_limit,
+        "margin": args.margin,
+        "output": args.output,
+        "model_subdir": args.model_subdir,
+        "suffix": args.output_suffix,
+        "text_column": args.text_column,
+        "id_column": args.id_column,
+        "article_batch_size": args.article_batch_size,
+        "max_batch_tokens": args.max_batch_tokens,
+    }
 
-    started_overall = time.monotonic()
-    total_articles = 0
-    total_sections = 0
+    ctx = mp.get_context("fork")
+    work_queue: mp.Queue = ctx.Queue()
     for shard in pending:
-        stats = process_shard(
-            shard=shard,
-            output_root=output_root,
-            model=model,
-            cls_id=cls_id,
-            sep_id=sep_id,
-            pad_id=pad_id,
-            device=device,
-            context_limit=args.context_limit,
-            margin=args.margin,
-            document_prefix=document_prefix,
-            suffix=args.output_suffix,
-            text_column=args.text_column,
-            id_column=args.id_column,
-            article_batch_size=args.article_batch_size,
-            max_batch_tokens=args.max_batch_tokens,
-        )
-        total_articles += stats["n_articles"]
-        total_sections += stats["n_sections_total"]
-        rate = stats["n_articles"] / max(stats["elapsed_seconds"], 1e-3)
-        print(
-            f"[gpu{args.gpu_id} pylate] {shard.wikiname}/{shard.stem}: "
-            f"{stats['n_articles']} articles ({stats['n_zero_articles']} zero), "
-            f"{stats['n_sections_total']:,} sections in {stats['elapsed_seconds']:.1f}s "
-            f"-> {rate:.1f} doc/s",
-            flush=True,
-        )
+        work_queue.put(shard)
+    for _ in range(args.num_gpus):
+        work_queue.put(None)
+
+    workers: list[mp.Process] = []
+    for gpu_id in range(args.num_gpus):
+        process = ctx.Process(target=worker, args=(gpu_id, work_queue, args_dict))
+        process.start()
+        workers.append(process)
 
-    wall = time.monotonic() - started_overall
+    started = time.monotonic()
+    print(
+        f"started {len(workers)} GPU workers at "
+        f"{time.strftime('%Y-%m-%dT%H:%M:%S')}; "
+        f"{len(pending)} shards in queue",
+        flush=True,
+    )
+
+    failed = 0
+    for process in workers:
+        process.join()
+        if process.exitcode != 0:
+            failed += 1
+            print(
+                f"  worker pid {process.pid} exited code {process.exitcode}",
+                flush=True,
+            )
+    elapsed = time.monotonic() - started
     print(
-        f"[gpu{args.gpu_id} pylate] DONE: {total_articles} articles, "
-        f"{total_sections:,} sections in {wall:.0f}s -> {total_articles/max(wall,1):.1f} doc/s",
+        f"DONE: {len(pending)} shards in {elapsed:.0f}s "
+        f"({len(pending) / max(elapsed, 1e-3):.2f} shards/s); "
+        f"{failed} workers failed",
         flush=True,
     )
 

eval_recall.py

@@ -30,7 +30,7 @@ import numpy as np
 REPO_ROOT = Path(__file__).resolve().parent
 sys.path.insert(0, str(REPO_ROOT))
 
-from wikiverse import (  # noqa: E402
+from usearchwiki import (  # noqa: E402
     CollectionShard,
     discover_collection,
     resolve_lfs_pointer,
@@ -121,16 +121,44 @@ def gather_ground_truth(
     return out
 
 
-def measure_recall(
-    expected: np.ndarray,
-    actual: np.ndarray,
-    k: int,
-) -> float:
-    """`expected` and `actual` are both `(num_queries, k)` int arrays."""
-    matches = 0
-    for row in range(expected.shape[0]):
-        matches += len(set(expected[row].tolist()) & set(actual[row].tolist()))
-    return matches / (expected.shape[0] * k)
+def metrics_at_k(
+    expected_keys: np.ndarray,
+    actual_keys: np.ndarray,
+    k_recall: int,
+    k_ndcg: int,
+) -> tuple[float, float]:
+    """Compute strict Recall@k_recall and binary NDCG@k_ndcg.
+
+    `expected_keys` is the exact top-k_max ground truth (descending
+    similarity), `actual_keys` is the predicted top-k_max from the index
+    (self-match already removed). Both arrays are
+    `(n_queries, k_max)` with `k_max >= max(k_recall, k_ndcg)`.
+
+    Strict recall: predicted top-k_recall key counts iff it appears in GT
+    *top-k_recall*. Standard ANN-Benchmarks definition.
+
+    Binary NDCG: predicted top-k_ndcg key counts iff it appears in GT
+    *top-k_ndcg*. Both rankings are graded by their position in their
+    respective top-lists, so a predicted #1 that matches GT #50 still
+    contributes 1 / log2(2) at rank 1 in DCG.
+    """
+    # Recall@k_recall: small bool matrix from k_recall slices on both sides.
+    rec_actual = actual_keys[:, :k_recall]
+    rec_expected = expected_keys[:, :k_recall]
+    membership_recall = (rec_actual[:, :, None] == rec_expected[:, None, :]).any(axis=2)
+    recall = float(membership_recall.sum(axis=1).mean()) / k_recall
+
+    # NDCG@k_ndcg: bigger bool matrix from k_ndcg slices.
+    ndcg_actual = actual_keys[:, :k_ndcg]
+    ndcg_expected = expected_keys[:, :k_ndcg]
+    membership_ndcg = (
+        ndcg_actual[:, :, None] == ndcg_expected[:, None, :]
+    ).any(axis=2)
+    discount = 1.0 / np.log2(np.arange(2, k_ndcg + 2))
+    dcg = (membership_ndcg * discount).sum(axis=1)
+    idcg = float(discount.sum())  # |GT| >= k_ndcg by construction
+    ndcg = float((dcg / idcg).mean())
+    return recall, ndcg
 
 
 def main() -> None:
@@ -140,10 +168,22 @@ def main() -> None:
     parser.add_argument("--output-suffix", default="body", choices=["body", "title"])
     parser.add_argument("--index", type=Path, default=None)
     parser.add_argument("--num-queries", type=int, default=10000)
-    parser.add_argument("--k", type=int, default=10)
+    parser.add_argument(
+        "--k-recall",
+        type=int,
+        default=10,
+        help="cutoff for Recall@k",
+    )
+    parser.add_argument(
+        "--k-ndcg",
+        type=int,
+        default=100,
+        help="cutoff for NDCG@k; also drives how many GT neighbors are loaded "
+        "and how many results we ask the index for (k_ndcg + 1 to drop self)",
+    )
     parser.add_argument(
         "--ef-search",
-        default="64,128,256,512",
+        default="16,32,64,128,256,512,1024",
         help="comma-separated efSearch values to sweep",
     )
     parser.add_argument(
@@ -198,22 +238,70 @@ def main() -> None:
     started = time.monotonic()
     query_vectors = gather_query_vectors(shards, dimensions, query_ids)
     expected_keys = gather_ground_truth(
-        model_root, args.output_suffix, shards, query_ids, args.k
+        model_root, args.output_suffix, shards, query_ids, args.k_ndcg
     )
     print(f"  loaded in {time.monotonic()-started:.1f}s", flush=True)
 
     ef_values = [int(x) for x in args.ef_search.split(",") if x.strip()]
-    print(f"sweeping ef_search over {ef_values} with k={args.k} ...", flush=True)
-    print(f"{'ef_search':>10}  {'recall@k':>10}  {'queries/s':>12}")
-    for ef in ef_values:
-        index.expansion_search = ef
+    print(
+        f"sweeping ef_search over {ef_values} "
+        f"(recall@{args.k_recall}, ndcg@{args.k_ndcg}) ...",
+        flush=True,
+    )
+    print(
+        f"{'ef_search':>10}  "
+        f"{'recall@'+str(args.k_recall):>12}  {'recall q/s':>12}  "
+        f"{'ndcg@'+str(args.k_ndcg):>12}  {'ndcg q/s':>12}"
+    )
+
+    # Two search calls per ef: one with count=k_recall+1 to get a meaningful
+    # recall@k_recall curve at the requested ef, and one with count=k_ndcg+1
+    # for NDCG. USearch coerces the internal expansion to >= count, so a
+    # single shared count=k_ndcg+1 would flatten the recall@k_recall sweep
+    # at low ef (effective ef becomes k_ndcg+1 regardless).
+    def search_top(count: int) -> tuple[np.ndarray, float]:
         started = time.monotonic()
-        results = index.search(query_vectors, count=args.k, threads=args.threads)
+        results = index.search(query_vectors, count=count, threads=args.threads)
         elapsed = time.monotonic() - started
-        actual_keys = np.asarray(results.keys, dtype=np.int64)
-        recall = measure_recall(expected_keys, actual_keys, args.k)
-        rate = args.num_queries / max(elapsed, 1e-3)
-        print(f"{ef:>10}  {recall*100:>9.4f}%  {rate:>12,.0f}")
+        raw_keys = np.asarray(results.keys, dtype=np.int64)
+        actual = np.empty((args.num_queries, count - 1), dtype=np.int64)
+        target = count - 1
+        for row in range(args.num_queries):
+            without_self = raw_keys[row][raw_keys[row] != query_ids[row]][:target]
+            if without_self.shape[0] < target:
+                actual[row] = -1
+                actual[row, : without_self.shape[0]] = without_self
+            else:
+                actual[row] = without_self
+        return actual, elapsed
+
+    expected_recall = expected_keys[:, : args.k_recall]
+    expected_ndcg = expected_keys[:, : args.k_ndcg]
+    discount = 1.0 / np.log2(np.arange(2, args.k_ndcg + 2))
+    idcg = float(discount.sum())
+
+    for ef in ef_values:
+        index.expansion_search = ef
+        # --- recall sweep (small count) ---
+        actual_recall, elapsed_recall = search_top(args.k_recall + 1)
+        membership_recall = (
+            actual_recall[:, :, None] == expected_recall[:, None, :]
+        ).any(axis=2)
+        recall = float(membership_recall.sum(axis=1).mean()) / args.k_recall
+        rate_recall = args.num_queries / max(elapsed_recall, 1e-3)
+        # --- ndcg sweep (large count) ---
+        actual_ndcg, elapsed_ndcg = search_top(args.k_ndcg + 1)
+        membership_ndcg = (
+            actual_ndcg[:, :, None] == expected_ndcg[:, None, :]
+        ).any(axis=2)
+        dcg = (membership_ndcg * discount).sum(axis=1)
+        ndcg = float((dcg / idcg).mean())
+        rate_ndcg = args.num_queries / max(elapsed_ndcg, 1e-3)
+        print(
+            f"{ef:>10}  "
+            f"{recall*100:>11.4f}%  {rate_recall:>12,.0f}  "
+            f"{ndcg*100:>11.4f}%  {rate_ndcg:>12,.0f}"
+        )
 
 
 if __name__ == "__main__":

ground_truth.py

@@ -1,13 +1,29 @@
 """Compute exact global k-NN ground truth for an embedding collection.
 
-Streams the entire collection through every GPU as both queries and candidates,
-using tiled FP16x FP16 -> FP32 GEMMs with a pre-allocated `out=` buffer. One
-collection (model) at a time; partitions queries across GPUs, double-buffers
-candidate tile H2D copies, keeps the running top-k on device.
+Two modes share the same per-stripe partition + per-shard output pipeline:
+
+  --mode dense  (default)
+    Cosine top-k over a `(N, dim)` FP16 corpus. Used for the
+    article-level dense models (qwen3-embedding-0.6b,
+    snowflake-arctic-embed-l-v2.0, nomic-embed-text-v1.5, ...).
+
+  --mode maxsim
+    ColBERT-style late-interaction MaxSim top-k over a
+    `(T_total, dim)` token bank + `(N+1,)` section offsets. Used for
+    the section-level multi-vector models (gte-moderncolbert-v1).
+
+Both modes write per-shard `{wiki}/{stem}.{suffix}.ground_truth.{ibin,fbin}`
+files in canonical shard-walk order. The neighbor IDs in the `.ibin` are
+global row IDs (article-id space for dense, section-id space for MaxSim).
 
 Usage:
-  python ground_truth.py --output /path/to/embeddings \\
-      --model-subdir qwen3-embedding-0.6b --dimensions 1024 --num-gpus 8
+  python ground_truth.py --mode dense \
+      --output /path/to/embeddings --model-subdir qwen3-embedding-0.6b \
+      --num-gpus 8
+
+  python ground_truth.py --mode maxsim \
+      --output /path/to/embeddings --model-subdir gte-moderncolbert-v1 \
+      --num-gpus 8
 """
 
 from __future__ import annotations
@@ -16,12 +32,21 @@ import argparse
 import multiprocessing as mp
 import os
 import struct
+import sys
 import time
 from pathlib import Path
 
 import numpy as np
 
-from wikiverse import (
+REPO_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(REPO_ROOT))
+
+from retrievers import (  # noqa: E402
+    _load_maxsim_corpus_to_host,
+    gt_stripe_dense,
+    gt_stripe_maxsim,
+)
+from usearchwiki import (  # noqa: E402
     CollectionShard,
     discover_collection,
     resolve_lfs_pointer,
@@ -29,13 +54,12 @@ from wikiverse import (
 )
 
 
-def load_collection(
+def load_dense_collection(
     model_root: Path,
     suffix: str,
     dimensions: int,
     shards: list[CollectionShard],
 ) -> np.ndarray:
-    """Allocate one large host array and stream every shard body into its row range."""
     total_vectors = sum(shard.row_count for shard in shards)
     embeddings = np.empty((total_vectors, dimensions), dtype=np.float16)
     started = time.monotonic()
@@ -60,269 +84,92 @@ def load_collection(
         flush=True,
     )
 
-    # Sanitize: a handful of rows in some collections contain a stray NaN/Inf
-    # (the embedder emitted noise for empty/degenerate articles). Even one
-    # NaN row poisons every query's top-k via NaN-tainted similarities.
-    # Coerce any non-finite row to a clean zero vector.
+    # Sanitize: a handful of rows in some collections contain stray NaN/Inf
+    # (the embedder emitted noise for empty/degenerate articles). One NaN row
+    # poisons every query's top-k via NaN-tainted similarities.
     started = time.monotonic()
-    bad_rows: list[int] = []
-    chunk_rows = 1_000_000
-    for chunk_start in range(0, total_vectors, chunk_rows):
-        chunk_end = min(chunk_start + chunk_rows, total_vectors)
+    bad_rows = 0
+    for chunk_start in range(0, total_vectors, 1_000_000):
+        chunk_end = min(chunk_start + 1_000_000, total_vectors)
         chunk = embeddings[chunk_start:chunk_end]
         bad_mask = ~np.isfinite(chunk).all(axis=1)
         if bad_mask.any():
-            local_bad = np.where(bad_mask)[0]
-            bad_rows.extend((chunk_start + local_bad).tolist())
+            bad_rows += int(bad_mask.sum())
             chunk[bad_mask] = 0
     elapsed = time.monotonic() - started
     print(
-        f"sanitized {len(bad_rows)} non-finite rows -> zero vectors in {elapsed:.1f}s",
+        f"sanitized {bad_rows} non-finite rows -> zero vectors in {elapsed:.1f}s",
         flush=True,
     )
-    if bad_rows:
-        preview = bad_rows[:8]
-        print(f"  bad row indices (first 8): {preview}", flush=True)
     return embeddings
 
 
-def worker_main(
+def dense_worker(
     gpu_index: int,
     num_gpus: int,
     embeddings: np.ndarray,
-    dimensions: int,
     num_neighbors: int,
     query_tile_rows: int,
     candidate_tile_rows: int,
     scratch_dir: Path,
 ) -> None:
-    """One process per GPU. Streams the whole corpus past a resident query stripe."""
     os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_index)
-    import cupy  # imported after CUDA_VISIBLE_DEVICES so this process binds to one GPU
-    import torch  # only used for its highly-optimized fused top-k kernel
-
     total_vectors = embeddings.shape[0]
     stripe_start = (total_vectors * gpu_index) // num_gpus
     stripe_end = (total_vectors * (gpu_index + 1)) // num_gpus
-    stripe_size = stripe_end - stripe_start
-    keep = num_neighbors + 1  # +1 so we always have headroom to drop the self-match
-
     print(
-        f"[gpu{gpu_index}] queries [{stripe_start:,}, {stripe_end:,}) "
-        f"({stripe_size:,} rows), candidate corpus {total_vectors:,} rows",
+        f"[gpu{gpu_index} dense] queries [{stripe_start:,}, {stripe_end:,}) "
+        f"vs corpus {total_vectors:,}",
         flush=True,
     )
-
-    # Resident query stripe on device (~16 GB at 8 GPUs, dim 1024).
-    query_stripe = cupy.asarray(embeddings[stripe_start:stripe_end])
-
-    # Pinned host scratch (one per slot) for async H2D of candidate tiles.
-    pinned_views: list[np.ndarray] = []
-    pinned_holders = []  # keep allocations alive
-    for _ in range(2):
-        pinned_memory = cupy.cuda.alloc_pinned_memory(
-            candidate_tile_rows * dimensions * 2
-        )
-        pinned_holders.append(pinned_memory)
-        view = np.frombuffer(
-            pinned_memory, dtype=np.float16, count=candidate_tile_rows * dimensions
-        ).reshape(candidate_tile_rows, dimensions)
-        pinned_views.append(view)
-
-    # Device candidate buffers (double-buffered).
-    candidate_buffers = [
-        cupy.empty((candidate_tile_rows, dimensions), dtype=cupy.float16),
-        cupy.empty((candidate_tile_rows, dimensions), dtype=cupy.float16),
-    ]
-
-    # Pre-allocated FP32 similarity buffer reused as `out=` of every matmul.
-    similarity_buffer = cupy.empty(
-        (query_tile_rows, candidate_tile_rows), dtype=cupy.float32
-    )
-
-    # Running top-k state on device. -inf scores so the first tile populates them.
-    topk_scores = cupy.full((stripe_size, keep), -cupy.inf, dtype=cupy.float32)
-    topk_indices = cupy.full((stripe_size, keep), -1, dtype=cupy.int32)
-
-    copy_stream = cupy.cuda.Stream(non_blocking=True)
-    compute_stream = cupy.cuda.Stream(non_blocking=True)
-    copy_done = [
-        cupy.cuda.Event(disable_timing=True),
-        cupy.cuda.Event(disable_timing=True),
-    ]
-    compute_done = [
-        cupy.cuda.Event(disable_timing=True),
-        cupy.cuda.Event(disable_timing=True),
-    ]
-
-    candidate_offsets = list(range(0, total_vectors, candidate_tile_rows))
-
-    def stage_tile(slot: int, tile_offset: int) -> int:
-        """Stage a candidate tile: pinned scratch then async H2D into candidate_buffers[slot].
-
-        Host-side: waits for any previous H2D from this slot's pinned scratch before
-        overwriting it (otherwise the in-flight H2D could read torn data). Device-side:
-        waits for the previous compute that read this slot's device buffer.
-        """
-        count = min(candidate_tile_rows, total_vectors - tile_offset)
-        # Pinned scratch reuse: host-side wait on the previous H2D from this slot.
-        # (Synchronize on a never-recorded event is a no-op.)
-        copy_done[slot].synchronize()
-        np.copyto(
-            pinned_views[slot][:count], embeddings[tile_offset : tile_offset + count]
-        )
-        # Device buffer reuse: don't overwrite while compute is still reading it.
-        copy_stream.wait_event(compute_done[slot])
-        candidate_buffers[slot][:count].set(
-            pinned_views[slot][:count], stream=copy_stream
-        )
-        copy_done[slot].record(copy_stream)
-        return count
-
-    # Prime both slots so the steady-state loop has tiles ready on first compute.
-    counts = [0, 0]
-    for slot in range(min(2, len(candidate_offsets))):
-        counts[slot] = stage_tile(slot, candidate_offsets[slot])
-
-    started = time.monotonic()
-
-    for tile_idx, tile_offset in enumerate(candidate_offsets):
-        slot = tile_idx % 2
-        active_count = counts[slot]
-        active_device = candidate_buffers[slot][:active_count]
-
-        # Issue compute for the current tile, waiting for its H2D to complete.
-        compute_stream.wait_event(copy_done[slot])
-
-        with compute_stream:
-            for query_start in range(0, stripe_size, query_tile_rows):
-                query_end = min(query_start + query_tile_rows, stripe_size)
-                query_count = query_end - query_start
-                similarity_view = similarity_buffer[:query_count, :active_count]
-
-                # Pre-allocated FP32 buffer reused for every tile pair (the `out=` request).
-                cupy.matmul(
-                    query_stripe[query_start:query_end],
-                    active_device.T,
-                    out=similarity_view,
-                )
-
-                # Top-k for this tile via torch.topk (much faster than
-                # cupy.argpartition: ~150x measured at 16K x 64K f32). The DLPack
-                # bridge zero-copies the cupy buffer; outputs are still on the
-                # same device. When the final tile is shorter than `keep`,
-                # take all rows and pad with -inf sentinels.
-                if active_count >= keep:
-                    similarity_torch = torch.from_dlpack(similarity_view)
-                    tile_values_torch, tile_local_torch = torch.topk(
-                        similarity_torch, k=keep, dim=1, largest=True, sorted=False
-                    )
-                    tile_top_scores = cupy.from_dlpack(tile_values_torch)
-                    tile_top_indices = cupy.from_dlpack(tile_local_torch).astype(
-                        cupy.int32
-                    ) + cupy.int32(tile_offset)
-                else:
-                    pad = keep - active_count
-                    sub_global = cupy.arange(
-                        active_count, dtype=cupy.int32
-                    ) + cupy.int32(tile_offset)
-                    tile_top_indices = cupy.concatenate(
-                        [
-                            cupy.broadcast_to(sub_global, (query_count, active_count)),
-                            cupy.full((query_count, pad), -1, dtype=cupy.int32),
-                        ],
-                        axis=1,
-                    )
-                    tile_top_scores = cupy.concatenate(
-                        [
-                            similarity_view,
-                            cupy.full(
-                                (query_count, pad), -cupy.inf, dtype=cupy.float32
-                            ),
-                        ],
-                        axis=1,
-                    )
-
-                # Merge running top-k with this tile's top-k. Combined width is
-                # 2 * keep, which is small enough that another torch.topk is the
-                # right tool here too.
-                running_indices_chunk = topk_indices[query_start:query_end]
-                running_scores_chunk = topk_scores[query_start:query_end]
-                combined_scores = cupy.concatenate(
-                    [running_scores_chunk, tile_top_scores], axis=1
-                )
-                combined_indices = cupy.concatenate(
-                    [running_indices_chunk, tile_top_indices], axis=1
-                )
-                combined_torch = torch.from_dlpack(combined_scores)
-                merge_values_torch, merge_pos_torch = torch.topk(
-                    combined_torch, k=keep, dim=1, largest=True, sorted=False
-                )
-                merge_pos = cupy.from_dlpack(merge_pos_torch)
-                topk_scores[query_start:query_end] = cupy.from_dlpack(
-                    merge_values_torch
-                )
-                topk_indices[query_start:query_end] = cupy.take_along_axis(
-                    combined_indices, merge_pos, axis=1
-                )
-
-            compute_done[slot].record(compute_stream)
-
-        # Now that compute is queued, prefetch tile_idx+2 into this slot.
-        # copy_stream waits on compute_done[slot] before overwriting the device buffer,
-        # and stage_tile waits host-side on copy_done[slot] before overwriting pinned scratch.
-        prefetch_idx = tile_idx + 2
-        if prefetch_idx < len(candidate_offsets):
-            counts[slot] = stage_tile(slot, candidate_offsets[prefetch_idx])
-
-        if (tile_idx + 1) % 32 == 0 or tile_idx + 1 == len(candidate_offsets):
-            compute_stream.synchronize()
-            # Reclaim pooled blocks accumulated by intra-tile concat / take ops
-            # so pool growth doesn't drift toward the device limit.
-            cupy.get_default_memory_pool().free_all_blocks()
-            elapsed = time.monotonic() - started
-            done_candidates = (tile_idx + 1) * candidate_tile_rows
-            millions_per_second = done_candidates / max(elapsed, 1e-3) / 1e6
-            print(
-                f"[gpu{gpu_index}] tile {tile_idx + 1}/{len(candidate_offsets)} "
-                f"elapsed {elapsed:.0f}s ({millions_per_second:.2f}M cand/s)",
-                flush=True,
-            )
-
-    compute_stream.synchronize()
-
-    # Sort each row by descending score, then drop the self-match in a single shift.
-    sorted_order = cupy.argsort(-topk_scores, axis=1)
-    sorted_scores = cupy.take_along_axis(topk_scores, sorted_order, axis=1)
-    sorted_indices = cupy.take_along_axis(topk_indices, sorted_order, axis=1)
-
-    query_global_ids = cupy.arange(stripe_start, stripe_end, dtype=cupy.int32).reshape(
-        -1, 1
-    )
-    is_self = sorted_indices == query_global_ids
-    has_self = cupy.any(is_self, axis=1, keepdims=True)
-    self_pos = cupy.argmax(is_self.astype(cupy.int32), axis=1, keepdims=True)
-
-    output_columns = cupy.broadcast_to(
-        cupy.arange(num_neighbors, dtype=cupy.int32), (stripe_size, num_neighbors)
+    indices, scores = gt_stripe_dense(
+        embeddings_host=embeddings,
+        stripe_start=stripe_start,
+        stripe_end=stripe_end,
+        num_neighbors=num_neighbors,
+        query_tile_rows=query_tile_rows,
+        candidate_tile_rows=candidate_tile_rows,
+        log_prefix=f"[gpu{gpu_index} dense] ",
     )
-    shift_mask = (output_columns >= self_pos) & has_self
-    source_columns = output_columns + shift_mask.astype(cupy.int32)
-    final_scores = cupy.take_along_axis(sorted_scores, source_columns, axis=1)
-    final_indices = cupy.take_along_axis(sorted_indices, source_columns, axis=1)
-
     scratch_dir.mkdir(parents=True, exist_ok=True)
-    indices_path = scratch_dir / f"stripe_{gpu_index:02d}.ibin"
-    scores_path = scratch_dir / f"stripe_{gpu_index:02d}.fbin"
-    write_bin(indices_path, cupy.asnumpy(final_indices), dtype="i32")
-    write_bin(scores_path, cupy.asnumpy(final_scores), dtype="f32")
+    write_bin(scratch_dir / f"stripe_{gpu_index:02d}.ibin", indices, dtype="i32")
+    write_bin(scratch_dir / f"stripe_{gpu_index:02d}.fbin", scores, dtype="f32")
+    print(f"[gpu{gpu_index} dense] DONE -> stripe_{gpu_index:02d}.{{ibin,fbin}}", flush=True)
 
-    elapsed = time.monotonic() - started
+
+def maxsim_worker(
+    gpu_index: int,
+    num_gpus: int,
+    token_bank: np.ndarray,
+    section_offsets: np.ndarray,
+    num_neighbors: int,
+    query_tile_sections: int,
+    candidate_tile_sections: int,
+    scratch_dir: Path,
+) -> None:
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_index)
+    total_sections = section_offsets.shape[0] - 1
+    stripe_start = (total_sections * gpu_index) // num_gpus
+    stripe_end = (total_sections * (gpu_index + 1)) // num_gpus
     print(
-        f"[gpu{gpu_index}] DONE {stripe_size:,} queries in {elapsed:.0f}s "
-        f"-> {indices_path.name}, {scores_path.name}",
+        f"[gpu{gpu_index} maxsim] queries [{stripe_start:,}, {stripe_end:,}) "
+        f"vs corpus {total_sections:,} sections, {token_bank.shape[0]:,} tokens",
         flush=True,
     )
+    indices, scores = gt_stripe_maxsim(
+        token_bank_host=token_bank,
+        section_offsets_host=section_offsets,
+        stripe_start_section=stripe_start,
+        stripe_end_section=stripe_end,
+        num_neighbors=num_neighbors,
+        query_tile_sections=query_tile_sections,
+        candidate_tile_sections=candidate_tile_sections,
+        log_prefix=f"[gpu{gpu_index} maxsim] ",
+    )
+    scratch_dir.mkdir(parents=True, exist_ok=True)
+    write_bin(scratch_dir / f"stripe_{gpu_index:02d}.ibin", indices, dtype="i32")
+    write_bin(scratch_dir / f"stripe_{gpu_index:02d}.fbin", scores, dtype="f32")
+    print(f"[gpu{gpu_index} maxsim] DONE -> stripe_{gpu_index:02d}.{{ibin,fbin}}", flush=True)
 
 
 def gather_outputs(
@@ -331,17 +178,15 @@ def gather_outputs(
     suffix: str,
     shards: list[CollectionShard],
     num_gpus: int,
-    total_vectors: int,
+    total_rows: int,
     num_neighbors: int,
 ) -> None:
-    """Slice per-stripe scratch files into per-shard `.ground_truth.ibin` and `.ground_truth.fbin`,
-    so each shard's ground truth lives next to its source `.f16bin`.
-
-    Each per-stripe scratch is contiguous global rows. A single shard may straddle
-    a stripe boundary, so we may pull from up to two stripes per shard.
+    """Slice per-stripe scratch files into per-shard
+    `.{suffix}.ground_truth.{ibin,fbin}` files. Each `CollectionShard.row_count`
+    is in whatever unit the per-stripe rows were written (articles for dense,
+    sections for maxsim) — `gather_outputs` is unit-agnostic.
     """
-    bytes_per_row_indices = num_neighbors * 4
-    bytes_per_row_scores = num_neighbors * 4
+    bytes_per_row = num_neighbors * 4
     indices_files = [
         open(scratch_dir / f"stripe_{gpu_index:02d}.ibin", "rb")
         for gpu_index in range(num_gpus)
@@ -351,9 +196,8 @@ def gather_outputs(
         for gpu_index in range(num_gpus)
     ]
     try:
-        # Stripe boundary table (cumulative row counts).
         stripe_starts = [
-            (total_vectors * gpu_index) // num_gpus for gpu_index in range(num_gpus + 1)
+            (total_rows * gpu_index) // num_gpus for gpu_index in range(num_gpus + 1)
         ]
         for shard in shards:
             wiki_dir = model_root / shard.wikiname
@@ -369,32 +213,21 @@ def gather_outputs(
                 cursor = shard.row_offset
                 shard_end = shard.row_offset + shard.row_count
                 while cursor < shard_end:
-                    # Find which stripe owns `cursor`.
                     stripe_index = next(
                         gpu_index
                         for gpu_index in range(num_gpus)
-                        if stripe_starts[gpu_index]
-                        <= cursor
-                        < stripe_starts[gpu_index + 1]
+                        if stripe_starts[gpu_index] <= cursor < stripe_starts[gpu_index + 1]
                     )
                     chunk_end = min(shard_end, stripe_starts[stripe_index + 1])
                     chunk_rows = chunk_end - cursor
                     offset_in_stripe = cursor - stripe_starts[stripe_index]
-                    indices_files[stripe_index].seek(
-                        8 + offset_in_stripe * bytes_per_row_indices
-                    )
-                    scores_files[stripe_index].seek(
-                        8 + offset_in_stripe * bytes_per_row_scores
-                    )
+                    indices_files[stripe_index].seek(8 + offset_in_stripe * bytes_per_row)
+                    scores_files[stripe_index].seek(8 + offset_in_stripe * bytes_per_row)
                     out_indices.write(
-                        indices_files[stripe_index].read(
-                            chunk_rows * bytes_per_row_indices
-                        )
+                        indices_files[stripe_index].read(chunk_rows * bytes_per_row)
                     )
                     out_scores.write(
-                        scores_files[stripe_index].read(
-                            chunk_rows * bytes_per_row_scores
-                        )
+                        scores_files[stripe_index].read(chunk_rows * bytes_per_row)
                     )
                     cursor = chunk_end
     finally:
@@ -402,41 +235,7 @@ def gather_outputs(
             handle.close()
 
 
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--output", default="/home/ubuntu/wikiverse-data/embeddings")
-    parser.add_argument(
-        "--model-subdir",
-        default="qwen3-embedding-0.6b",
-        help="collection lives at {output}/{model-subdir}/",
-    )
-    parser.add_argument(
-        "--dimensions",
-        type=int,
-        default=1024,
-        help="embedding dimensionality (1024 Qwen3/arctic, 768 nomic, 4096 e5-mistral)",
-    )
-    parser.add_argument("--output-suffix", default="body", choices=["body", "title"])
-    parser.add_argument("--num-neighbors", type=int, default=100)
-    parser.add_argument("--num-gpus", type=int, default=8)
-    parser.add_argument(
-        "--query-tile-rows",
-        type=int,
-        default=16384,
-        help="rows per query chunk inside the resident stripe",
-    )
-    parser.add_argument(
-        "--candidate-tile-rows",
-        type=int,
-        default=131072,
-        help="rows per candidate tile streamed past the query stripe",
-    )
-    args = parser.parse_args()
-
-    model_root = Path(args.output) / args.model_subdir
-    if not model_root.is_dir():
-        raise SystemExit(f"no collection at {model_root}")
-
+def run_dense(args, model_root: Path) -> None:
     shards = discover_collection(model_root, args.output_suffix)
     if not shards:
         raise SystemExit(f"no .{args.output_suffix}.f16bin files under {model_root}")
@@ -448,10 +247,16 @@ def main() -> None:
         flush=True,
     )
 
-    embeddings = load_collection(
-        model_root, args.output_suffix, args.dimensions, shards
-    )
+    # Read dimensions from the first shard's header.
+    first_blob = resolve_lfs_pointer(shards[0].path)
+    with open(first_blob, "rb") as file:
+        _, dimensions = struct.unpack("<II", file.read(8))
+    if args.dimensions and args.dimensions != dimensions:
+        raise SystemExit(
+            f"--dimensions {args.dimensions} != on-disk {dimensions} for {model_root}"
+        )
 
+    embeddings = load_dense_collection(model_root, args.output_suffix, dimensions, shards)
     scratch_dir = model_root / f"_ground_truth_scratch_{args.output_suffix}"
     scratch_dir.mkdir(parents=True, exist_ok=True)
 
@@ -459,12 +264,11 @@ def main() -> None:
     workers: list[mp.Process] = []
     for gpu_index in range(args.num_gpus):
         process = mp_context.Process(
-            target=worker_main,
+            target=dense_worker,
             args=(
                 gpu_index,
                 args.num_gpus,
                 embeddings,
-                args.dimensions,
                 args.num_neighbors,
                 args.query_tile_rows,
                 args.candidate_tile_rows,
@@ -480,8 +284,7 @@ def main() -> None:
         if process.exitcode != 0:
             failed = True
             print(
-                f"worker pid {process.pid} exited with code {process.exitcode}",
-                flush=True,
+                f"worker pid {process.pid} exited code {process.exitcode}", flush=True
             )
     if failed:
         raise SystemExit("one or more GPU workers failed")
@@ -497,15 +300,137 @@ def main() -> None:
     )
     print(
         f"wrote {len(shards)} per-shard "
-        f"`.{args.output_suffix}.ground_truth.ibin` + `.{args.output_suffix}.ground_truth.fbin` "
-        f"files under {model_root}",
+        f"`.{args.output_suffix}.ground_truth.{{ibin,fbin}}` files under {model_root}",
         flush=True,
     )
+    for path in scratch_dir.iterdir():
+        path.unlink()
+    scratch_dir.rmdir()
 
+
+def run_maxsim(args, model_root: Path) -> None:
+    started = time.monotonic()
+    print(f"loading multi-vector corpus under {model_root} ...", flush=True)
+    token_bank, section_offsets, shards, dimensions = _load_maxsim_corpus_to_host(
+        model_root, args.output_suffix
+    )
+    elapsed = time.monotonic() - started
+    total_sections = section_offsets.shape[0] - 1
+    total_tokens = token_bank.shape[0]
+    print(
+        f"loaded {total_sections:,} sections, {total_tokens:,} tokens "
+        f"({token_bank.nbytes/1e9:.1f} GB) across {len(shards)} shards "
+        f"in {elapsed:.1f}s; dim={dimensions}",
+        flush=True,
+    )
+
+    scratch_dir = model_root / f"_ground_truth_scratch_{args.output_suffix}"
+    scratch_dir.mkdir(parents=True, exist_ok=True)
+
+    mp_context = mp.get_context("fork")
+    workers: list[mp.Process] = []
+    for gpu_index in range(args.num_gpus):
+        process = mp_context.Process(
+            target=maxsim_worker,
+            args=(
+                gpu_index,
+                args.num_gpus,
+                token_bank,
+                section_offsets,
+                args.num_neighbors,
+                args.query_tile_sections,
+                args.candidate_tile_sections,
+                scratch_dir,
+            ),
+        )
+        process.start()
+        workers.append(process)
+
+    failed = False
+    for process in workers:
+        process.join()
+        if process.exitcode != 0:
+            failed = True
+            print(
+                f"worker pid {process.pid} exited code {process.exitcode}", flush=True
+            )
+    if failed:
+        raise SystemExit("one or more GPU workers failed")
+
+    gather_outputs(
+        scratch_dir,
+        model_root,
+        args.output_suffix,
+        shards,
+        args.num_gpus,
+        total_sections,
+        args.num_neighbors,
+    )
+    print(
+        f"wrote {len(shards)} per-shard "
+        f"`.{args.output_suffix}.ground_truth.{{ibin,fbin}}` files under {model_root}",
+        flush=True,
+    )
     for path in scratch_dir.iterdir():
         path.unlink()
     scratch_dir.rmdir()
 
 
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--mode",
+        default="dense",
+        choices=["dense", "maxsim"],
+        help="dense = single vector per row (cosine); maxsim = multi-vector per "
+        "section (ColBERT late interaction)",
+    )
+    parser.add_argument("--output", default="/home/ubuntu/USearchWiki")
+    parser.add_argument("--model-subdir", required=True)
+    parser.add_argument(
+        "--dimensions",
+        type=int,
+        default=0,
+        help="optional sanity check; if 0, read from first shard's header (dense only)",
+    )
+    parser.add_argument("--output-suffix", default="body", choices=["body", "title"])
+    parser.add_argument("--num-neighbors", type=int, default=100)
+    parser.add_argument("--num-gpus", type=int, default=8)
+    parser.add_argument(
+        "--query-tile-rows",
+        type=int,
+        default=16384,
+        help="dense: rows per query chunk inside the resident stripe",
+    )
+    parser.add_argument(
+        "--candidate-tile-rows",
+        type=int,
+        default=131072,
+        help="dense: rows per candidate tile streamed past the query stripe",
+    )
+    parser.add_argument(
+        "--query-tile-sections",
+        type=int,
+        default=256,
+        help="maxsim: sections per query micro-batch",
+    )
+    parser.add_argument(
+        "--candidate-tile-sections",
+        type=int,
+        default=65536,
+        help="maxsim: sections per streamed candidate tile",
+    )
+    args = parser.parse_args()
+
+    model_root = Path(args.output) / args.model_subdir
+    if not model_root.is_dir():
+        raise SystemExit(f"no collection at {model_root}")
+
+    if args.mode == "dense":
+        run_dense(args, model_root)
+    else:
+        run_maxsim(args, model_root)
+
+
 if __name__ == "__main__":
     main()

retrievers.py

@@ -0,0 +1,845 @@
+"""Brute-force retrievers + shared GPU kernels.
+
+Two retriever families share one streaming-top-k template:
+  - DenseRetriever: cosine top-k over an `(N, dim)` FP16 corpus.
+  - MaxSimRetriever: ColBERT-style late interaction over a multi-vector
+    corpus (`(T_total, dim)` token bank + `(N+1,)` section offsets).
+
+Both compute an `(Q, M)` score matrix per candidate tile, merge it into the
+running top-k, and repeat. They differ only in the per-tile score kernel:
+
+  - Dense: a single FP16 matmul into a pre-allocated FP32 `out=` buffer.
+  - MaxSim: matmul + segment-max along ragged doc-token offsets +
+    segment-sum along ragged query-token offsets, via two small RawKernels.
+
+The same streaming loop is exposed two ways:
+  - `gt_stripe_*` functions: per-GPU stripe workers used by `ground_truth.py`
+    for the all-vs-all corpus sweep (host-resident corpus, double-buffered
+    H2D for candidate tiles, query stripe resident on-device).
+  - `DenseRetriever` / `MaxSimRetriever` classes: consumer-facing search,
+    corpus loaded once at construction and held resident on a single GPU.
+    `search()` becomes a single `gt_stripe_*` call with the resident corpus
+    used as the candidate stream.
+"""
+
+from __future__ import annotations
+
+import struct
+import time
+from pathlib import Path
+
+import numpy as np
+
+from usearchwiki import (
+    CollectionShard,
+    discover_collection,
+    resolve_lfs_pointer,
+)
+
+
+# Two ragged-segment reductions for MaxSim. Each thread handles one (row,
+# segment) cell; the inner loop is bounded by the segment width (median 3,
+# p99 ~16 for FineWiki sections, so a single warp easily covers the worst
+# rows without divergence pain).
+_SEGMENT_MAX_SRC = r"""
+extern "C" __global__ void segment_max_2d(
+    const float* __restrict__ values,
+    const int* __restrict__ offsets,
+    float* __restrict__ out,
+    int rows, int n_segments, int row_stride, int out_stride
+) {
+    int seg = blockIdx.x * blockDim.x + threadIdx.x;
+    int row = blockIdx.y * blockDim.y + threadIdx.y;
+    if (row >= rows || seg >= n_segments) return;
+    int start = offsets[seg];
+    int end   = offsets[seg + 1];
+    const float* row_ptr = values + row * row_stride;
+    float best = -3.4e38f;
+    for (int t = start; t < end; ++t) {
+        float v = row_ptr[t];
+        if (v > best) best = v;
+    }
+    out[row * out_stride + seg] = best;
+}
+"""
+
+_SEGMENT_SUM_SRC = r"""
+extern "C" __global__ void segment_sum_2d(
+    const float* __restrict__ values,
+    const int* __restrict__ offsets,
+    float* __restrict__ out,
+    int n_segments, int n_cols, int row_stride, int out_stride
+) {
+    int col = blockIdx.x * blockDim.x + threadIdx.x;
+    int seg = blockIdx.y * blockDim.y + threadIdx.y;
+    if (seg >= n_segments || col >= n_cols) return;
+    int start = offsets[seg];
+    int end   = offsets[seg + 1];
+    float total = 0.0f;
+    for (int t = start; t < end; ++t) {
+        total += values[t * row_stride + col];
+    }
+    out[seg * out_stride + col] = total;
+}
+"""
+
+_SEGMENT_MAX_KERNEL = None
+_SEGMENT_SUM_KERNEL = None
+
+
+def _segment_kernels():
+    global _SEGMENT_MAX_KERNEL, _SEGMENT_SUM_KERNEL
+    if _SEGMENT_MAX_KERNEL is None:
+        import cupy
+
+        _SEGMENT_MAX_KERNEL = cupy.RawKernel(_SEGMENT_MAX_SRC, "segment_max_2d")
+        _SEGMENT_SUM_KERNEL = cupy.RawKernel(_SEGMENT_SUM_SRC, "segment_sum_2d")
+    return _SEGMENT_MAX_KERNEL, _SEGMENT_SUM_KERNEL
+
+
+def _topk_merge(
+    running_scores,
+    running_indices,
+    tile_scores,
+    tile_indices,
+    keep,
+):
+    """Merge a (rows, keep) running top-k with a (rows, *) tile top-k. Returns
+    the new top-k. `tile_scores` / `tile_indices` may already be (rows, keep)
+    (precomputed via `torch.topk` on the full tile-similarity row) or wider.
+    """
+    import cupy
+    import torch
+
+    combined_scores = cupy.concatenate([running_scores, tile_scores], axis=1)
+    combined_indices = cupy.concatenate([running_indices, tile_indices], axis=1)
+    combined_torch = torch.from_dlpack(combined_scores)
+    merge_values, merge_pos = torch.topk(
+        combined_torch, k=keep, dim=1, largest=True, sorted=False
+    )
+    new_scores = cupy.from_dlpack(merge_values)
+    new_indices = cupy.take_along_axis(combined_indices, cupy.from_dlpack(merge_pos), axis=1)
+    return new_scores, new_indices
+
+
+def _tile_topk_dense(similarity_view, keep, candidate_offset_global, query_count, active_count):
+    """Top-k inside one (Q, M) FP32 similarity tile -> global indices. Pads to
+    `keep` columns when the tile is shorter than `keep`.
+    """
+    import cupy
+    import torch
+
+    if active_count >= keep:
+        sim_torch = torch.from_dlpack(similarity_view)
+        values, local = torch.topk(sim_torch, k=keep, dim=1, largest=True, sorted=False)
+        return (
+            cupy.from_dlpack(values),
+            cupy.from_dlpack(local).astype(cupy.int32) + cupy.int32(candidate_offset_global),
+        )
+    pad = keep - active_count
+    sub_global = cupy.arange(active_count, dtype=cupy.int32) + cupy.int32(
+        candidate_offset_global
+    )
+    indices = cupy.concatenate(
+        [
+            cupy.broadcast_to(sub_global, (query_count, active_count)),
+            cupy.full((query_count, pad), -1, dtype=cupy.int32),
+        ],
+        axis=1,
+    )
+    scores = cupy.concatenate(
+        [similarity_view, cupy.full((query_count, pad), -cupy.inf, dtype=cupy.float32)],
+        axis=1,
+    )
+    return scores, indices
+
+
+def _drop_self(sorted_scores, sorted_indices, query_global_ids, num_neighbors):
+    """Sort each row by descending score, then drop the (up-to-one) row whose
+    index equals the query's own global id. Pure cupy, vectorized over rows.
+    """
+    import cupy
+
+    is_self = sorted_indices == query_global_ids.reshape(-1, 1)
+    has_self = cupy.any(is_self, axis=1, keepdims=True)
+    self_pos = cupy.argmax(is_self.astype(cupy.int32), axis=1, keepdims=True)
+    rows = sorted_scores.shape[0]
+    output_columns = cupy.broadcast_to(
+        cupy.arange(num_neighbors, dtype=cupy.int32), (rows, num_neighbors)
+    )
+    shift_mask = (output_columns >= self_pos) & has_self
+    source_columns = output_columns + shift_mask.astype(cupy.int32)
+    final_scores = cupy.take_along_axis(sorted_scores, source_columns, axis=1)
+    final_indices = cupy.take_along_axis(sorted_indices, source_columns, axis=1)
+    return final_indices, final_scores
+
+
+def gt_stripe_dense(
+    embeddings_host: np.ndarray,
+    stripe_start: int,
+    stripe_end: int,
+    num_neighbors: int,
+    query_tile_rows: int,
+    candidate_tile_rows: int,
+    log_prefix: str = "",
+):
+    """Compute top-k for `embeddings_host[stripe_start:stripe_end]` against
+    the *whole* `embeddings_host` corpus, with double-buffered H2D streaming
+    of candidate tiles. Returns `(indices, scores)` numpy arrays of shape
+    `(stripe_end - stripe_start, num_neighbors)` in i32 / f32.
+
+    Caller is responsible for picking the GPU (`CUDA_VISIBLE_DEVICES`).
+    """
+    import cupy
+    import torch  # noqa: F401  (used inside helpers)
+
+    total_vectors, dimensions = embeddings_host.shape
+    stripe_size = stripe_end - stripe_start
+    keep = num_neighbors + 1
+
+    query_stripe = cupy.asarray(embeddings_host[stripe_start:stripe_end])
+
+    pinned_holders = []
+    pinned_views: list[np.ndarray] = []
+    for _ in range(2):
+        pinned = cupy.cuda.alloc_pinned_memory(candidate_tile_rows * dimensions * 2)
+        pinned_holders.append(pinned)
+        view = np.frombuffer(
+            pinned, dtype=np.float16, count=candidate_tile_rows * dimensions
+        ).reshape(candidate_tile_rows, dimensions)
+        pinned_views.append(view)
+
+    candidate_buffers = [
+        cupy.empty((candidate_tile_rows, dimensions), dtype=cupy.float16),
+        cupy.empty((candidate_tile_rows, dimensions), dtype=cupy.float16),
+    ]
+    similarity_buffer = cupy.empty(
+        (query_tile_rows, candidate_tile_rows), dtype=cupy.float32
+    )
+    topk_scores = cupy.full((stripe_size, keep), -cupy.inf, dtype=cupy.float32)
+    topk_indices = cupy.full((stripe_size, keep), -1, dtype=cupy.int32)
+
+    copy_stream = cupy.cuda.Stream(non_blocking=True)
+    compute_stream = cupy.cuda.Stream(non_blocking=True)
+    copy_done = [
+        cupy.cuda.Event(disable_timing=True),
+        cupy.cuda.Event(disable_timing=True),
+    ]
+    compute_done = [
+        cupy.cuda.Event(disable_timing=True),
+        cupy.cuda.Event(disable_timing=True),
+    ]
+
+    candidate_offsets = list(range(0, total_vectors, candidate_tile_rows))
+
+    def stage(slot: int, tile_offset: int) -> int:
+        count = min(candidate_tile_rows, total_vectors - tile_offset)
+        copy_done[slot].synchronize()
+        np.copyto(
+            pinned_views[slot][:count],
+            embeddings_host[tile_offset : tile_offset + count],
+        )
+        copy_stream.wait_event(compute_done[slot])
+        candidate_buffers[slot][:count].set(pinned_views[slot][:count], stream=copy_stream)
+        copy_done[slot].record(copy_stream)
+        return count
+
+    counts = [0, 0]
+    for slot in range(min(2, len(candidate_offsets))):
+        counts[slot] = stage(slot, candidate_offsets[slot])
+
+    started = time.monotonic()
+    for tile_idx, tile_offset in enumerate(candidate_offsets):
+        slot = tile_idx % 2
+        active_count = counts[slot]
+        active_device = candidate_buffers[slot][:active_count]
+        compute_stream.wait_event(copy_done[slot])
+
+        with compute_stream:
+            for query_start in range(0, stripe_size, query_tile_rows):
+                query_end = min(query_start + query_tile_rows, stripe_size)
+                query_count = query_end - query_start
+                similarity_view = similarity_buffer[:query_count, :active_count]
+                cupy.matmul(
+                    query_stripe[query_start:query_end],
+                    active_device.T,
+                    out=similarity_view,
+                )
+                tile_scores, tile_indices = _tile_topk_dense(
+                    similarity_view, keep, tile_offset, query_count, active_count
+                )
+                new_scores, new_indices = _topk_merge(
+                    topk_scores[query_start:query_end],
+                    topk_indices[query_start:query_end],
+                    tile_scores,
+                    tile_indices,
+                    keep,
+                )
+                topk_scores[query_start:query_end] = new_scores
+                topk_indices[query_start:query_end] = new_indices
+            compute_done[slot].record(compute_stream)
+
+        prefetch_idx = tile_idx + 2
+        if prefetch_idx < len(candidate_offsets):
+            counts[slot] = stage(slot, candidate_offsets[prefetch_idx])
+
+        if (tile_idx + 1) % 32 == 0 or tile_idx + 1 == len(candidate_offsets):
+            compute_stream.synchronize()
+            cupy.get_default_memory_pool().free_all_blocks()
+            elapsed = time.monotonic() - started
+            done = (tile_idx + 1) * candidate_tile_rows
+            rate = done / max(elapsed, 1e-3) / 1e6
+            print(
+                f"{log_prefix}tile {tile_idx + 1}/{len(candidate_offsets)} "
+                f"elapsed {elapsed:.0f}s ({rate:.2f}M cand/s)",
+                flush=True,
+            )
+
+    compute_stream.synchronize()
+
+    sorted_order = cupy.argsort(-topk_scores, axis=1)
+    sorted_scores = cupy.take_along_axis(topk_scores, sorted_order, axis=1)
+    sorted_indices = cupy.take_along_axis(topk_indices, sorted_order, axis=1)
+    query_global_ids = cupy.arange(stripe_start, stripe_end, dtype=cupy.int32)
+    final_indices, final_scores = _drop_self(
+        sorted_scores, sorted_indices, query_global_ids, num_neighbors
+    )
+    return cupy.asnumpy(final_indices), cupy.asnumpy(final_scores)
+
+
+def gt_stripe_maxsim(
+    token_bank_host: np.ndarray,
+    section_offsets_host: np.ndarray,
+    stripe_start_section: int,
+    stripe_end_section: int,
+    num_neighbors: int,
+    query_tile_sections: int,
+    candidate_tile_sections: int,
+    log_prefix: str = "",
+):
+    """Compute MaxSim top-k for sections in
+    `[stripe_start_section, stripe_end_section)` against the whole section
+    corpus. Returns `(indices, scores)` numpy arrays of shape
+    `(stripe_size, num_neighbors)`.
+
+    `token_bank_host` is `(T_total, dim)` FP16; `section_offsets_host` is
+    `(N+1,)` int32 with cumulative token counts (so section i's tokens live
+    at rows `[offsets[i]:offsets[i+1]]`).
+    """
+    import cupy
+    import torch  # noqa: F401
+
+    total_sections = section_offsets_host.shape[0] - 1
+    dimensions = token_bank_host.shape[1]
+    stripe_size = stripe_end_section - stripe_start_section
+    keep = num_neighbors + 1
+
+    query_token_start = int(section_offsets_host[stripe_start_section])
+    query_token_end = int(section_offsets_host[stripe_end_section])
+    query_token_count = query_token_end - query_token_start
+    query_tokens_device = cupy.asarray(token_bank_host[query_token_start:query_token_end])
+    # Per-stripe local section offsets (zeroed against query_token_start).
+    query_section_offsets_local = (
+        section_offsets_host[stripe_start_section : stripe_end_section + 1]
+        - query_token_start
+    ).astype(np.int32)
+    query_section_offsets_device = cupy.asarray(query_section_offsets_local)
+
+    seg_max_kernel, seg_sum_kernel = _segment_kernels()
+
+    candidate_starts = list(range(0, total_sections, candidate_tile_sections))
+
+    # Pre-compute per-tile token byte budget so we can size pinned buffers.
+    max_tile_tokens = 0
+    for cand_start in candidate_starts:
+        cand_end = min(cand_start + candidate_tile_sections, total_sections)
+        tile_tokens = int(
+            section_offsets_host[cand_end] - section_offsets_host[cand_start]
+        )
+        if tile_tokens > max_tile_tokens:
+            max_tile_tokens = tile_tokens
+
+    pinned_holders = []
+    pinned_views: list[np.ndarray] = []
+    for _ in range(2):
+        pinned = cupy.cuda.alloc_pinned_memory(max_tile_tokens * dimensions * 2)
+        pinned_holders.append(pinned)
+        view = np.frombuffer(
+            pinned, dtype=np.float16, count=max_tile_tokens * dimensions
+        ).reshape(max_tile_tokens, dimensions)
+        pinned_views.append(view)
+
+    doc_token_buffers = [
+        cupy.empty((max_tile_tokens, dimensions), dtype=cupy.float16),
+        cupy.empty((max_tile_tokens, dimensions), dtype=cupy.float16),
+    ]
+    doc_offsets_buffers = [
+        cupy.empty((candidate_tile_sections + 1,), dtype=cupy.int32),
+        cupy.empty((candidate_tile_sections + 1,), dtype=cupy.int32),
+    ]
+
+    # Pre-allocated FP32 scratch buffers reused across tiles.
+    sim_buffer = cupy.empty(
+        (query_tile_sections * 64, max_tile_tokens), dtype=cupy.float32
+    )
+    # Bound on per-stripe query tokens per tile is `max query tokens` over the
+    # query stripe. A safe upper bound for the buffer is the full stripe's
+    # token count, but we tile queries by section count too — so size
+    # generously to avoid mid-loop re-allocs.
+    max_query_tokens_per_tile = int(
+        max(
+            section_offsets_host[
+                min(stripe_start_section + query_tile_sections, stripe_end_section)
+            ]
+            - section_offsets_host[stripe_start_section],
+            section_offsets_host[stripe_end_section]
+            - section_offsets_host[
+                max(stripe_end_section - query_tile_sections, stripe_start_section)
+            ],
+        )
+    )
+    # Re-size sim_buffer if it's too small for the worst-case (q_tokens, m_tokens).
+    if sim_buffer.shape[0] < max_query_tokens_per_tile:
+        sim_buffer = cupy.empty(
+            (max_query_tokens_per_tile, max_tile_tokens), dtype=cupy.float32
+        )
+    per_token_max = cupy.empty(
+        (max_query_tokens_per_tile, candidate_tile_sections), dtype=cupy.float32
+    )
+    score_out = cupy.empty(
+        (query_tile_sections, candidate_tile_sections), dtype=cupy.float32
+    )
+
+    topk_scores = cupy.full((stripe_size, keep), -cupy.inf, dtype=cupy.float32)
+    topk_indices = cupy.full((stripe_size, keep), -1, dtype=cupy.int32)
+
+    copy_stream = cupy.cuda.Stream(non_blocking=True)
+    compute_stream = cupy.cuda.Stream(non_blocking=True)
+    copy_done = [
+        cupy.cuda.Event(disable_timing=True),
+        cupy.cuda.Event(disable_timing=True),
+    ]
+    compute_done = [
+        cupy.cuda.Event(disable_timing=True),
+        cupy.cuda.Event(disable_timing=True),
+    ]
+
+    def stage(slot: int, cand_start: int):
+        cand_end = min(cand_start + candidate_tile_sections, total_sections)
+        section_count = cand_end - cand_start
+        token_start = int(section_offsets_host[cand_start])
+        token_end = int(section_offsets_host[cand_end])
+        token_count = token_end - token_start
+        copy_done[slot].synchronize()
+        np.copyto(
+            pinned_views[slot][:token_count],
+            token_bank_host[token_start:token_end],
+        )
+        # Local doc offsets, zeroed against token_start.
+        local_offsets = (
+            section_offsets_host[cand_start : cand_end + 1] - token_start
+        ).astype(np.int32)
+        copy_stream.wait_event(compute_done[slot])
+        doc_token_buffers[slot][:token_count].set(
+            pinned_views[slot][:token_count], stream=copy_stream
+        )
+        doc_offsets_buffers[slot][: section_count + 1].set(
+            local_offsets, stream=copy_stream
+        )
+        copy_done[slot].record(copy_stream)
+        return section_count, token_count
+
+    counts = [(0, 0), (0, 0)]
+    for slot in range(min(2, len(candidate_starts))):
+        counts[slot] = stage(slot, candidate_starts[slot])
+
+    block = (16, 16, 1)
+    started = time.monotonic()
+
+    for tile_idx, cand_start in enumerate(candidate_starts):
+        slot = tile_idx % 2
+        section_count, token_count = counts[slot]
+        if section_count == 0:
+            continue
+        compute_stream.wait_event(copy_done[slot])
+
+        doc_tokens_dev = doc_token_buffers[slot][:token_count]
+        doc_offsets_dev = doc_offsets_buffers[slot][: section_count + 1]
+
+        with compute_stream:
+            for q_section_start in range(0, stripe_size, query_tile_sections):
+                q_section_end = min(q_section_start + query_tile_sections, stripe_size)
+                q_count = q_section_end - q_section_start
+                q_token_lo = int(query_section_offsets_local[q_section_start])
+                q_token_hi = int(query_section_offsets_local[q_section_end])
+                q_token_count = q_token_hi - q_token_lo
+                if q_token_count == 0:
+                    continue
+                q_tokens_dev = query_tokens_device[q_token_lo:q_token_hi]
+                # Local query offsets for this micro-batch (zeroed against q_token_lo).
+                q_offsets_micro = (
+                    query_section_offsets_device[q_section_start : q_section_end + 1]
+                    - cupy.int32(q_token_lo)
+                )
+
+                sim_view = sim_buffer[:q_token_count, :token_count]
+                cupy.matmul(q_tokens_dev, doc_tokens_dev.T, out=sim_view)
+
+                pt_max_view = per_token_max[:q_token_count, :section_count]
+                grid_max = (
+                    (section_count + block[0] - 1) // block[0],
+                    (q_token_count + block[1] - 1) // block[1],
+                    1,
+                )
+                seg_max_kernel(
+                    grid_max,
+                    block,
+                    (
+                        sim_view,
+                        doc_offsets_dev,
+                        pt_max_view,
+                        np.int32(q_token_count),
+                        np.int32(section_count),
+                        np.int32(sim_buffer.shape[1]),
+                        np.int32(per_token_max.shape[1]),
+                    ),
+                )
+
+                score_view = score_out[:q_count, :section_count]
+                grid_sum = (
+                    (section_count + block[0] - 1) // block[0],
+                    (q_count + block[1] - 1) // block[1],
+                    1,
+                )
+                seg_sum_kernel(
+                    grid_sum,
+                    block,
+                    (
+                        pt_max_view,
+                        q_offsets_micro,
+                        score_view,
+                        np.int32(q_count),
+                        np.int32(section_count),
+                        np.int32(per_token_max.shape[1]),
+                        np.int32(score_out.shape[1]),
+                    ),
+                )
+
+                tile_scores, tile_indices = _tile_topk_dense(
+                    score_view, keep, cand_start, q_count, section_count
+                )
+                new_scores, new_indices = _topk_merge(
+                    topk_scores[q_section_start:q_section_end],
+                    topk_indices[q_section_start:q_section_end],
+                    tile_scores,
+                    tile_indices,
+                    keep,
+                )
+                topk_scores[q_section_start:q_section_end] = new_scores
+                topk_indices[q_section_start:q_section_end] = new_indices
+            compute_done[slot].record(compute_stream)
+
+        prefetch_idx = tile_idx + 2
+        if prefetch_idx < len(candidate_starts):
+            counts[slot] = stage(slot, candidate_starts[prefetch_idx])
+
+        if (tile_idx + 1) % 32 == 0 or tile_idx + 1 == len(candidate_starts):
+            compute_stream.synchronize()
+            cupy.get_default_memory_pool().free_all_blocks()
+            elapsed = time.monotonic() - started
+            done = (tile_idx + 1) * candidate_tile_sections
+            rate = done / max(elapsed, 1e-3) / 1e6
+            print(
+                f"{log_prefix}tile {tile_idx + 1}/{len(candidate_starts)} "
+                f"elapsed {elapsed:.0f}s ({rate:.2f}M sect/s)",
+                flush=True,
+            )
+
+    compute_stream.synchronize()
+
+    sorted_order = cupy.argsort(-topk_scores, axis=1)
+    sorted_scores = cupy.take_along_axis(topk_scores, sorted_order, axis=1)
+    sorted_indices = cupy.take_along_axis(topk_indices, sorted_order, axis=1)
+    query_global_ids = cupy.arange(
+        stripe_start_section, stripe_end_section, dtype=cupy.int32
+    )
+    final_indices, final_scores = _drop_self(
+        sorted_scores, sorted_indices, query_global_ids, num_neighbors
+    )
+    return cupy.asnumpy(final_indices), cupy.asnumpy(final_scores)
+
+
+# ---------------------------------------------------------------------------
+# Consumer-facing classes: load corpus once, search many.
+# ---------------------------------------------------------------------------
+
+
+def _read_header(path: Path) -> tuple[int, int]:
+    blob = resolve_lfs_pointer(path)
+    with open(blob, "rb") as file:
+        rows, columns = struct.unpack("<II", file.read(8))
+    return rows, columns
+
+
+def _load_dense_corpus_to_host(
+    model_root: Path, suffix: str, shards: list[CollectionShard]
+) -> tuple[np.ndarray, int]:
+    """Same data-load contract as `ground_truth.load_collection` but kept here
+    so `DenseRetriever` doesn't need to import the GT script.
+    """
+    if not shards:
+        raise ValueError(f"no shards under {model_root}")
+    _, dimensions = _read_header(shards[0].path)
+    total = sum(s.row_count for s in shards)
+    embeddings = np.empty((total, dimensions), dtype=np.float16)
+    for shard in shards:
+        blob = resolve_lfs_pointer(shard.path)
+        with open(blob, "rb") as file:
+            file.seek(8)
+            destination = embeddings[shard.row_offset : shard.row_offset + shard.row_count]
+            file.readinto(memoryview(destination))  # type: ignore[arg-type]
+    bad = ~np.isfinite(embeddings).all(axis=1)
+    if bad.any():
+        embeddings[bad] = 0
+    return embeddings, dimensions
+
+
+def _load_maxsim_corpus_to_host(
+    model_root: Path, suffix: str
+) -> tuple[np.ndarray, np.ndarray, list[CollectionShard], int]:
+    """Walk `*.{suffix}.sections.f16bin` + `*.sections.offsets.ibin` shards in
+    canonical order. Return `(token_bank, section_offsets, shards, dimensions)`.
+
+    `section_offsets` has shape `(total_sections + 1,)` int32 cumulative across
+    all shards (so section i's tokens are at `token_bank[offsets[i]:offsets[i+1]]`).
+    Each `CollectionShard.row_count` is the number of *sections* in that shard,
+    `row_offset` is the cumulative section count.
+    """
+    if not model_root.is_dir():
+        raise FileNotFoundError(f"no model directory at {model_root}")
+    shards: list[CollectionShard] = []
+    cumulative_sections = 0
+    cumulative_tokens = 0
+    section_offsets_chunks: list[np.ndarray] = []
+    section_offsets_chunks.append(np.zeros(1, dtype=np.int32))
+    token_chunks: list[tuple[int, int, Path]] = []  # (offset_in_bank, token_count, path)
+    dimensions: int | None = None
+    for wiki_dir in sorted(model_root.iterdir()):
+        if not wiki_dir.is_dir():
+            continue
+        for path in sorted(wiki_dir.glob(f"*.{suffix}.sections.f16bin")):
+            stem = path.name[: -len(f".{suffix}.sections.f16bin")]
+            tokens, dim = _read_header(path)
+            if dimensions is None:
+                dimensions = dim
+            elif dim != dimensions:
+                raise ValueError(f"{path}: dim {dim} != expected {dimensions}")
+            offsets_path = wiki_dir / f"{stem}.{suffix}.sections.offsets.ibin"
+            if not offsets_path.is_file():
+                raise FileNotFoundError(f"missing offsets file: {offsets_path}")
+            offsets_blob = resolve_lfs_pointer(offsets_path)
+            with open(offsets_blob, "rb") as file:
+                rows, _cols = struct.unpack("<II", file.read(8))
+                local_offsets = np.frombuffer(
+                    file.read(), dtype=np.int32, count=rows
+                ).copy()
+            n_sections = rows - 1
+            shifted = (local_offsets + cumulative_tokens).astype(np.int32)
+            # `local_offsets` already starts at 0; we drop the first element of
+            # subsequent chunks since `cumulative_tokens` provides the seam.
+            section_offsets_chunks.append(shifted[1:])
+            shards.append(
+                CollectionShard(
+                    wikiname=wiki_dir.name,
+                    stem=stem,
+                    path=path,
+                    row_offset=cumulative_sections,
+                    row_count=n_sections,
+                )
+            )
+            token_chunks.append((cumulative_tokens, tokens, path))
+            cumulative_sections += n_sections
+            cumulative_tokens += tokens
+    if dimensions is None:
+        raise FileNotFoundError(f"no `.{suffix}.sections.f16bin` files under {model_root}")
+
+    token_bank = np.empty((cumulative_tokens, dimensions), dtype=np.float16)
+    for token_offset, token_count, path in token_chunks:
+        blob = resolve_lfs_pointer(path)
+        with open(blob, "rb") as file:
+            file.seek(8)
+            destination = token_bank[token_offset : token_offset + token_count]
+            file.readinto(memoryview(destination))  # type: ignore[arg-type]
+    bad = ~np.isfinite(token_bank).all(axis=1)
+    if bad.any():
+        token_bank[bad] = 0
+    section_offsets = np.concatenate(section_offsets_chunks).astype(np.int32)
+    return token_bank, section_offsets, shards, dimensions
+
+
+class DenseRetriever:
+    """Brute-force exact cosine top-k for a dense embedding collection.
+
+    Loads the entire `(N, dim)` FP16 corpus to one GPU at construction. Each
+    `search()` call runs a single matmul + top-k against that resident corpus.
+
+    For 60M × 1024 FP16 (~120 GB) the corpus does NOT fit on a single 80 GB
+    H100 — quantize on-disk before instantiating, or use the multi-GPU
+    `gt_stripe_dense` path directly. The single-resident-corpus class is
+    designed for moderate-size collections (≤ tens of GB).
+    """
+
+    def __init__(
+        self,
+        model_root: str | Path,
+        suffix: str = "body",
+        device_id: int = 0,
+    ):
+        import os
+
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(device_id)
+        import cupy
+
+        model_root = Path(model_root)
+        self.model_root = model_root
+        self.suffix = suffix
+        self.shards = discover_collection(model_root, suffix)
+        embeddings_host, self.dimensions = _load_dense_corpus_to_host(
+            model_root, suffix, self.shards
+        )
+        self.total_vectors = embeddings_host.shape[0]
+        # Resident on GPU — caller pays the upfront cost; subsequent searches
+        # are bandwidth-bound on the matmul alone.
+        self.corpus_device = cupy.asarray(embeddings_host)
+
+    def search(
+        self, query_vectors: np.ndarray, k: int = 10
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """`query_vectors`: `(Q, dim)` FP16, already L2-normalized.
+        Returns `(scores, indices)` — both `(Q, k)` numpy arrays.
+        """
+        import cupy
+        import torch  # noqa: F401
+
+        if query_vectors.ndim != 2 or query_vectors.shape[1] != self.dimensions:
+            raise ValueError(
+                f"queries shape {query_vectors.shape} != (?, {self.dimensions})"
+            )
+        queries_dev = cupy.asarray(query_vectors.astype(np.float16, copy=False))
+        sim = cupy.matmul(queries_dev, self.corpus_device.T, dtype=cupy.float32)
+        sim_torch = torch.from_dlpack(sim)
+        values, local = torch.topk(sim_torch, k=k, dim=1, largest=True, sorted=True)
+        return cupy.asnumpy(cupy.from_dlpack(values)), cupy.asnumpy(
+            cupy.from_dlpack(local).astype(cupy.int32)
+        )
+
+
+class MaxSimRetriever:
+    """Brute-force exact MaxSim top-k for a multi-vector section corpus.
+
+    Loads the full token bank + section offsets to one GPU at construction.
+    `search()` accepts a query in the same `(token_bank, offsets)` shape and
+    runs matmul + segment-max + segment-sum + top-k against the resident
+    corpus.
+
+    For 60 M sections × 128 dim with average 3.4 tokens/section the resident
+    bank is ~52 GB FP16 — fits on H100 with margin only after FP8/int8
+    quantization, or on B200 / multi-GPU for raw FP16.
+    """
+
+    def __init__(
+        self,
+        model_root: str | Path,
+        suffix: str = "body",
+        device_id: int = 0,
+    ):
+        import os
+
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(device_id)
+        import cupy
+
+        model_root = Path(model_root)
+        self.model_root = model_root
+        self.suffix = suffix
+        (
+            token_bank_host,
+            section_offsets_host,
+            self.shards,
+            self.dimensions,
+        ) = _load_maxsim_corpus_to_host(model_root, suffix)
+        self.total_sections = section_offsets_host.shape[0] - 1
+        self.total_tokens = token_bank_host.shape[0]
+        self.token_bank_device = cupy.asarray(token_bank_host)
+        self.section_offsets_device = cupy.asarray(section_offsets_host)
+
+    def search(
+        self,
+        query_token_bank: np.ndarray,
+        query_section_offsets: np.ndarray,
+        k: int = 10,
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """`query_token_bank`: `(T_q, dim)` FP16. `query_section_offsets`:
+        `(Q+1,)` int32 cumulative. Returns `(scores, indices)` — `(Q, k)`.
+        """
+        import cupy
+        import torch  # noqa: F401
+
+        if query_token_bank.ndim != 2 or query_token_bank.shape[1] != self.dimensions:
+            raise ValueError(
+                f"queries shape {query_token_bank.shape} != (?, {self.dimensions})"
+            )
+        n_queries = query_section_offsets.shape[0] - 1
+        seg_max_kernel, seg_sum_kernel = _segment_kernels()
+
+        queries_dev = cupy.asarray(query_token_bank.astype(np.float16, copy=False))
+        q_offsets_dev = cupy.asarray(query_section_offsets.astype(np.int32, copy=False))
+
+        sim = cupy.matmul(queries_dev, self.token_bank_device.T, dtype=cupy.float32)
+        per_token_max = cupy.empty(
+            (queries_dev.shape[0], self.total_sections), dtype=cupy.float32
+        )
+        block = (16, 16, 1)
+        grid_max = (
+            (self.total_sections + block[0] - 1) // block[0],
+            (queries_dev.shape[0] + block[1] - 1) // block[1],
+            1,
+        )
+        seg_max_kernel(
+            grid_max,
+            block,
+            (
+                sim,
+                self.section_offsets_device,
+                per_token_max,
+                np.int32(queries_dev.shape[0]),
+                np.int32(self.total_sections),
+                np.int32(sim.shape[1]),
+                np.int32(per_token_max.shape[1]),
+            ),
+        )
+
+        scores = cupy.empty((n_queries, self.total_sections), dtype=cupy.float32)
+        grid_sum = (
+            (self.total_sections + block[0] - 1) // block[0],
+            (n_queries + block[1] - 1) // block[1],
+            1,
+        )
+        seg_sum_kernel(
+            grid_sum,
+            block,
+            (
+                per_token_max,
+                q_offsets_dev,
+                scores,
+                np.int32(n_queries),
+                np.int32(self.total_sections),
+                np.int32(per_token_max.shape[1]),
+                np.int32(scores.shape[1]),
+            ),
+        )
+
+        scores_torch = torch.from_dlpack(scores)
+        values, local = torch.topk(scores_torch, k=k, dim=1, largest=True, sorted=True)
+        return cupy.asnumpy(cupy.from_dlpack(values)), cupy.asnumpy(
+            cupy.from_dlpack(local).astype(cupy.int32)
+        )

tests/test_ground_truth.py

@@ -22,7 +22,7 @@ import numpy as np
 REPO_ROOT = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(REPO_ROOT))
 
-from wikiverse import read_bin, write_bin  # noqa: E402
+from usearchwiki import read_bin, write_bin  # noqa: E402
 
 
 def normalize_rows(matrix: np.ndarray) -> np.ndarray: