Struct EmbeddingIndex 

pub struct EmbeddingIndex<P> { /* private fields */ }

Implementations

impl<P: Projection> EmbeddingIndex<P>

pub fn builder(projection: P) -> EmbeddingIndexBuilder<P>

pub fn insert(&mut self, id: impl Into<String>, embedding: &Embedding)

pub fn insert_with_radius( &mut self, id: impl Into<String>, embedding: &Embedding, r: f64, )

Insert with an explicit radial value, overriding the projection’s RadialStrategy. The angular coordinates (theta, phi) are still determined by the projection. Use this for metadata-driven radius: recency scores, importance weights, etc.

pub fn search_nearest( &self, query: &Embedding, k: usize, ) -> Vec<NearestResult<EmbeddingItem>>

Find the k embeddings whose projected directions are closest to the query.

pub fn search_similar( &self, query: &Embedding, min_cosine_similarity: f64, ) -> SpatialQueryResult<EmbeddingItem>

Find all embeddings whose projected cosine similarity to the query is at least min_cosine_similarity.

Internally maps cos(sim) → angular distance and uses within_distance.

pub fn search_region( &self, region: &Region, ) -> SpatialQueryResult<EmbeddingItem>

pub fn remove(&mut self, id: &str) -> Option<EmbeddingItem>

pub fn get(&self, id: &str) -> Option<&EmbeddingItem>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn projection(&self) -> &P

pub fn all_items(&self) -> Vec<&EmbeddingItem>

pub fn concept_path( &self, source_id: &str, target_id: &str, k: usize, ) -> Option<ConceptPath>

Find the shortest semantic path between two items through a k-NN graph.

Builds a k-nearest-neighbor graph over all indexed embeddings, then runs Dijkstra’s algorithm weighted by angular distance. The resulting path traces the chain of closest intermediate concepts connecting the source to the target.

The k-NN graph is memoized per k: the first call at a given k builds it in O(n · log n · k) (index-assisted) and every subsequent call reuses the snapshot until the index mutates. Dijkstra itself is O((n + E) · log n) via a binary heap.

pub fn concept_path_bridged( &self, source_id: &str, target_id: &str, k: usize, categories: &HashMap<&str, usize>, bridge_strengths: &HashMap<(usize, usize), (f64, BridgeClassification)>, ) -> Option<ConceptPath>

Find a semantic path that prefers hops with strong conceptual bridges.

Like concept_path, but when a hop crosses a category boundary, the edge weight is penalized based on the bridge’s classification:

• BridgeClassification::Genuine: angular_dist / (strength + 0.1)

• BridgeClassification::Weak: angular_dist / (strength + 0.01)

• BridgeClassification::OverlapArtifact: angular_dist * 2.0 (shared-territory bridges are actively discouraged — they aren’t real connectors).

• categories: maps item ID → category index.

• bridge_strengths: maps (cat_a, cat_b) → (max_bridge_strength, classification). Missing entries are treated as a weak no-bridge (strength 0, Weak).

Same-category hops use raw angular distance.