Struct IncrementalDiskANN 

pub struct IncrementalDiskANN<D>
where
    D: Distance<f32> + Send + Sync + Copy + Clone + 'static,
{ /* private fields */ }

An incremental DiskANN index supporting add/delete without full rebuild

Implementations

impl<D> IncrementalDiskANN<D>

where D: Distance<f32> + Send + Sync + Copy + Clone + Default + 'static,

pub fn build_default( vectors: &[Vec<f32>], file_path: &str, ) -> Result<Self, DiskAnnError>

Build a new incremental index with default parameters

pub fn open(path: &str) -> Result<Self, DiskAnnError>

Open an existing index for incremental updates

impl<D> IncrementalDiskANN<D>

where D: Distance<f32> + Send + Sync + Copy + Clone + 'static,

pub fn build_with_config( vectors: &[Vec<f32>], file_path: &str, config: IncrementalConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Build a new incremental index with custom configuration

pub fn open_with_config( path: &str, config: IncrementalConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Open an existing index with custom configuration

pub fn new_empty(dim: usize, dist: D, config: IncrementalConfig) -> Self

Create an empty incremental index (no base, delta-only)

pub fn build_with_labels( vectors: &[Vec<f32>], labels: &[Vec<u64>], file_path: &str, config: IncrementalConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Build an incremental index with per-vector labels for filtered search.

pub fn build_quantized_f16( vectors: &[Vec<f32>], file_path: &str, config: IncrementalConfig, quant_config: IncrementalQuantizedConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Build an incremental index with F16 quantization.

pub fn build_quantized_int8( vectors: &[Vec<f32>], file_path: &str, config: IncrementalConfig, quant_config: IncrementalQuantizedConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Build an incremental index with Int8 quantization.

pub fn build_quantized_pq( vectors: &[Vec<f32>], file_path: &str, config: IncrementalConfig, pq_config: PQConfig, quant_config: IncrementalQuantizedConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Build an incremental index with PQ quantization.

pub fn build_full( vectors: &[Vec<f32>], labels: &[Vec<u64>], file_path: &str, config: IncrementalConfig, quantizer_kind: QuantizerKind, quant_config: IncrementalQuantizedConfig, ) -> Result<Self, DiskAnnError>

where D: Default,

Build an incremental index with labels AND quantization.

pub fn add_vectors( &self, vectors: &[Vec<f32>], ) -> Result<Vec<u64>, DiskAnnError>

Add new vectors to the index. Returns their assigned IDs.

pub fn add_vectors_with_labels( &self, vectors: &[Vec<f32>], labels: &[Vec<u64>], ) -> Result<Vec<u64>, DiskAnnError>

Add new vectors with labels to the index. Returns their assigned IDs.

pub fn delete_vectors(&self, ids: &[u64]) -> Result<(), DiskAnnError>

Delete vectors by their IDs (lazy deletion via tombstones)

pub fn is_deleted(&self, id: u64) -> bool

Check if a vector ID has been deleted

pub fn search(&self, query: &[f32], k: usize, beam_width: usize) -> Vec<u64>

Search the index, merging results from base and delta, excluding tombstones

pub fn search_with_dists( &self, query: &[f32], k: usize, beam_width: usize, ) -> Vec<(u64, f32)>

Search returning (id, distance) pairs

pub fn search_filtered( &self, query: &[f32], k: usize, beam_width: usize, filter: &Filter, ) -> Vec<u64>

Search with a filter predicate (requires labels).

pub fn search_filtered_with_dists( &self, query: &[f32], k: usize, beam_width: usize, filter: &Filter, ) -> Vec<(u64, f32)>

Search with filter, returning (id, distance) pairs.

pub fn search_batch( &self, queries: &[Vec<f32>], k: usize, beam_width: usize, ) -> Vec<Vec<u64>>

Parallel batch search

pub fn get_vector(&self, id: u64) -> Option<Vec<f32>>

Get a vector by its ID (works for both base and delta)

pub fn should_compact(&self) -> bool

Check if compaction is recommended

pub fn compact(&mut self, new_path: &str) -> Result<(), DiskAnnError>

where D: Default,

Compact the index: merge base + delta, remove tombstones, write new file

pub fn to_bytes(&self) -> Vec<u8>

Serialize the entire incremental index to bytes.

New format (v1):

[magic:u32 = 0x494E4352]["INCR"]
[version:u32 = 1]
[has_base:u8][base_len:u64][base_bytes...]
[dim:u64]
[num_delta:u64][delta_vectors flat]
[num_delta_graph:u64][graph data]
[entry_point:i64]
[max_degree:u64]
[num_tombstones:u64][tombstone_ids]
[has_labels:u8]
  if has_labels:
    [num_label_fields:u64]
    [num_base_labels:u64][base_labels flat]
    [num_delta_labels:u64][delta_labels flat]
[has_quantizer:u8]
  if has_quantizer:
    [code_size:u64]
    [rerank_size:u64]
    [quantizer_data_len:u64][quantizer_data]
    [base_codes_len:u64][base_codes]

pub fn from_bytes( bytes: &[u8], dist: D, config: IncrementalConfig, ) -> Result<Self, DiskAnnError>

Load an incremental index from bytes.

Supports both old format (has_base byte first) and new format (INCR magic).

pub fn stats(&self) -> IncrementalStats

Get statistics about the index

pub fn dim(&self) -> usize

Get the dimensionality of vectors in this index

pub fn has_labels(&self) -> bool

Whether this index has labels configured.

pub fn has_quantizer(&self) -> bool

Whether this index has quantization configured.