Struct VectorSearchIndex 

pub struct VectorSearchIndex { /* private fields */ }

Vector search index

Implementations

impl VectorSearchIndex

pub fn new(config: SearchConfig) -> Self

Create new vector search index

pub fn build(&mut self, embeddings: &HashMap<String, Vec<f32>>) -> Result<()>

Build search index from embeddings

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

Search for K nearest neighbors

pub fn batch_search( &self, queries: &[Vec<f32>], k: usize, ) -> Result<Vec<Vec<SearchResult>>>

Batch search for multiple queries

pub fn get_stats(&self) -> IndexStats

Get index statistics

pub fn radius_search( &self, query: &[f32], radius: f32, ) -> Result<Vec<SearchResult>>

Find entities within a radius

pub fn set_metadata(&mut self, entity_id: &str, metadata: Metadata)

Set metadata for an entity

pub fn set_metadata_batch(&mut self, metadata_map: HashMap<String, Metadata>)

Set metadata for multiple entities

pub fn get_metadata(&self, entity_id: &str) -> Option<&Metadata>

Get metadata for an entity

pub fn filtered_search( &self, query: &[f32], k: usize, filter: &Filter, ) -> Result<Vec<SearchResult>>

Search with metadata filtering (post-filtering)

Post-filtering searches all vectors first, then filters results. This is efficient when the filter is selective.

pub fn prefiltered_search( &self, query: &[f32], k: usize, filter: &Filter, ) -> Result<Vec<SearchResult>>

Search with pre-filtering (filter before computing distances)

Pre-filtering only computes distances for entities matching the filter. This is efficient when the filter discards most entities.

pub fn add_vector( &mut self, entity_id: String, embedding: Vec<f32>, ) -> Result<()>

Add a single vector to the index incrementally (without full rebuild)

This is more efficient than rebuilding when adding a few vectors. For bulk additions, consider using add_vectors or build.

pub fn add_vectors( &mut self, embeddings: &HashMap<String, Vec<f32>>, ) -> Result<()>

Add multiple vectors to the index incrementally

More efficient than calling add_vector multiple times.

pub fn remove_vector(&mut self, entity_id: &str) -> Result<()>

Remove a vector from the index

pub fn remove_vectors(&mut self, entity_ids: &[&str]) -> Result<()>

Remove multiple vectors from the index

pub fn update_vector( &mut self, entity_id: &str, new_embedding: Vec<f32>, ) -> Result<()>

Update an existing vector in the index

pub fn clear(&mut self)

Clear all vectors from the index

pub fn len(&self) -> usize

Get the number of vectors in the index

pub fn is_empty(&self) -> bool

Check if the index is empty

pub fn contains(&self, entity_id: &str) -> bool

Check if a vector exists in the index

pub fn get_vector(&self, entity_id: &str) -> Option<&Vec<f32>>

Get a vector from the index

pub fn merge( &mut self, other: &VectorSearchIndex, overwrite_duplicates: bool, ) -> Result<()>

Merge another index into this one

Combines vectors from another index, handling duplicates and dimension checks. By default, duplicates are skipped. Use overwrite_duplicates to update existing vectors.

pub fn merge_multiple( indexes: &[&VectorSearchIndex], ) -> Result<VectorSearchIndex>

Create a new index by merging multiple indexes

This is more efficient than merging sequentially when combining many indexes.

Trait Implementations

impl Clone for VectorSearchIndex

fn clone(&self) -> VectorSearchIndex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for VectorSearchIndex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for VectorSearchIndex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for VectorSearchIndex

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.