ruvector/crates/ruvector-diskann
ruvnet 499dec61a5 feat(ruvector-diskann): wire Quantizer trait into search path — codes load-bearing
Closes the architectural gap surfaced in PR #383: previously
`DiskAnnIndex.pq_codes` was dead storage. `search()` called
`graph.greedy_search` over `FlatVectors` (full f32 originals)
and exact-L2² rerank — `self.pq_codes` was read by neither.

Today's PQ "savings" were on-disk only; in DRAM the index still
held full f32 vectors. RaBitQ inherited the same gap.

This PR makes the `Quantizer` trait load-bearing in the DiskANN
hot path so both backends (PQ + RaBitQ) actually consult their
codes during graph traversal.

## What changes

1. **New `greedy_search_with_codes` in `graph.rs`** — generalizes
   `greedy_search_fast` to accept an arbitrary `distance_fn` closure
   over node ids. The original `greedy_search_fast` stays unchanged
   for back-compat. Surprise observation worth recording: the old
   `greedy_search_fast` was coupled to f32 distance via inline
   `l2_squared(...)` calls inside the loop, NOT via type signatures.
   The "abstraction gap" PR #383 left was three lines, not an
   architectural mismatch.

2. **`DiskAnnIndex` carries `enum QuantizerBackend`** rather than
   `Option<ProductQuantizer>`. Hybrid pattern chosen because:
       Option A (generic `DiskAnnIndex<Q>`) — would cascade through
         `ruvector-diskann-node`'s NAPI binding and any other crate
         using `DiskAnnIndex` by name. Too much ripple.
       Option B (`Box<dyn Quantizer>`) — impossible because
         `Quantizer::Query` is an associated type; trait isn't
         object-safe.
       Hybrid (this PR): match-once-per-search on the backend enum,
         dispatch into a monomorphic closure. Hot loop stays
         branch-free.

3. **Builder API**: `DiskAnnConfig::with_quantizer_kind()`,
   `with_rerank_factor()`, `with_rabitq_seed()`,
   `with_originals_in_memory()`. All have `Default` impls so existing
   call sites compile unchanged after a `..Default::default()` patch.

4. **`with_originals_in_memory(false)` plumbed but not yet honored**.
   `build()` rejects with `InvalidConfig` for now — the disk-backed
   rerank path that would land the actual 17.5× DRAM compression is
   the natural next PR. The trait-driven traversal shipped here is
   the prerequisite. Measured codes-vs-originals memory ratio at
   D=128, n=2000: **codes 40 KB, originals 1024 KB, ratio 0.039
   (~25× smaller)** — once originals can be evicted, dataset-level
   compression will exceed the 17.5× target.

## Recall numbers

| Path | recall@10 | Notes |
|---|---|---|
| Flat f32 (legacy) | 1.000 | n=1k, dim=64, 30 queries |
| **PQ before this PR** | (≈ 1.000) | Codes never read — PQ was effectively no-op on recall |
| **PQ after this PR** | 0.897 | Trait-driven, M=8, rerank_factor=4. Reflects actual quantization noise. |
| **RaBitQ after this PR** | 0.967 | Trait-driven, search_beam=512, rerank_factor=40 |

PQ recall now reflects real quantization noise because PQ codes
are *used* during traversal. 0.897 is well above the 0.85 floor
required by the regression test.

## NAPI binding patch

`ruvector-diskann-node/src/lib.rs:48` was using a struct literal
that listed every `DiskAnnConfig` field. Adding the four new fields
broke that initializer. One-line `..Default::default()` fix
restores it without growing the NAPI override surface (all new
fields have sensible defaults).

## Verification

  cargo build --workspace                                              → 0 errors
  cargo build -p ruvector-diskann --no-default-features                → OK (PQ-only)
  cargo clippy --workspace --all-targets --no-deps -- -D warnings      → exit 0
  cargo fmt --all --check                                              → exit 0
  cargo test -p ruvector-diskann --features rabitq                     → 30 / 30
                                                                          (was 26 in PR #383)

New tests in `tests/quantizer_search_uses_codes.rs`:
  - spy-quantizer codes-consulted assertion (proves codes are now
    consulted; would fail before this PR)
  - recall@10 vs brute-force baseline (≥ 0.85 floor)
  - PQ recall regression (no drop vs the old "ignore codes,
    brute-force rerank" behavior, after accounting for actual
    quantization noise)
  - codes-vs-originals memory ratio sanity check
  - greedy_search_with_codes ≡ greedy_search_fast under f32 distance

Refs: PR #383 (DiskANN Quantizer trait + RaBitQ backend),
docs/research/rabitq-integration/05-roadmap.md Phase 1

Co-Authored-By: claude-flow <ruv@ruv.net>
2026-04-25 21:51:10 -04:00
..
benches feat(ruvector-diskann): add RaBitQ backend via new Quantizer trait 2026-04-25 21:12:41 -04:00
src feat(ruvector-diskann): wire Quantizer trait into search path — codes load-bearing 2026-04-25 21:51:10 -04:00
tests feat(ruvector-diskann): wire Quantizer trait into search path — codes load-bearing 2026-04-25 21:51:10 -04:00
Cargo.toml feat(ruvector-diskann): add RaBitQ backend via new Quantizer trait 2026-04-25 21:12:41 -04:00