Struct RipvecIndex 

pub struct RipvecIndex { /* private fields */ }

Combined orchestrator for the ripvec retrieval pipeline.

Constructed via RipvecIndex::from_root which walks files, chunks them with ripvec’s chunker, embeds with the static encoder, and builds the BM25 index.

Implementations

impl RipvecIndex

pub fn from_root( root: &Path, encoder: StaticEncoder, cfg: &SearchConfig, profiler: &Profiler, pagerank_lookup: Option<HashMap<String, f32>>, pagerank_alpha: f32, ) -> Result<Self>

Build a RipvecIndex by walking root and indexing every supported file. Uses encoder.embed_root (ripvec’s chunker + model2vec encode) and builds a fresh BM25 index over the resulting chunks.

pagerank_lookup is the optional structural-prior map (file path → normalized PageRank) used by the final ranking layer; pass None to disable. pagerank_alpha is the corresponding boost strength.

Errors

Returns the underlying error if embed_root fails.

pub fn apply_diff(&self, diff: &Diff, profiler: &Profiler) -> Result<Self>

Build a new index by incrementally applying diff against self.

The selective-rebuild path that v3.1.0 punted on. Re-embeds only the dirty + new files, splices them into the existing chunks/embeddings, drops deleted files’ chunks, rebuilds BM25 and the per-file/per-language mappings from the new chunk set, reclassifies the corpus, and refreshes the manifest entries for the affected files.

Cost shape

Roughly O(|diff.dirty| + |diff.new|) chunk + embed work plus O(|self.chunks|) BM25 rebuild. On a 5000-chunk corpus with one file changed: ~5-10 ms (embed one file) + ~50 ms (BM25 rebuild) = ~60 ms — vs. ~270 ms-1 s for a full Self::from_root rebuild. The full-build cost is paid only at cold start.

BM25

BM25 is rebuilt from scratch over the new chunks vec rather than incrementally updated. Inverted-postings incremental update is correct but adds significant code; full rebuild at our chunk counts is fast enough that the simpler path wins.

Errors

Returns the underlying error if StaticEncoder::embed_paths fails or if the embedding matrix shape is invalid.

pub fn diff_against_filesystem(&self) -> Diff

Compare the manifest captured at build time against the current filesystem state under Self::root, using the same WalkOptions used for the original index build.

Returns a Diff enumerating dirty, new, and deleted files. A zero-cost (Diff::is_empty) result means the index is up-to-date and no rebuild is needed.

Cost

Walk + per-file stat() for the cheap-path files (typically all of them between successive queries). Blake3 verification is paid only on the rare files where the stat tuple mismatches. On a 200-file repo with no changes: sub-millisecond. On a 92k-file repo with no changes: ~100-130 ms (the walk dominates).

Mutation

This method takes &self and works on a clone of the manifest, so the optimization of “refresh touched-but-unchanged stat tuples” from diff_against_walk is discarded here. In practice that means a file repeatedly touched without content change pays one blake3 read per reconcile rather than zero — negligible at our file sizes.

pub fn root(&self) -> &Path

Canonical root the index was built against.

pub fn walk_options(&self) -> &WalkOptions

Walk options captured at build time.

pub fn manifest(&self) -> &Manifest

Manifest of tracked files (read-only access).

pub fn corpus_class(&self) -> CorpusClass

The index’s corpus classification, computed at build time.

Used by the MCP rerank gate to decide whether the L-12 cross-encoder fires on a given query.

pub fn len(&self) -> usize

Number of indexed chunks.

pub fn is_empty(&self) -> bool

Whether the index has zero chunks.

pub fn chunks(&self) -> &[CodeChunk]

Indexed chunks (read-only access).

pub fn embeddings(&self) -> &Array2<f32>

Indexed embeddings (read-only access).

Array2<f32> of shape [n_chunks, hidden_dim], row-major. Row i is the L2-normalized embedding of chunk i, so cosine similarity reduces to a dot product. Callers that need their own similarity arithmetic (find_similar, find_duplicates) should use embeddings.row(i) for a single-row view or embeddings.dot(&query) for a one-call BLAS GEMV.

pub fn search( &self, query: &str, top_k: usize, mode: SearchMode, alpha: Option<f32>, filter_languages: Option<&[String]>, filter_paths: Option<&[String]>, ) -> Vec<(usize, f32)>

Search the index and return ranked (chunk_index, score) pairs.

mode = SearchMode::Hybrid (default) fuses semantic + BM25 via RRF; Semantic and Keyword use one signal each.

filter_languages and filter_paths build a selector mask that restricts retrieval to chunks in the named files / languages.

Trait Implementations

impl SearchableIndex for RipvecIndex

fn search( &self, query_text: &str, top_k: usize, mode: SearchMode, ) -> Vec<(usize, f32)>

Trait-shape search: text-only, no engine-specific knobs.

The trait surface is the LSP-callers’ common ground. Filters (language, path) and the alpha auto-detect override are not surfaced through the trait because no LSP module uses them.

fn search_from_chunk( &self, chunk_idx: usize, query_text: &str, top_k: usize, mode: SearchMode, ) -> Vec<(usize, f32)>

Use chunk chunk_idx’s own embedding as the query vector and rank everything else by cosine similarity (semantic-only) or blend with BM25 (hybrid). Falls back to text-only keyword search when the chunk index is out of range.

Mirrors the [HybridIndex] equivalent so goto_definition and goto_implementation work identically across engines.

fn chunks(&self) -> &[CodeChunk]

Borrow the indexed chunks.

fn as_any(&self) -> &dyn Any

Downcast escape hatch for callers that legitimately need the concrete engine-specific index type.