Improve: Rename to USearchWiki + new pipelines + pyproject

Rename WikiVerse -> USearchWiki throughout (GitHub + HuggingFace at
unum-cloud/USearchWiki, Nebius bucket at s3://usearch-wiki). The
Python module wikiverse.py is kept under its old name so consumer
imports keep working.

Adds three new pipelines:
- embed_sections.py: section-pooled ColBERT via pylate, with
late-chunking margins so attention flows across section boundaries
- build_index.py: USearch HNSW build from per-shard f16bin via
memmap, f16 quantization matching the storage dtype
- eval_recall.py: self-recall@k against the precomputed ground
truth, with an ef_search sweep

Plus:
- late_chunking.py with section-aware windowing primitives (greedy
pack into core <= context_limit - 2*margin, fragments for
oversized sections, weighted-mean recombination)
- wikiverse.py grows resolve_lfs_pointer / discover_collection /
CollectionShard, dedup'ing logic that used to live in ground_truth
- embed.py renamed to embed_articles.py (parallel to embed_sections)
- pyproject.toml with ruff (E F I B UP C4) / mypy / pytest config
and dependency extras (dense, ground, colbert, index, dev)
- tests/test_late_chunking.py covers the windowing invariants
without needing a real model

.gitignore

@@ -211,3 +211,7 @@ data/
 state/
 benchmarks/results/
 logs/
+
+# Local-only orchestration shell scripts (kept under /home/ubuntu/wikiverse-data/scripts/
+# in this workstation, not part of the published repo).
+*.sh

README.md

@@ -2,14 +2,14 @@
 license: apache-2.0
 ---
 
-# WikiVerse
+# USearchWiki
 
 Multi-model embedding dataset built on [HuggingFace FineWiki](https://huggingface.co/datasets/HuggingFaceFW/finewiki), designed for approximate nearest neighbor (ANN) search benchmarking with [USearch](https://github.com/unum-cloud/usearch) and other vector search engines.
 
-The same Wikipedia corpus — chunked, cleaned, and enriched with graph metadata — is embedded by multiple models spanning dense encoders, decoder-based LLMs, and late-interaction (ColBERT-style) architectures.
+The same Wikipedia corpus — chunked, cleaned, and enriched with graph metadata — is embedded by multiple models spanning dense BERT-like encoders, GPT-style decoder-based LLMs, and late-interaction ColBERT-style architectures.
 Each model's embeddings ship with precomputed ground-truth k-nearest neighbors, enabling reproducible recall and throughput benchmarks without re-running expensive exact search.
 
-## Why WikiVerse?
+## Why USearchWiki?
 
 Existing ANN benchmarks suffer from three gaps:
 
@@ -21,7 +21,7 @@ Existing ANN benchmarks suffer from three gaps:
 3. __No decoder embeddings.__
    State-of-the-art embedding models (GTE-Qwen, Llama-Embed-Nemotron, Qwen3-Embedding) are decoder-based LLMs, yet no ANN benchmark uses their outputs.
 
-WikiVerse fixes all three: one corpus, multiple models, modern architectures, with graph-structured metadata for filtered search.
+USearchWiki fixes all three: one corpus, multiple models, modern architectures, with graph-structured metadata for filtered search.
 
 ## Source Corpus
 
@@ -53,6 +53,41 @@ Long-context models are prioritized and receive the whole document in the origin
 Parquet weight includes both `text` and `wikitext` columns; pure text is roughly half.
 Average bytes/article drops at wider scope because smaller wikis are dominated by stubs.
 
+### Corpus Structure
+
+Measured by scanning every parquet shard (rendered Markdown `text` + raw `wikitext` columns):
+
+| Quantity                            |        Total | Per article |
+| :---------------------------------- | -----------: | ----------: |
+| Articles                            |       61.55M |           — |
+| Rendered text bytes (`text` column) |     195.2 GB |     3.2 KB  |
+| Wikitext bytes (`wikitext` column)  |     337.1 GB |     5.5 KB  |
+| Markdown paragraphs (blank-line-separated blocks) | 254.2M | 4.13 |
+| Section headings (`#`/`##`/`###`)   |       206.3M |        3.35 |
+
+35% of articles have a single paragraph (stubs), 65% have ≤ 3, only 10% have 8+.
+Paragraph length distribution: 12% < 50 bytes (mostly headings or one-liners), 38% in 200–800 bytes (the prose sweet spot), 4% > 3.2 KB (long lists or tables rendered as one block).
+
+Annotation density extracted from raw `wikitext` (counts across the full corpus):
+
+| Annotation kind | Total | Articles touched |
+| :-------------- | ----: | ---------------: |
+| Plain `[[wikilinks]]` | 1.42 B | 99.4% |
+| Templates `{{...}}`   | 0.998 B | 98.6% |
+| Piped links `[[T\|d]]` | 0.648 B | 89.3% |
+| Citations `<ref>...`  | 0.400 B | 71.0% |
+| External URLs `[https://...]` | 84M | 41.8% |
+| Categories `[[Category:...]]` | 55M | 16.3% |
+| Tables `{| ... |}`             | 19M | 14.6% |
+| Files / images `[[File:...]]`  | 14M |  7.2% |
+| **Section anchors `[[Article#Section]]`** | **11.5M** | **6.4%** |
+| Math `<math>...`                | 6.4M | 0.5% |
+| Self anchors `[[#Section]]`     | 2.6M | 0.7% |
+| Galleries `<gallery>`           | 2.5M | 3.2% |
+| Inline interwiki `[[lang:...]]` | 0.83M | 1.1% |
+
+Section anchors deserve attention: they form a 11.5M-edge **paragraph-level link graph** already curated by editors — a built-in supervision signal for sub-article retrieval evaluation.
+
 ## Embedding Models
 
 Each model embeds the same article corpus independently.
@@ -80,16 +115,21 @@ FP8 quantization can improve throughput ~1.5× with negligible quality loss.
 Token counts vary by tokenizer — CJK text produces ~1 token per 2-3 bytes, Latin/Cyrillic ~1 per 4-5 bytes.
 Average article length across all languages is ~400 tokens, but this is dragged down by millions of stubs in smaller wikis; English articles average ~2,700 tokens.
 
-| Model                  | Throughput | Total tokens |   Time | Vectors | Storage | Notes                          |
-| :--------------------- | ---------: | -----------: | -----: | ------: | ------: | :----------------------------- |
-| Qwen3-Embedding-0.6B   |  500 doc/s |         24 B |  1.4 d |  61.6 M |  126 GB | Full articles                  |
-| GTE-ModernColBERT-v1   |  800 doc/s |         24 B |  0.9 d |  24.3 B |  6.2 TB | ~400 token vectors per article |
-| arctic-embed-l-v2.0    |  800 doc/s |         28 B |  0.9 d |  61.6 M |  126 GB | Truncated at 8K tokens         |
-| nomic-embed-text-v1.5  | 1200 doc/s |         21 B |  0.6 d |  61.6 M |   95 GB | Truncated at 8K tokens         |
-| e5-mistral-7b-instruct |   50 doc/s |         21 B | 14.3 d |  61.6 M |  505 GB | Truncated at 4K tokens         |
+| Model                                  | Throughput | Total tokens |   Time |  Vectors | Storage | Notes                                              |
+| :------------------------------------- | ---------: | -----------: | -----: | -------: | ------: | :------------------------------------------------- |
+| Qwen3-Embedding-0.6B                   |  500 doc/s |         24 B |  1.4 d |   61.6 M |  126 GB | Full articles, one vector per article              |
+| GTE-ModernColBERT-v1 (token-level)     |  800 doc/s |         24 B |  0.9 d |   24.3 B |  6.2 TB | ~400 token vectors per article                     |
+| GTE-ModernColBERT-v1 (section-pooled)  |  800 doc/s |         24 B |  0.9 d |  206.3 M |   53 GB | Mean-pool tokens within each section, ~3.4 per art |
+| GTE-ModernColBERT-v1 (paragraph-pooled)|  800 doc/s |         24 B |  0.9 d |  254.2 M |   65 GB | Mean-pool tokens within each paragraph             |
+| arctic-embed-l-v2.0                    |  800 doc/s |         28 B |  0.9 d |   61.6 M |  126 GB | Truncated at 8K tokens                             |
+| nomic-embed-text-v1.5                  | 1200 doc/s |         21 B |  0.6 d |   61.6 M |   95 GB | Truncated at 8K tokens                             |
+| e5-mistral-7b-instruct                 |   50 doc/s |         21 B | 14.3 d |   61.6 M |  505 GB | Truncated at 4K tokens                             |
 
 > Single H100 80 GB, full dataset — 61.6M articles, all 325 languages.
 
+The two ColBERT-pooled rows trade fine-grained MaxSim resolution (lost) for an indexable single-machine footprint (gained).
+Section-pooled fits in 53 GB at FP16 — small enough for a single 80 GB GPU and trivially served by [USearch](https://github.com/unum-cloud/usearch); paragraph-pooled gives ~25% more granularity for the same throughput cost since the bottleneck is total tokens encoded.
+
 ## Metadata Enrichment
 
 ### Compute Estimates
@@ -105,12 +145,17 @@ Binary format: `u32` rows count, `u32` columns count, then `rows × cols` little
 `.body.f16bin` is the article-body embedding; `.title.f16bin` is the title-only embedding (short-context, useful for title-vs-body retrieval studies).
 
 ```
-unum-cloud/WikiVerse/
+unum-cloud/USearchWiki/
 ├── README.md
 ├── LICENSE
 ├── .gitattributes
-├── wikiverse.py                              # consumer module: load_lang, read_bin, ...
-├── embed.py                                  # reference embedding pipeline (TEI-based)
+├── wikiverse.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
+├── ground_truth.py                           # exact global k-NN via tiled CuPy GEMMs
+├── build_index.py                            # build a USearch HNSW index from per-shard f16bin
+├── eval_recall.py                            # measure recall@k of an index against the ground truth
 │
 ├── qwen3-embedding-0.6b/                     # 1024-dim, decoder, float16
 │   ├── enwiki/
@@ -138,13 +183,15 @@ unum-cloud/WikiVerse/
 
 ## Downloading
 
-WikiVerse lives on three coordinated mirrors, all sharing the same single-branch Git history:
+USearchWiki uses an unusual distribution policy.
+Single repository, no separation of code and data.
+USearchWiki lives on three coordinated mirrors, all sharing the same single-branch Git history:
 
-| Mirror              | Holds                          | Best for                         |
-| :------------------ | :----------------------------- | :------------------------------- |
-| HuggingFace Hub     | code + LFS bytes (canonical)   | `git clone`, `hf` CLI, streaming |
-| GitHub              | code + LFS pointers (no bytes) | reading the code, contributing   |
-| Nebius S3           | flat byte mirror of LFS blobs  | bulk downloads, batch jobs       |
+| Mirror          | Holds                          | Best for                         |
+| :-------------- | :----------------------------- | :------------------------------- |
+| HuggingFace Hub | code + LFS bytes (canonical)   | `git clone`, `hf` CLI, streaming |
+| GitHub          | code + LFS pointers (no bytes) | reading the code, contributing   |
+| Nebius S3       | flat byte mirror of LFS blobs  | bulk downloads, batch jobs       |
 
 `.f16bin` files are tracked via [Git LFS](https://git-lfs.com); on GitHub, the LFS server is rerouted to HuggingFace, so GitHub clones receive only ~200-byte pointer files.
 
@@ -153,13 +200,13 @@ WikiVerse lives on three coordinated mirrors, all sharing the same single-branch
 The default and the simplest path — full code, full data, single command:
 
 ```sh
-git clone https://huggingface.co/datasets/ashvardanian/WikiVerse
+git clone https://huggingface.co/datasets/unum-cloud/USearchWiki
 ```
 
 To skip the ~600 GB of binaries and get only code + pointers:
 
 ```sh
-GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/datasets/ashvardanian/WikiVerse
+GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/datasets/unum-cloud/USearchWiki
 ```
 
 ### From GitHub
@@ -167,9 +214,9 @@ GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/datasets/ashvardanian/Wik
 The GitHub repo holds only code and LFS pointers; the actual binaries live on HuggingFace. After cloning, point Git LFS at HuggingFace and pull:
 
 ```sh
-git clone https://github.com/ashvardanian/WikiVerse
-cd WikiVerse
-git config lfs.url https://huggingface.co/datasets/ashvardanian/WikiVerse.git/info/lfs
+git clone https://github.com/unum-cloud/USearchWiki
+cd USearchWiki
+git config lfs.url https://huggingface.co/datasets/unum-cloud/USearchWiki.git/info/lfs
 git lfs pull
 ```
 
@@ -178,7 +225,7 @@ git lfs pull
 The fastest path for bulk downloads — pulls byte-identical LFS objects directly from object storage, then materializes the `.f16bin` files into the working tree:
 
 ```sh
-aws s3 sync s3://wikiverse/lfs/ ./.git/lfs/objects/ \
+aws s3 sync s3://usearch-wiki/lfs/ ./.git/lfs/objects/ \
     --endpoint-url https://storage.us-central1.nebius.cloud
 git lfs checkout
 ```
@@ -194,7 +241,7 @@ matrix = read_bin("qwen3-embedding-0.6b/enwiki/000_00000.body.f16bin", dtype="f1
 Or pull just one model's embeddings for a single language:
 
 ```sh
-hf download ashvardanian/WikiVerse \
+hf download unum-cloud/USearchWiki \
     --repo-type dataset \
     --include "qwen3-embedding-0.6b/enwiki/*"
 ```
@@ -208,11 +255,12 @@ The embedding pipeline is designed for multi-day runs on GPU servers with checkp
 python corpus.py --lang en --output corpus/
 
 # 2. Embed with each model (resume-safe — rerun after interruptions)
-python embed.py --model qwen3-0.6b --input corpus/ --output embeddings/ --resume
-python embed.py --model e5-mistral-7b --input corpus/ --output embeddings/ --resume
-python embed.py --model arctic-embed-l-v2 --input corpus/ --output embeddings/ --resume
-python embed.py --model nomic-v1.5 --input corpus/ --output embeddings/ --resume
-python embed.py --model gte-moderncolbert --input corpus/ --output embeddings/ --resume
+python embed_articles.py --model qwen3-0.6b --input corpus/ --output embeddings/ --resume
+python embed_articles.py --model e5-mistral-7b --input corpus/ --output embeddings/ --resume
+python embed_articles.py --model arctic-embed-l-v2 --input corpus/ --output embeddings/ --resume
+python embed_articles.py --model nomic-v1.5 --input corpus/ --output embeddings/ --resume
+# Section-pooled ColBERT uses a different pipeline (late chunking)
+python embed_sections.py --model gte-moderncolbert --input corpus/ --output embeddings/ --resume
 
 # 3. Extract graph metadata
 python graph.py --lang en --output graph/
@@ -222,7 +270,7 @@ python ground_truth.py --embeddings embeddings/qwen3-0.6b/ --k 100 --queries 100
 python ground_truth.py --embeddings embeddings/e5-mistral-7b/ --k 100 --queries 10000
 
 # 5. Upload to HuggingFace
-python upload.py --repo unum-cloud/WikiVerse
+python upload.py --repo unum-cloud/USearchWiki
 ```
 
 Each step is idempotent.
@@ -233,7 +281,7 @@ Adding a new embedding model requires only step 2 + step 4 — the corpus and gr
 
 | Location                                                                           | Storage/mo (1 TB) | Egress/GB | Notes                                                            |
 | ---------------------------------------------------------------------------------- | ----------------- | --------- | ---------------------------------------------------------------- |
-| [HuggingFace Hub](https://huggingface.co/unum-cloud/WikiVerse)                     | Free              | Free      | Primary. Xet storage, unlimited public downloads                 |
+| [HuggingFace Hub](https://huggingface.co/unum-cloud/USearchWiki)                     | Free              | Free      | Primary. Xet storage, unlimited public downloads                 |
 | [AWS S3](https://aws.amazon.com/s3/pricing/) Standard                              | $23.00            | $0.09     | S3-compatible mirror. Egress adds up fast for popular datasets   |
 | [Nebius Object Storage](https://docs.nebius.com/object-storage/resources/pricing/) | $15.05            | $0.015    | S3-compatible. ~35% cheaper storage, ~6× cheaper egress than AWS |
 

build_index.py

@@ -0,0 +1,230 @@
+"""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.
+
+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 os
+import struct
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+REPO_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(REPO_ROOT))
+
+from wikiverse import (  # noqa: E402
+    CollectionShard,
+    discover_collection,
+    resolve_lfs_pointer,
+)
+
+
+def memmap_shard(shard: CollectionShard, dimensions: int) -> 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()`.
+    """
+    blob = resolve_lfs_pointer(shard.path)
+    return np.memmap(
+        blob,
+        dtype=np.float16,
+        mode="r",
+        offset=8,
+        shape=(shard.row_count, dimensions),
+    )
+
+
+def add_shards(
+    index,
+    shards: list[CollectionShard],
+    dimensions: 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`).
+    """
+    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)
+        keys = np.arange(
+            shard.row_offset, shard.row_offset + shard.row_count, dtype=np.uint64
+        )
+        index.add(keys=keys, vectors=vectors, threads=threads)
+        cumulative_rows += shard.row_count
+        bytes_added_since_log += vectors.nbytes
+        if (shard_index + 1) % log_every == 0 or shard_index == len(shards) - 1:
+            now = time.monotonic()
+            elapsed = now - started
+            interval = now - last_log_at
+            rate = cumulative_rows / max(elapsed, 1e-3)
+            interval_mb = bytes_added_since_log / 1e6 / max(interval, 1e-3)
+            print(
+                f"  shard {shard_index + 1}/{len(shards)} "
+                f"({shard.wikiname}/{shard.stem}): "
+                f"{cumulative_rows:,} vectors total, "
+                f"{rate:,.0f} vec/s avg, {interval_mb:,.0f} MB/s recent",
+                flush=True,
+            )
+            last_log_at = now
+            bytes_added_since_log = 0
+    return cumulative_rows
+
+
+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(
+        "--model-subdir",
+        required=True,
+        help="e.g. qwen3-embedding-0.6b, nomic-embed-text-v1.5, snowflake-arctic-embed-l-v2.0",
+    )
+    parser.add_argument(
+        "--output-suffix",
+        default="body",
+        choices=["body", "title"],
+        help="which embedding file flavor to index",
+    )
+    parser.add_argument(
+        "--output-index",
+        type=Path,
+        default=None,
+        help="destination .usearch file (defaults to {output}/{model-subdir}/{suffix}.usearch)",
+    )
+    parser.add_argument(
+        "--threads",
+        type=int,
+        default=os.cpu_count() or 1,
+        help="parallel insertion threads (default: all logical cores)",
+    )
+    parser.add_argument(
+        "--connectivity",
+        type=int,
+        default=16,
+        help="HNSW M, neighbors per node (16 is the typical floor for ANN)",
+    )
+    parser.add_argument(
+        "--expansion-add",
+        type=int,
+        default=256,
+        help="HNSW efConstruction; bumped from the default 128 to chase >=99% recall@10",
+    )
+    parser.add_argument(
+        "--metric",
+        default="cos",
+        choices=["cos", "ip", "l2sq"],
+        help="similarity metric; cos is right for L2-normalized embeddings",
+    )
+    parser.add_argument(
+        "--dtype",
+        default="f16",
+        help="index quantization dtype; f16 matches the on-disk format",
+    )
+    parser.add_argument(
+        "--log-every",
+        type=int,
+        default=10,
+        help="print a progress line every N shards",
+    )
+    args = parser.parse_args()
+
+    from usearch.index import Index  # local import: heavy dependency
+
+    model_root = Path(args.output) / args.model_subdir
+    print(f"discovering shards under {model_root} ...", flush=True)
+    started = time.monotonic()
+    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))
+    total_vectors = sum(s.row_count for s in shards)
+    elapsed = time.monotonic() - started
+    print(
+        f"  {len(shards)} shards across "
+        f"{len({s.wikiname for s in shards})} wikis, "
+        f"{total_vectors:,} vectors x {dimensions}d in {elapsed:.1f}s",
+        flush=True,
+    )
+
+    output_index_path = (
+        args.output_index
+        if args.output_index is not None
+        else model_root / f"{args.output_suffix}.usearch"
+    )
+
+    print(
+        f"opening USearch index "
+        f"(dim={dimensions}, metric={args.metric}, dtype={args.dtype}, "
+        f"M={args.connectivity}, ef_add={args.expansion_add}, "
+        f"multi=False, threads={args.threads})",
+        flush=True,
+    )
+    index = Index(
+        ndim=dimensions,
+        metric=args.metric,
+        dtype=args.dtype,
+        connectivity=args.connectivity,
+        expansion_add=args.expansion_add,
+        multi=False,
+    )
+
+    print("streaming shards into index ...", flush=True)
+    started = time.monotonic()
+    added = add_shards(
+        index=index,
+        shards=shards,
+        dimensions=dimensions,
+        threads=args.threads,
+        log_every=args.log_every,
+    )
+    elapsed_build = time.monotonic() - started
+    rate = added / max(elapsed_build, 1e-3)
+    print(
+        f"added {added:,} vectors in {elapsed_build:.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 __name__ == "__main__":
+    main()

embed.py → embed_articles.py

@@ -1,7 +1,11 @@
-"""Embed FineWiki shards via a running TEI server.
+"""Embed FineWiki shards via a running TEI server (one dense vector per article).
+
+The companion to `embed_sections.py`, which produces one vector per section
+via late-chunking ColBERT. This module is the simpler dense path: each
+article goes to TEI as a truncated document, gets back a single pooled vector.
 
 Usage:
-  python embed.py --cache-dir /path/to/hf-cache --output /path/to/embeddings \\
+  python embed_articles.py --cache-dir /path/to/hf-cache --output /path/to/embeddings \\
       --wiki enwiki --model-subdir qwen3-embedding-0.6b --dimensions 1024
 
 For title embeddings, add: --text-column title --output-suffix title --char-cap 256
@@ -103,7 +107,7 @@ async def run(args: argparse.Namespace) -> None:
             )
             response.raise_for_status()
         except Exception as error:
-            raise SystemExit(f"TEI not reachable at {args.url}: {error}")
+            raise SystemExit(f"TEI not reachable at {args.url}: {error}") from error
 
     async with httpx.AsyncClient() as client:
         for shard in pending:

embed_sections.py

@@ -0,0 +1,480 @@
+"""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
+     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).
+
+One process per GPU; partition shards by `shard_index % world_size == gpu_id`.
+
+Usage:
+  CUDA_VISIBLE_DEVICES=0 python embed_sections.py \\
+      --cache-dir /home/ubuntu/wikiverse-data/hf-cache \\
+      --output /home/ubuntu/WikiVerse \\
+      --model-subdir gte-moderncolbert-v1 \\
+      --wiki enwiki --gpu-id 0 --world-size 8
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import struct
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+import torch
+import torch.nn.functional as F
+
+REPO_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(REPO_ROOT))
+
+from late_chunking import (  # noqa: E402
+    SectionCharSpan,
+    Window,
+    find_section_char_spans,
+    plan_windows,
+    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]
+
+
+def load_pylate_model(model_id: str, device: str, document_length: int):
+    from pylate import models  # local import (heavy)
+
+    print(f"[gpu] loading {model_id} on {device} ...", flush=True)
+    started = time.monotonic()
+    model = models.ColBERT(
+        model_name_or_path=model_id,
+        device=device,
+        document_length=document_length,
+    )
+    # Pylate defaults to fp32; switching to fp16 is ~3x faster with no
+    # measurable quality loss for this model. Cast both submodules.
+    model[0].auto_model = model[0].auto_model.half()
+    model[1].linear = model[1].linear.half()
+    model.eval()
+    print(
+        f"[gpu] loaded in {time.monotonic() - started:.1f}s "
+        f"(fp16: transformer={next(model[0].auto_model.parameters()).dtype}, "
+        f"dense={next(model[1].linear.parameters()).dtype})",
+        flush=True,
+    )
+    return model
+
+
+def plan_articles_batched(
+    texts: list[str],
+    tokenizer,
+    document_prefix: str,
+    context_limit: int,
+    margin: int,
+) -> tuple[list[list[Window]], list[int]]:
+    """Tokenize all articles in one tokenizer call (fast Rust path), then plan
+    windows per article. Returns (per_article_windows, per_article_n_sections).
+    """
+    n = len(texts)
+    per_article_char_spans: list[list[SectionCharSpan]] = []
+    prefixed_texts: list[str] = []
+    nonempty_indices: list[int] = []
+    for index, text in enumerate(texts):
+        if not text:
+            per_article_char_spans.append([])
+            continue
+        char_spans = find_section_char_spans(text)
+        if not char_spans:
+            per_article_char_spans.append([])
+            continue
+        per_article_char_spans.append(char_spans)
+        prefixed_texts.append(document_prefix + text)
+        nonempty_indices.append(index)
+
+    per_article_windows: list[list[Window]] = [[] for _ in range(n)]
+    per_article_n_sections: list[int] = [0] * n
+
+    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,
+        return_offsets_mapping=True,
+        truncation=False,
+    )
+
+    prefix_len = len(document_prefix)
+    for batch_index, article_index in enumerate(nonempty_indices):
+        token_ids = encodings["input_ids"][batch_index]
+        offsets = encodings["offset_mapping"][batch_index]
+        char_spans = per_article_char_spans[article_index]
+        shifted = [
+            SectionCharSpan(
+                char_start=s.char_start + prefix_len,
+                char_end=s.char_end + prefix_len,
+                heading_level=s.heading_level,
+                heading_text=s.heading_text,
+            )
+            for s in char_spans
+        ]
+        section_spans = section_token_spans_from_offsets(shifted, list(offsets))
+        if not section_spans:
+            continue
+        windows = plan_windows(token_ids, section_spans, context_limit, margin)
+        per_article_windows[article_index] = windows
+        per_article_n_sections[article_index] = len(section_spans)
+
+    return per_article_windows, per_article_n_sections
+
+
+def encode_articles_batch(
+    texts: list[str],
+    model,
+    cls_id: int,
+    sep_id: int,
+    pad_id: int,
+    device: str,
+    context_limit: int,
+    margin: int,
+    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).
+    """
+    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,
+        document_prefix=document_prefix,
+        context_limit=context_limit,
+        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]] = []
+        sub_batch_max_len = 0
+
+        def flush(sub: list[tuple[int, int, Window]]) -> None:
+            if not sub:
+                return
+            wrapped_max = max(triple[2].length for triple in sub) + 2
+            input_ids = torch.full(
+                (len(sub), wrapped_max), pad_id, dtype=torch.long, device=device
+            )
+            attention_mask = torch.zeros(
+                (len(sub), wrapped_max), dtype=torch.long, device=device
+            )
+            for row, (_, _, window) in enumerate(sub):
+                wrapped = [cls_id] + window.token_ids + [sep_id]
+                input_ids[row, : len(wrapped)] = torch.tensor(
+                    wrapped, dtype=torch.long, device=device
+                )
+                attention_mask[row, : len(wrapped)] = 1
+            with torch.inference_mode():
+                hidden = (
+                    model[0]
+                    .auto_model(input_ids=input_ids, attention_mask=attention_mask)
+                    .last_hidden_state
+                )
+                projected = model[1].linear(hidden)
+                normalized = F.normalize(projected, p=2, dim=-1)
+            for row, (article_index, window_index, window) in enumerate(sub):
+                out = (
+                    normalized[row, 1 : 1 + window.length, :]
+                    .to(torch.float32)
+                    .cpu()
+                    .numpy()
+                )
+                output_token_arrays[(article_index, window_index)] = out
+
+        for triple in all_windows:
+            window = triple[2]
+            wrapped_len = window.length + 2
+            new_max_len = max(sub_batch_max_len, wrapped_len)
+            projected_padded_tokens = (len(sub_batch) + 1) * new_max_len
+            if sub_batch and projected_padded_tokens > max_batch_tokens:
+                flush(sub_batch)
+                sub_batch = []
+                sub_batch_max_len = 0
+            sub_batch.append(triple)
+            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)
+    ):
+        if n_sections == 0:
+            section_matrices.append(np.zeros((0, embedding_dim), dtype=np.float16))
+            continue
+        token_outputs = [
+            output_token_arrays[(article_index, window_index)]
+            for window_index in range(len(windows))
+        ]
+        section_matrix = pool_section_vectors(
+            windows=windows,
+            window_token_outputs=token_outputs,
+            n_sections=n_sections,
+            embedding_dim=embedding_dim,
+        )
+        norms = np.linalg.norm(section_matrix, axis=1, keepdims=True)
+        nonzero = norms[:, 0] > 0
+        section_matrix[nonzero] = section_matrix[nonzero] / norms[nonzero]
+        section_matrices.append(section_matrix.astype(np.float16))
+    return section_matrices
+
+
+def write_shard_outputs(
+    shard_dir: Path,
+    stem: str,
+    suffix: str,
+    section_matrices: list[np.ndarray],
+    embedding_dim: int,
+) -> None:
+    shard_dir.mkdir(parents=True, exist_ok=True)
+    section_counts = [m.shape[0] for m in section_matrices]
+    total_sections = sum(section_counts)
+    cumulative_offsets = np.zeros(len(section_matrices) + 1, dtype=np.int32)
+    cumulative_offsets[1:] = np.cumsum(section_counts, dtype=np.int32)
+
+    sections_path = shard_dir / f"{stem}.{suffix}.sections.f16bin"
+    offsets_path = shard_dir / f"{stem}.{suffix}.sections.offsets.ibin"
+
+    with open(sections_path.with_suffix(sections_path.suffix + ".tmp"), "wb") as file:
+        file.write(struct.pack("<II", total_sections, embedding_dim))
+        if total_sections > 0:
+            concatenated = (
+                np.vstack(section_matrices)
+                if section_matrices
+                else np.zeros((0, embedding_dim), dtype=np.float16)
+            )
+            file.write(concatenated.tobytes(order="C"))
+    sections_path.with_suffix(sections_path.suffix + ".tmp").rename(sections_path)
+
+    with open(offsets_path.with_suffix(offsets_path.suffix + ".tmp"), "wb") as file:
+        file.write(struct.pack("<II", len(cumulative_offsets), 1))
+        file.write(cumulative_offsets.tobytes(order="C"))
+    offsets_path.with_suffix(offsets_path.suffix + ".tmp").rename(offsets_path)
+
+
+def process_shard(
+    shard: Shard,
+    output_root: Path,
+    model,
+    cls_id: int,
+    sep_id: int,
+    pad_id: int,
+    device: str,
+    context_limit: int,
+    margin: int,
+    document_prefix: str,
+    suffix: str,
+    text_column: str,
+    id_column: str,
+    article_batch_size: int,
+    max_batch_tokens: int,
+) -> dict:
+    table = pq.read_table(shard.path, columns=[id_column, text_column])
+    ids = table.column(id_column).to_pylist()
+    texts = table.column(text_column).to_pylist()
+
+    section_matrices: list[np.ndarray] = []
+    n_sections_total = 0
+    n_zero = 0
+    started = time.monotonic()
+    progress_every = max(article_batch_size, len(ids) // 20)
+    embedding_dim = model[1].linear.out_features
+
+    for batch_start in range(0, len(ids), article_batch_size):
+        batch_end = min(batch_start + article_batch_size, len(ids))
+        batch_texts = [t or "" for t in texts[batch_start:batch_end]]
+        try:
+            batch_matrices = encode_articles_batch(
+                texts=batch_texts,
+                model=model,
+                cls_id=cls_id,
+                sep_id=sep_id,
+                pad_id=pad_id,
+                device=device,
+                context_limit=context_limit,
+                margin=margin,
+                document_prefix=document_prefix,
+                max_batch_tokens=max_batch_tokens,
+            )
+        except Exception as exc:
+            print(
+                f"  ! batch [{batch_start},{batch_end}) failed: {exc!r}; "
+                f"emitting zero sections for the batch",
+                flush=True,
+            )
+            batch_matrices = [
+                np.zeros((0, embedding_dim), dtype=np.float16) for _ in batch_texts
+            ]
+        for matrix in batch_matrices:
+            section_matrices.append(matrix)
+            n_sections_total += matrix.shape[0]
+            if matrix.shape[0] == 0:
+                n_zero += 1
+        if batch_end % progress_every < article_batch_size or batch_end == len(ids):
+            elapsed = time.monotonic() - started
+            rate = batch_end / max(elapsed, 1e-3)
+            print(
+                f"    {shard.wikiname}/{shard.stem}: {batch_end}/{len(ids)} articles "
+                f"({rate:.1f} doc/s, {n_sections_total:,} sections so far)",
+                flush=True,
+            )
+
+    elapsed = time.monotonic() - started
+    embedding_dim = model[1].linear.out_features
+
+    write_shard_outputs(
+        shard_dir=output_root / shard.wikiname,
+        stem=shard.stem,
+        suffix=suffix,
+        section_matrices=section_matrices,
+        embedding_dim=embedding_dim,
+    )
+
+    return {
+        "n_articles": len(ids),
+        "n_zero_articles": n_zero,
+        "n_sections_total": n_sections_total,
+        "elapsed_seconds": elapsed,
+    }
+
+
+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("--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("--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",
+    )
+    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.
+
+    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()
+    ]
+    print(
+        f"[gpu{args.gpu_id}] {args.wiki}: {len(owned)} owned, {len(pending)} 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
+
+    started_overall = time.monotonic()
+    total_articles = 0
+    total_sections = 0
+    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,
+        )
+
+    wall = time.monotonic() - started_overall
+    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",
+        flush=True,
+    )
+
+
+if __name__ == "__main__":
+    main()

eval_recall.py

@@ -0,0 +1,220 @@
+"""Measure self-recall@k of a USearch index against the precomputed exact
+ground-truth files (`{wiki}/{stem}.body.ground_truth.ibin`).
+
+Samples N article IDs uniformly across the canonical shard walk, queries the
+index with their stored vectors (memory-mapped from the same `.f16bin` files),
+and compares the returned top-k keys against the exact top-k from the ground
+truth. Reports mean recall@k for one or more `ef_search` settings — the
+standard recall-vs-speed sweep.
+
+Usage:
+  python eval_recall.py \\
+      --output /home/ubuntu/WikiVerse \\
+      --model-subdir qwen3-embedding-0.6b \\
+      --output-suffix body \\
+      --index /home/ubuntu/WikiVerse/qwen3-embedding-0.6b/body.usearch \\
+      --num-queries 10000 --k 10 \\
+      --ef-search 64,128,256,512
+"""
+
+from __future__ import annotations
+
+import argparse
+import struct
+import sys
+import time
+from pathlib import Path
+
+import numpy as np
+
+REPO_ROOT = Path(__file__).resolve().parent
+sys.path.insert(0, str(REPO_ROOT))
+
+from wikiverse import (  # noqa: E402
+    CollectionShard,
+    discover_collection,
+    resolve_lfs_pointer,
+)
+
+
+def memmap_shard_vectors(shard: CollectionShard, dimensions: int) -> np.ndarray:
+    blob = resolve_lfs_pointer(shard.path)
+    return np.memmap(
+        blob,
+        dtype=np.float16,
+        mode="r",
+        offset=8,
+        shape=(shard.row_count, dimensions),
+    )
+
+
+def gather_query_vectors(
+    shards: list[CollectionShard],
+    dimensions: int,
+    query_global_ids: np.ndarray,
+) -> np.ndarray:
+    """Return a `(len(query_global_ids), dimensions)` FP16 array of the
+    embeddings for the given global IDs, drawn via memmap from the canonical
+    shard walk.
+    """
+    out = np.empty((len(query_global_ids), dimensions), dtype=np.float16)
+    # Index of each query within the per-shard offsets — binary search.
+    shard_starts = np.array([s.row_offset for s in shards], dtype=np.int64)
+    shard_indices = np.searchsorted(shard_starts, query_global_ids, side="right") - 1
+    sort_order = np.argsort(shard_indices, kind="stable")
+    sorted_query_indices = shard_indices[sort_order]
+    sorted_global_ids = query_global_ids[sort_order]
+
+    cursor = 0
+    while cursor < len(sort_order):
+        shard_index = int(sorted_query_indices[cursor])
+        end = cursor
+        while end < len(sort_order) and sorted_query_indices[end] == shard_index:
+            end += 1
+        shard = shards[shard_index]
+        local_rows = sorted_global_ids[cursor:end] - shard.row_offset
+        memmap = memmap_shard_vectors(shard, dimensions)
+        out[sort_order[cursor:end]] = np.asarray(memmap[local_rows])
+        cursor = end
+    return out
+
+
+def gather_ground_truth(
+    model_root: Path,
+    suffix: str,
+    shards: list[CollectionShard],
+    query_global_ids: np.ndarray,
+    k: int,
+) -> np.ndarray:
+    """Return `(len(query_global_ids), k)` int32 array of exact top-k indices
+    pulled from per-shard `.{suffix}.ground_truth.ibin` files. Assumes the GT
+    was stored with at least `k` neighbors per row."""
+    out = np.empty((len(query_global_ids), k), dtype=np.int32)
+    shard_starts = np.array([s.row_offset for s in shards], dtype=np.int64)
+    shard_indices = np.searchsorted(shard_starts, query_global_ids, side="right") - 1
+    sort_order = np.argsort(shard_indices, kind="stable")
+    sorted_query_indices = shard_indices[sort_order]
+    sorted_global_ids = query_global_ids[sort_order]
+    cursor = 0
+    while cursor < len(sort_order):
+        shard_index = int(sorted_query_indices[cursor])
+        end = cursor
+        while end < len(sort_order) and sorted_query_indices[end] == shard_index:
+            end += 1
+        shard = shards[shard_index]
+        gt_path = (
+            model_root / shard.wikiname / f"{shard.stem}.{suffix}.ground_truth.ibin"
+        )
+        gt_blob = resolve_lfs_pointer(gt_path)
+        with open(gt_blob, "rb") as file:
+            rows, gt_k = struct.unpack("<II", file.read(8))
+        if k > gt_k:
+            raise SystemExit(
+                f"requested k={k} > stored ground-truth k={gt_k} in {gt_path}"
+            )
+        gt_memmap = np.memmap(
+            gt_blob, dtype=np.int32, mode="r", offset=8, shape=(rows, gt_k)
+        )
+        local_rows = sorted_global_ids[cursor:end] - shard.row_offset
+        out[sort_order[cursor:end]] = np.asarray(gt_memmap[local_rows, :k])
+        cursor = end
+    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 main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", default="/home/ubuntu/WikiVerse")
+    parser.add_argument("--model-subdir", required=True)
+    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(
+        "--ef-search",
+        default="64,128,256,512",
+        help="comma-separated efSearch values to sweep",
+    )
+    parser.add_argument(
+        "--threads",
+        type=int,
+        default=64,
+        help="USearch search thread count",
+    )
+    parser.add_argument("--seed", type=int, default=0)
+    args = parser.parse_args()
+
+    from usearch.index import Index
+
+    model_root = Path(args.output) / args.model_subdir
+    index_path = (
+        args.index
+        if args.index is not None
+        else model_root / f"{args.output_suffix}.usearch"
+    )
+    if not index_path.is_file():
+        raise SystemExit(f"index not found at {index_path}")
+
+    print(f"loading index {index_path} ...", flush=True)
+    started = time.monotonic()
+    index = Index.restore(str(index_path))
+    print(
+        f"  loaded {len(index):,} vectors in {time.monotonic()-started:.1f}s",
+        flush=True,
+    )
+
+    print(f"discovering shards under {model_root} ...", flush=True)
+    shards = discover_collection(model_root, args.output_suffix)
+    total_vectors = sum(s.row_count for s in shards)
+    if total_vectors != len(index):
+        print(
+            f"  WARN: index size {len(index):,} != collection size {total_vectors:,}",
+            flush=True,
+        )
+    # Read first shard header for dimensions
+    first_blob = resolve_lfs_pointer(shards[0].path)
+    with open(first_blob, "rb") as file:
+        _, dimensions = struct.unpack("<II", file.read(8))
+    print(f"  {total_vectors:,} vectors x {dimensions}d", flush=True)
+
+    rng = np.random.default_rng(args.seed)
+    query_ids = np.sort(
+        rng.choice(total_vectors, size=args.num_queries, replace=False)
+    ).astype(np.int64)
+    print(f"sampled {args.num_queries:,} query IDs", flush=True)
+
+    print("loading query vectors and exact ground truth ...", flush=True)
+    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
+    )
+    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
+        started = time.monotonic()
+        results = index.search(query_vectors, count=args.k, 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}")
+
+
+if __name__ == "__main__":
+    main()

ground_truth.py

@@ -17,88 +17,16 @@ import multiprocessing as mp
 import os
 import struct
 import time
-from dataclasses import dataclass
 from pathlib import Path
 
 import numpy as np
 
-from wikiverse import write_bin
-
-
-LFS_POINTER_PREFIX = b"version https://git-lfs"
-
-
-def resolve_lfs_pointer(path: Path) -> Path:
-    """If `path` is a Git-LFS pointer file, return the materialized blob in `.git/lfs/objects`.
-
-    Pointer files are tiny ASCII stubs (~133 bytes) with an `oid sha256:<hex>` line.
-    Repositories cloned with `GIT_LFS_SKIP_SMUDGE=1` (or with `git lfs fetch` only)
-    keep the actual binaries under `.git/lfs/objects/<aa>/<bb>/<oid>` while the
-    working tree holds pointers. Reading those blobs in place avoids checking out
-    a duplicate copy of the dataset.
-    """
-    try:
-        if path.stat().st_size > 1024:
-            return path
-    except OSError:
-        return path
-    with open(path, "rb") as file:
-        head = file.read(256)
-    if not head.startswith(LFS_POINTER_PREFIX):
-        return path
-    oid: str | None = None
-    for line in head.decode("ascii", errors="ignore").splitlines():
-        if line.startswith("oid sha256:"):
-            oid = line.split(":", 1)[1].strip()
-            break
-    if not oid:
-        raise ValueError(f"{path}: looks like an LFS pointer but no sha256 oid line")
-    # Walk parents of the resolved path (so symlinked working trees still find the
-    # original repo's `.git/lfs/objects`).
-    for ancestor in path.resolve().parents:
-        candidate = ancestor / ".git" / "lfs" / "objects" / oid[:2] / oid[2:4] / oid
-        if candidate.is_file():
-            return candidate
-    raise FileNotFoundError(
-        f"{path}: LFS pointer references oid {oid} but no .git/lfs/objects/ contains it; "
-        f"run `git lfs fetch` or pass --output to a tree that has the blobs"
-    )
-
-
-@dataclass(frozen=True, slots=True)
-class CollectionShard:
-    wikiname: str
-    stem: str
-    row_offset: int
-    row_count: int
-
-
-def discover_shards(model_root: Path, suffix: str) -> list[CollectionShard]:
-    """Find every {wiki}/{stem}.{suffix}.f16bin under model_root in deterministic order."""
-    binaries: list[tuple[str, str, Path, int]] = []
-    for wiki_dir in sorted(model_root.iterdir()):
-        if not wiki_dir.is_dir():
-            continue
-        for path in sorted(wiki_dir.glob(f"*.{suffix}.f16bin")):
-            stem = path.name[: -len(f".{suffix}.f16bin")]
-            blob_path = resolve_lfs_pointer(path)
-            with open(blob_path, "rb") as file:
-                rows, _columns = struct.unpack("<II", file.read(8))
-            binaries.append((wiki_dir.name, stem, path, rows))
-
-    shards: list[CollectionShard] = []
-    offset = 0
-    for wikiname, stem, _path, row_count in binaries:
-        shards.append(
-            CollectionShard(
-                wikiname=wikiname,
-                stem=stem,
-                row_offset=offset,
-                row_count=row_count,
-            )
-        )
-        offset += row_count
-    return shards
+from wikiverse import (
+    CollectionShard,
+    discover_collection,
+    resolve_lfs_pointer,
+    write_bin,
+)
 
 
 def load_collection(
@@ -432,9 +360,10 @@ def gather_outputs(
             wiki_dir.mkdir(parents=True, exist_ok=True)
             indices_path = wiki_dir / f"{shard.stem}.{suffix}.ground_truth.ibin"
             scores_path = wiki_dir / f"{shard.stem}.{suffix}.ground_truth.fbin"
-            with open(indices_path, "wb") as out_indices, open(
-                scores_path, "wb"
-            ) as out_scores:
+            with (
+                open(indices_path, "wb") as out_indices,
+                open(scores_path, "wb") as out_scores,
+            ):
                 out_indices.write(struct.pack("<II", shard.row_count, num_neighbors))
                 out_scores.write(struct.pack("<II", shard.row_count, num_neighbors))
                 cursor = shard.row_offset
@@ -508,7 +437,7 @@ def main() -> None:
     if not model_root.is_dir():
         raise SystemExit(f"no collection at {model_root}")
 
-    shards = discover_shards(model_root, args.output_suffix)
+    shards = discover_collection(model_root, args.output_suffix)
     if not shards:
         raise SystemExit(f"no .{args.output_suffix}.f16bin files under {model_root}")
     total_vectors = sum(shard.row_count for shard in shards)

late_chunking.py

@@ -0,0 +1,334 @@
+"""Late-chunking with section-aware windowing for long-context encoders.
+
+The pipeline is:
+
+  1. Find section spans (character coordinates) in an article's rendered Markdown.
+  2. Tokenize the whole article once, with offset mapping, so each section maps
+     to a token range.
+  3. Greedy-pack consecutive sections into windows of `core` tokens, where
+     `core <= context_limit - 2 * margin`. Sections too large for one window
+     get split into fragments; fragments live in their own windows.
+  4. Surround each window's core with up to `margin` tokens of left- and
+     right-context drawn from the surrounding tokens of the same article.
+     Margins exist purely so attention can flow between adjacent sections.
+  5. Run the model once per window. Mean-pool the *core* token outputs (skip
+     the margin) per section. If a section was split, weighted-average its
+     fragment vectors by token count to recover one vector per section.
+
+The output is one embedding vector per source section, in article order.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+import numpy as np
+
+# Markdown heading lines: between 1 and 6 leading hashes followed by whitespace.
+HEADING_LINE = re.compile(r"^(#{1,6})\s+(.*)$", re.MULTILINE)
+
+
+@dataclass(frozen=True, slots=True)
+class SectionCharSpan:
+    """A section's character-coordinate span and its heading metadata."""
+
+    char_start: int
+    char_end: int
+    heading_level: int  # 0 for the lead section (no heading)
+    heading_text: str | None  # None for the lead section
+
+
+@dataclass(frozen=True, slots=True)
+class SectionTokenSpan:
+    """A section's token-coordinate span (after tokenization)."""
+
+    section_index: int
+    token_start: int  # inclusive, in article token coordinates
+    token_end: int  # exclusive
+    heading_level: int
+    heading_text: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class CoreSegment:
+    """One contiguous range of tokens inside a window's core that pools to part
+    of (or all of) a single section's vector.
+
+    For a section that fits in one window, fragment_count == 1. For a section
+    split across N windows, the same section_index produces N CoreSegments,
+    each with the same fragment_count == N, but different fragment_index in
+    [0, N)."""
+
+    section_index: int
+    fragment_index: int
+    fragment_count: int
+    article_token_start: int  # in article coordinates
+    article_token_end: int  # exclusive
+
+
+@dataclass(frozen=True, slots=True)
+class Window:
+    """One forward-pass through the encoder.
+
+    `token_ids` is the literal input to the model: left margin (0..core_start),
+    then core (core_start..core_end), then right margin (core_end..len).
+    `core_segments` describe how to mean-pool the core token outputs into
+    section fragments.
+    """
+
+    token_ids: list[int]
+    core_start: int  # offset in token_ids where core begins
+    core_end: int  # offset where core ends (exclusive)
+    core_segments: list[CoreSegment]
+    article_left_margin_start: int  # in article token coordinates
+    article_right_margin_end: int  # exclusive
+
+    @property
+    def length(self) -> int:
+        return len(self.token_ids)
+
+    def core_segment_window_range(self, segment: CoreSegment) -> tuple[int, int]:
+        """Return (start, end) offsets for `segment` in this window's outputs.
+
+        A window position is just the corresponding article position shifted by
+        the left-margin start, since `token_ids` is a contiguous slice of the
+        article tokens beginning at `article_left_margin_start`.
+        """
+        start = segment.article_token_start - self.article_left_margin_start
+        end = segment.article_token_end - self.article_left_margin_start
+        return start, end
+
+
+def find_section_char_spans(text: str) -> list[SectionCharSpan]:
+    """Split the rendered Markdown text into section spans.
+
+    A section runs from a heading line to the next heading line (exclusive).
+    The lead — anything before the first heading — is its own section with
+    `heading_level == 0` and `heading_text is None`.
+    """
+    if not text:
+        return []
+    headings = list(HEADING_LINE.finditer(text))
+    if not headings:
+        return [SectionCharSpan(0, len(text), 0, None)]
+
+    spans: list[SectionCharSpan] = []
+    if headings[0].start() > 0:
+        spans.append(SectionCharSpan(0, headings[0].start(), 0, None))
+    for index, match in enumerate(headings):
+        next_start = (
+            headings[index + 1].start() if index + 1 < len(headings) else len(text)
+        )
+        spans.append(
+            SectionCharSpan(
+                char_start=match.start(),
+                char_end=next_start,
+                heading_level=len(match.group(1)),
+                heading_text=match.group(2).strip() or None,
+            )
+        )
+    return spans
+
+
+def section_token_spans_from_offsets(
+    section_char_spans: Sequence[SectionCharSpan],
+    token_offsets: Sequence[tuple[int, int]],
+) -> list[SectionTokenSpan]:
+    """Convert character-coordinate section spans into token-coordinate spans
+    using the tokenizer's `offset_mapping` output. Sections that produce zero
+    tokens (empty after tokenization) are dropped silently."""
+    n_tokens = len(token_offsets)
+    spans: list[SectionTokenSpan] = []
+    for index, section in enumerate(section_char_spans):
+        # First token whose start offset >= section.char_start.
+        token_start = n_tokens
+        for token_index, (char_start, _) in enumerate(token_offsets):
+            if char_start >= section.char_start:
+                token_start = token_index
+                break
+        # First token whose start offset >= section.char_end (exclusive).
+        token_end = n_tokens
+        for token_index, (char_start, _) in enumerate(token_offsets):
+            if char_start >= section.char_end:
+                token_end = token_index
+                break
+        if token_end > token_start:
+            spans.append(
+                SectionTokenSpan(
+                    section_index=index,
+                    token_start=token_start,
+                    token_end=token_end,
+                    heading_level=section.heading_level,
+                    heading_text=section.heading_text,
+                )
+            )
+    return spans
+
+
+def plan_windows(
+    article_token_ids: Sequence[int],
+    section_token_spans: Sequence[SectionTokenSpan],
+    context_limit: int,
+    margin: int,
+) -> list[Window]:
+    """Greedy-pack sections into windows of `<= context_limit - 2*margin` core
+    tokens. Sections that exceed the per-window core limit are split into
+    fragments, each fragment getting its own window. Margins are added per
+    window from neighboring article tokens.
+    """
+    if context_limit <= 2 * margin:
+        raise ValueError(
+            f"context_limit ({context_limit}) must exceed 2 * margin ({2 * margin})"
+        )
+    max_core_tokens = context_limit - 2 * margin
+    n_article_tokens = len(article_token_ids)
+
+    # Step 1: build "segments" — each segment is one fragment of one section that
+    # fits in a single window. Sections shorter than max_core_tokens become a
+    # single segment; longer sections become multiple segments.
+    segments: list[CoreSegment] = []
+    for span in section_token_spans:
+        section_size = span.token_end - span.token_start
+        if section_size <= max_core_tokens:
+            segments.append(
+                CoreSegment(
+                    section_index=span.section_index,
+                    fragment_index=0,
+                    fragment_count=1,
+                    article_token_start=span.token_start,
+                    article_token_end=span.token_end,
+                )
+            )
+            continue
+        n_fragments = (section_size + max_core_tokens - 1) // max_core_tokens
+        # Even-sized fragments (last one may be slightly smaller).
+        base = section_size // n_fragments
+        remainder = section_size - base * n_fragments
+        cursor = span.token_start
+        for fragment_index in range(n_fragments):
+            this_size = base + (1 if fragment_index < remainder else 0)
+            segments.append(
+                CoreSegment(
+                    section_index=span.section_index,
+                    fragment_index=fragment_index,
+                    fragment_count=n_fragments,
+                    article_token_start=cursor,
+                    article_token_end=cursor + this_size,
+                )
+            )
+            cursor += this_size
+
+    # Step 2: greedy-pack segments into windows. A multi-fragment section never
+    # shares a window with anything else: its segments are already exactly
+    # max_core_tokens (or smaller, for the last fragment), so packing them
+    # alongside other sections would risk overflow.
+    window_segment_groups: list[list[CoreSegment]] = []
+    current: list[CoreSegment] = []
+    current_size = 0
+    for segment in segments:
+        segment_size = segment.article_token_end - segment.article_token_start
+        is_split_section = segment.fragment_count > 1
+        previous_was_split = bool(current) and current[-1].fragment_count > 1
+        new_window_required = (
+            not current
+            or is_split_section
+            or previous_was_split
+            or current_size + segment_size > max_core_tokens
+        )
+        if new_window_required and current:
+            window_segment_groups.append(current)
+            current = []
+            current_size = 0
+        current.append(segment)
+        current_size += segment_size
+    if current:
+        window_segment_groups.append(current)
+
+    # Step 3: materialize each window with margins drawn from the surrounding
+    # article tokens.
+    windows: list[Window] = []
+    for group in window_segment_groups:
+        core_start_in_article = group[0].article_token_start
+        core_end_in_article = group[-1].article_token_end
+        left_margin_start = max(0, core_start_in_article - margin)
+        right_margin_end = min(n_article_tokens, core_end_in_article + margin)
+        token_ids = list(article_token_ids[left_margin_start:right_margin_end])
+        core_start_in_window = core_start_in_article - left_margin_start
+        core_end_in_window = core_end_in_article - left_margin_start
+        windows.append(
+            Window(
+                token_ids=token_ids,
+                core_start=core_start_in_window,
+                core_end=core_end_in_window,
+                core_segments=list(group),
+                article_left_margin_start=left_margin_start,
+                article_right_margin_end=right_margin_end,
+            )
+        )
+    return windows
+
+
+def pool_section_vectors(
+    windows: Sequence[Window],
+    window_token_outputs: Sequence[np.ndarray],
+    n_sections: int,
+    embedding_dim: int,
+) -> np.ndarray:
+    """Reduce per-window per-token output vectors to one vector per section.
+
+    `window_token_outputs[i]` must have shape `(windows[i].length, embedding_dim)`.
+    The pooled outputs are mean-pooled over each section's token range; sections
+    that were split into fragments are recombined by token-count-weighted average
+    across their fragments.
+    """
+    fragment_sums: dict[tuple[int, int], np.ndarray] = {}
+    fragment_counts: dict[tuple[int, int], int] = {}
+    for window, outputs in zip(windows, window_token_outputs, strict=True):
+        if outputs.shape != (window.length, embedding_dim):
+            raise ValueError(
+                f"window output shape {outputs.shape} != ({window.length}, {embedding_dim})"
+            )
+        for segment in window.core_segments:
+            window_start, window_end = window.core_segment_window_range(segment)
+            segment_outputs = outputs[window_start:window_end]
+            if segment_outputs.shape[0] == 0:
+                continue
+            key = (segment.section_index, segment.fragment_index)
+            fragment_sums[key] = segment_outputs.sum(axis=0).astype(np.float32)
+            fragment_counts[key] = segment_outputs.shape[0]
+
+    section_vectors = np.zeros((n_sections, embedding_dim), dtype=np.float32)
+    section_token_totals = np.zeros(n_sections, dtype=np.int64)
+    for (section_index, _fragment_index), summed in fragment_sums.items():
+        n_tokens = fragment_counts[(section_index, _fragment_index)]
+        section_vectors[section_index] += summed
+        section_token_totals[section_index] += n_tokens
+    nonzero = section_token_totals > 0
+    section_vectors[nonzero] /= section_token_totals[nonzero, None]
+    return section_vectors
+
+
+def chunk_article(
+    text: str,
+    tokenizer,  # transformers.PreTrainedTokenizer
+    context_limit: int = 8192,
+    margin: int = 256,
+) -> tuple[list[Window], list[SectionTokenSpan]]:
+    """End-to-end: rendered Markdown -> windows ready for the model.
+
+    Returns the windows plus the section token spans (so callers can correlate
+    section vectors back to heading metadata)."""
+    char_spans = find_section_char_spans(text)
+    encoding = tokenizer(
+        text,
+        add_special_tokens=False,
+        return_offsets_mapping=True,
+        truncation=False,
+    )
+    token_ids: list[int] = encoding["input_ids"]
+    token_offsets: list[tuple[int, int]] = list(encoding["offset_mapping"])
+    section_spans = section_token_spans_from_offsets(char_spans, token_offsets)
+    windows = plan_windows(token_ids, section_spans, context_limit, margin)
+    return windows, section_spans

pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "usearchwiki"
+version = "0.0.0"
+description = "Multi-model embedding dataset over FineWiki for ANN-search benchmarking"
+readme = "README.md"
+license = { text = "Apache-2.0" }
+requires-python = ">=3.12"
+dependencies = [
+    "numpy>=1.26",
+    "pyarrow>=16",
+]
+
+[project.optional-dependencies]
+dense    = ["httpx>=0.27"]
+ground   = ["cupy-cuda12x>=14", "torch>=2.5"]
+colbert  = ["pylate>=1.0"]
+index    = ["usearch>=2.25"]
+dev      = ["ruff>=0.15", "pytest>=8", "mypy>=1.13"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP", "C4"]
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["E402"]   # imports after sys.path manipulation
+
+[tool.mypy]
+python_version = "3.12"
+strict_optional = true
+warn_unused_ignores = true
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

tests/test_ground_truth.py

@@ -12,8 +12,6 @@ or directly:
 
 from __future__ import annotations
 
-import json
-import struct
 import subprocess
 import sys
 import tempfile
@@ -24,7 +22,7 @@ import numpy as np
 REPO_ROOT = Path(__file__).resolve().parent.parent
 sys.path.insert(0, str(REPO_ROOT))
 
-from wikiverse import write_bin, read_bin  # noqa: E402
+from wikiverse import read_bin, write_bin  # noqa: E402
 
 
 def normalize_rows(matrix: np.ndarray) -> np.ndarray:
@@ -70,8 +68,8 @@ def assemble_per_shard(
     model_root: Path, suffix: str, extension: str, dtype: str
 ) -> np.ndarray:
     """Read every `{wiki}/{stem}.{suffix}.ground_truth.{extension}` and
-    concatenate in the same deterministic order discover_shards uses (sorted
-    wikiname, then sorted stem)."""
+    concatenate in the same deterministic order discover_collection uses
+    (sorted wikiname, then sorted stem)."""
     parts: list[np.ndarray] = []
     for wiki_dir in sorted(model_root.iterdir()):
         if not wiki_dir.is_dir():
@@ -87,8 +85,6 @@ def reference_topk(
     """Brute-force exact top-k via NumPy float32 matmul, with self-match dropped."""
     f32 = embeddings.astype(np.float32)
     similarity = f32 @ f32.T
-    total = embeddings.shape[0]
-    # Drop self-match by setting diagonal to -inf, then take top-k.
     np.fill_diagonal(similarity, -np.inf)
     top_indices = np.argsort(-similarity, axis=1)[:, :num_neighbors].astype(np.int32)
     top_scores = np.take_along_axis(similarity, top_indices, axis=1).astype(np.float32)

tests/test_late_chunking.py

@@ -0,0 +1,283 @@
+"""Synthetic tests for late_chunking.py.
+
+The chunker is purely arithmetic — given an article's tokens and section
+spans, it produces windows. We can verify all the invariants without a model:
+
+  - every section's core tokens appear in exactly one window
+    (or, when split, every section's core tokens are partitioned across
+    fragments without gaps or overlaps)
+  - every window's input length is at most context_limit
+  - every section's pooled token range falls inside a window's core
+  - margins respect article boundaries
+  - pool_section_vectors recovers the right per-section means
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import numpy as np
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT))
+
+from late_chunking import (  # noqa: E402
+    CoreSegment,
+    SectionCharSpan,
+    SectionTokenSpan,
+    Window,
+    find_section_char_spans,
+    plan_windows,
+    pool_section_vectors,
+    section_token_spans_from_offsets,
+)
+
+
+def make_synthetic_section_spans(
+    section_sizes: list[int],
+) -> tuple[list[int], list[SectionTokenSpan]]:
+    """Build (article_token_ids, section_token_spans) where each token's id
+    encodes its (section_index, position_in_section) so we can verify that
+    pooling maps the right tokens back to the right section."""
+    spans: list[SectionTokenSpan] = []
+    token_ids: list[int] = []
+    cursor = 0
+    for index, size in enumerate(section_sizes):
+        spans.append(
+            SectionTokenSpan(
+                section_index=index,
+                token_start=cursor,
+                token_end=cursor + size,
+                heading_level=2,
+                heading_text=f"Section {index}",
+            )
+        )
+        for position in range(size):
+            # Encode (section_index, position) so the test can verify pooling.
+            token_ids.append(index * 100000 + position)
+        cursor += size
+    return token_ids, spans
+
+
+def assert_windows_cover_all_sections(
+    section_sizes: list[int],
+    spans: list[SectionTokenSpan],
+    windows: list[Window],
+) -> None:
+    """Every section's [token_start, token_end) must be covered by exactly one
+    set of CoreSegments whose article ranges concatenate to the original."""
+    by_section: dict[int, list[CoreSegment]] = {}
+    for window in windows:
+        for segment in window.core_segments:
+            by_section.setdefault(segment.section_index, []).append(segment)
+    for index, span in enumerate(spans):
+        section_segments = sorted(
+            by_section[index], key=lambda seg: seg.fragment_index
+        )
+        # Fragments must form a contiguous partition.
+        cursor = span.token_start
+        for fragment in section_segments:
+            assert fragment.article_token_start == cursor, (
+                f"section {index} fragment gap at {cursor} vs {fragment.article_token_start}"
+            )
+            cursor = fragment.article_token_end
+            assert fragment.fragment_count == len(section_segments), (
+                f"section {index} fragment_count mismatch"
+            )
+        assert cursor == span.token_end, (
+            f"section {index} fragments end at {cursor}, expected {span.token_end}"
+        )
+
+
+def assert_window_lengths_within_limit(
+    windows: list[Window], context_limit: int
+) -> None:
+    for index, window in enumerate(windows):
+        assert window.length <= context_limit, (
+            f"window {index} length {window.length} exceeds context_limit {context_limit}"
+        )
+        # Core boundaries must lie within the window.
+        assert 0 <= window.core_start <= window.core_end <= window.length
+
+
+def assert_segment_offsets_consistent(windows: list[Window]) -> None:
+    for window in windows:
+        for segment in window.core_segments:
+            window_start, window_end = window.core_segment_window_range(segment)
+            assert window.core_start <= window_start < window_end <= window.core_end, (
+                f"segment {segment} offsets ({window_start}, {window_end}) "
+                f"escape core [{window.core_start}, {window.core_end})"
+            )
+
+
+def test_single_section_fits_in_one_window() -> None:
+    section_sizes = [400]
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    assert len(windows) == 1
+    assert_window_lengths_within_limit(windows, 8192)
+    assert_windows_cover_all_sections(section_sizes, spans, windows)
+    # No left margin (article starts here) and no right margin (article ends here).
+    assert windows[0].core_start == 0
+    assert windows[0].core_end == 400
+    assert windows[0].length == 400
+    print("PASS: single-section fits in one window")
+
+
+def test_many_small_sections_pack_into_one_window() -> None:
+    section_sizes = [100] * 30  # 3000 total tokens
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    assert len(windows) == 1, f"expected 1 window, got {len(windows)}"
+    assert sum(s.token_end - s.token_start for s in spans) == windows[0].core_end - windows[0].core_start
+    print(f"PASS: 30 small sections packed into 1 window ({windows[0].length} tokens)")
+
+
+def test_sections_split_across_multiple_windows() -> None:
+    # 10 sections of 1000 each = 10K tokens; with core 7680 that's 2 windows.
+    section_sizes = [1000] * 10
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    assert len(windows) == 2, f"expected 2 windows, got {len(windows)}"
+    assert_window_lengths_within_limit(windows, 8192)
+    assert_windows_cover_all_sections(section_sizes, spans, windows)
+    assert_segment_offsets_consistent(windows)
+    # Window 0 has no left margin (article start); has a right margin from window 1's first section.
+    assert windows[0].article_left_margin_start == 0
+    assert windows[0].length > windows[0].core_end - windows[0].core_start  # right margin present
+    # Window 1 has a left margin from window 0's tail; no right margin (article end).
+    assert windows[1].article_right_margin_end == 10000
+    assert windows[1].core_start > 0  # left margin present
+    print(f"PASS: 10 x 1000-token sections -> {len(windows)} windows with margins")
+
+
+def test_oversized_section_split_into_fragments() -> None:
+    # One section of 20K tokens, where context=8192, margin=256, core_max=7680.
+    # 20000 / 7680 = 3 fragments (sizes 6667, 6667, 6666).
+    section_sizes = [20000]
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    assert len(windows) == 3, f"expected 3 windows, got {len(windows)}"
+    fragments = [seg for w in windows for seg in w.core_segments]
+    assert len(fragments) == 3
+    assert all(f.fragment_count == 3 for f in fragments)
+    # Fragments must partition the section's token range.
+    starts = [f.article_token_start for f in fragments]
+    ends = [f.article_token_end for f in fragments]
+    assert starts[0] == 0 and ends[-1] == 20000
+    for i in range(len(fragments) - 1):
+        assert ends[i] == starts[i + 1]
+    assert_window_lengths_within_limit(windows, 8192)
+    print("PASS: oversized section split into 3 fragments across 3 windows")
+
+
+def test_mixed_normal_and_oversized_sections() -> None:
+    # Lead 100, big middle 10000, tail 200.
+    section_sizes = [100, 10000, 200]
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    assert_windows_cover_all_sections(section_sizes, spans, windows)
+    assert_window_lengths_within_limit(windows, 8192)
+    assert_segment_offsets_consistent(windows)
+    # The middle section needs 2 windows to itself; the lead and tail go in
+    # their own windows because we don't share with split sections.
+    fragment_counts = {seg.section_index: seg.fragment_count for w in windows for seg in w.core_segments}
+    assert fragment_counts == {0: 1, 1: 2, 2: 1}, fragment_counts
+    print(f"PASS: mixed normal+oversized -> {len(windows)} windows")
+
+
+def test_pool_section_vectors_recovers_means() -> None:
+    """Synthesize per-token outputs whose mean is the section index;
+    verify that pooled vectors equal the section index."""
+    section_sizes = [50, 30, 20]
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    embedding_dim = 8
+    window_outputs: list[np.ndarray] = []
+    for window in windows:
+        out = np.zeros((window.length, embedding_dim), dtype=np.float32)
+        for segment in window.core_segments:
+            wstart, wend = window.core_segment_window_range(segment)
+            # Fill core token rows with a vector whose values equal section_index.
+            out[wstart:wend] = float(segment.section_index) + 0.0
+        window_outputs.append(out)
+    pooled = pool_section_vectors(windows, window_outputs, n_sections=3, embedding_dim=embedding_dim)
+    expected = np.array(
+        [[0.0] * 8, [1.0] * 8, [2.0] * 8],
+        dtype=np.float32,
+    )
+    assert np.allclose(pooled, expected), pooled
+    print("PASS: pool_section_vectors recovers per-section means")
+
+
+def test_pool_recovers_split_section_via_weighted_mean() -> None:
+    """Section split into 2 fragments of different sizes; per-fragment mean is
+    different; pooled section vector must be the token-weighted average."""
+    # Single section, 12K tokens — splits into 2 fragments of 6K each (since
+    # core max = 7680 and 12000/7680 rounds to 2).
+    section_sizes = [12000]
+    article_tokens, spans = make_synthetic_section_spans(section_sizes)
+    windows = plan_windows(article_tokens, spans, context_limit=8192, margin=256)
+    assert len(windows) == 2
+    embedding_dim = 4
+    window_outputs: list[np.ndarray] = []
+    for window in windows:
+        out = np.zeros((window.length, embedding_dim), dtype=np.float32)
+        for segment in window.core_segments:
+            wstart, wend = window.core_segment_window_range(segment)
+            # Fragment 0 -> mean is 1.0; fragment 1 -> mean is 5.0.
+            value = 1.0 if segment.fragment_index == 0 else 5.0
+            out[wstart:wend] = value
+        window_outputs.append(out)
+    pooled = pool_section_vectors(windows, window_outputs, n_sections=1, embedding_dim=embedding_dim)
+    # Both fragments are 6000 tokens; weighted mean = (1*6000 + 5*6000)/12000 = 3.0.
+    assert np.allclose(pooled, np.full((1, 4), 3.0)), pooled
+    print("PASS: split section recovered via token-weighted average")
+
+
+def test_section_char_spans_lead_only() -> None:
+    text = "Just one paragraph of text, no headings."
+    spans = find_section_char_spans(text)
+    assert len(spans) == 1
+    assert spans[0].heading_text is None
+    assert spans[0].heading_level == 0
+    print("PASS: lead-only article -> 1 section span")
+
+
+def test_section_char_spans_with_headings() -> None:
+    text = "Lead paragraph.\n\n# History\nHistory text.\n\n## Origins\nOrigins text.\n"
+    spans = find_section_char_spans(text)
+    levels_and_titles = [(s.heading_level, s.heading_text) for s in spans]
+    assert levels_and_titles == [(0, None), (1, "History"), (2, "Origins")], levels_and_titles
+    # The last section ends at end-of-text.
+    assert spans[-1].char_end == len(text)
+    print("PASS: lead + 2 headings -> 3 section spans")
+
+
+def test_section_token_spans_from_offsets() -> None:
+    # Two sections at char [0,100) and [100, 200); offsets every 5 chars.
+    char_spans = [
+        SectionCharSpan(char_start=0, char_end=100, heading_level=0, heading_text=None),
+        SectionCharSpan(char_start=100, char_end=200, heading_level=1, heading_text="X"),
+    ]
+    offsets = [(i * 5, i * 5 + 5) for i in range(40)]
+    token_spans = section_token_spans_from_offsets(char_spans, offsets)
+    assert len(token_spans) == 2
+    assert token_spans[0].token_start == 0 and token_spans[0].token_end == 20
+    assert token_spans[1].token_start == 20 and token_spans[1].token_end == 40
+    print("PASS: char->token span conversion")
+
+
+if __name__ == "__main__":
+    test_section_char_spans_lead_only()
+    test_section_char_spans_with_headings()
+    test_section_token_spans_from_offsets()
+    test_single_section_fits_in_one_window()
+    test_many_small_sections_pack_into_one_window()
+    test_sections_split_across_multiple_windows()
+    test_oversized_section_split_into_fragments()
+    test_mixed_normal_and_oversized_sections()
+    test_pool_section_vectors_recovers_means()
+    test_pool_recovers_split_section_via_weighted_mean()
+    print("\nALL TESTS PASSED")

wikiverse.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 import re
 import struct
+from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Iterator, Literal
+from typing import Literal
 
 import numpy as np
 import pyarrow.parquet as pq
@@ -18,6 +19,8 @@ file_extensions = {"f16": "f16bin", "f32": "fbin", "i32": "ibin"}
 
 DType = Literal["f16", "f32", "i32"]
 
+LFS_POINTER_PREFIX = b"version https://git-lfs"
+
 
 @dataclass(frozen=True, slots=True)
 class Shard:
@@ -31,6 +34,96 @@ class Shard:
         return f"{self.group:03d}_{self.index:05d}"
 
 
+@dataclass(frozen=True, slots=True)
+class CollectionShard:
+    """A shard of an embedding collection, populated with its row count and the
+    row offset that would assign each of its rows a deterministic global flat ID
+    (used as the integer key for ground truth, USearch indexes, and any consumer
+    that wants to map vectors back to their source article)."""
+
+    wikiname: str
+    stem: str
+    path: Path
+    row_offset: int
+    row_count: int
+
+
+def resolve_lfs_pointer(path: Path) -> Path:
+    """If `path` is a Git-LFS pointer file, return the materialized blob in
+    `.git/lfs/objects`; otherwise return the path unchanged.
+
+    Pointer files are tiny ASCII stubs (~133 bytes) with an `oid sha256:<hex>`
+    line. Repositories cloned with `GIT_LFS_SKIP_SMUDGE=1` (or with `git lfs
+    fetch` only) keep the actual binaries under `.git/lfs/objects/<aa>/<bb>/<oid>`
+    while the working tree holds pointers. Reading those blobs in place avoids
+    checking out a duplicate copy of the dataset.
+    """
+    try:
+        if path.stat().st_size > 1024:
+            return path
+    except OSError:
+        return path
+    with open(path, "rb") as file:
+        head = file.read(256)
+    if not head.startswith(LFS_POINTER_PREFIX):
+        return path
+    oid: str | None = None
+    for line in head.decode("ascii", errors="ignore").splitlines():
+        if line.startswith("oid sha256:"):
+            oid = line.split(":", 1)[1].strip()
+            break
+    if not oid:
+        raise ValueError(f"{path}: looks like an LFS pointer but no sha256 oid line")
+    # Walk parents of the resolved path so symlinked working trees still find
+    # the original repo's `.git/lfs/objects`.
+    for ancestor in path.resolve().parents:
+        candidate = ancestor / ".git" / "lfs" / "objects" / oid[:2] / oid[2:4] / oid
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(
+        f"{path}: LFS pointer references oid {oid} but no .git/lfs/objects/ contains it; "
+        f"run `git lfs fetch` or pass --output to a tree that has the blobs"
+    )
+
+
+def discover_collection(
+    model_root: Path, suffix: str = "body"
+) -> list[CollectionShard]:
+    """Walk an embedding collection's per-shard `.f16bin` files in canonical
+    order (sorted wikiname, then sorted shard stem), reading each header to
+    capture its row count, and return a list of `CollectionShard`s with
+    cumulative `row_offset`s assigned.
+
+    This is the *contract* for the global flat IDs: the i-th row of the n-th
+    shard (after this canonical walk) gets ID `shards[n].row_offset + i`.
+    Ground truth files, USearch index keys, and any consumer needing a
+    deterministic vector-to-article mapping should reproduce this walk.
+    """
+    if not model_root.is_dir():
+        raise FileNotFoundError(f"no model directory at {model_root}")
+    shards: list[CollectionShard] = []
+    cumulative = 0
+    for wiki_dir in sorted(model_root.iterdir()):
+        if not wiki_dir.is_dir():
+            continue
+        for path in sorted(wiki_dir.glob(f"*.{suffix}.f16bin")):
+            stem = path.name[: -len(f".{suffix}.f16bin")]
+            blob = resolve_lfs_pointer(path)
+            with open(blob, "rb") as file:
+                rows, _columns = struct.unpack("<II", file.read(8))
+            shards.append(
+                CollectionShard(
+                    wikiname=wiki_dir.name,
+                    stem=stem,
+                    path=path,
+                    row_offset=cumulative,
+                    row_count=rows,
+                )
+            )
+            cumulative += rows
+    return shards
+
+
 def find_snapshot(cache_dir: str | Path) -> Path:
     cache_dir = Path(cache_dir)
     snapshots = cache_dir / "datasets--HuggingFaceFW--finewiki" / "snapshots"
@@ -72,7 +165,7 @@ def iter_articles(
     table = pq.read_table(shard.path, columns=[id_column, text_column])
     identifiers = table.column(id_column).to_pylist()
     texts = table.column(text_column).to_pylist()
-    for identifier, text in zip(identifiers, texts):
+    for identifier, text in zip(identifiers, texts, strict=True):
         yield str(identifier), text or ""