Struct EntityResolver 

pub struct EntityResolver { /* private fields */ }

Disambiguates and resolves entity mentions to canonical entities.

Resolution priority (highest to lowest):

1. Exact match on normalized canonical name.
2. Alias match on any normalized alias.
3. Fuzzy (edit-distance) match if similarity ≥ fuzzy_threshold.
4. Embedding cosine similarity match if score ≥ embedding_threshold.
5. Unresolved.

Implementations

impl EntityResolver

pub fn new(config: ResolverConfig) -> Self

Create a new resolver with the given configuration.

pub fn register_entity(&mut self, entity: CanonicalEntity) -> bool

Register a canonical entity. Returns true if the entity was inserted, false if an entity with the same entity_id already exists (no update).

pub fn resolve(&mut self, mention: EntityMention) -> ResolutionResult

Resolve a single mention to a canonical entity.

pub fn resolve_with_embedding( &mut self, mention: EntityMention, query_embedding: &[f64], ) -> ResolutionResult

Resolve a mention when the caller also supplies a query embedding.

Falls through the same priority chain as resolve but adds an embedding-cosine step before returning Unresolved.

pub fn resolve_batch( &mut self, mentions: Vec<EntityMention>, ) -> Vec<ResolutionResult>

Resolve a batch of mentions, returning one ResolutionResult per mention.

pub fn normalize(text: &str) -> String

Normalize a string: trim, lowercase, collapse interior whitespace runs.

pub fn edit_distance(a: &str, b: &str) -> usize

Classic Levenshtein edit distance between two strings.

pub fn string_similarity(a: &str, b: &str) -> f64

String similarity in [0.0, 1.0]: 1.0 - edit_distance / max_len. Returns 1.0 if both strings are empty.

pub fn cosine_similarity(a: &[f64], b: &[f64]) -> f64

Cosine similarity between two vectors; returns 0.0 for zero-norm inputs.

pub fn find_candidates<'a>( &'a self, mention: &str, n: usize, ) -> Vec<&'a CanonicalEntity>

Return up to n candidate entities ranked by string similarity to mention.

This is an O(|entities|) scan. For very large registries a dedicated inverted-index or BK-tree would be more efficient, but correctness is the priority here.

pub fn entity_count(&self) -> usize

Number of registered canonical entities.

pub fn get_entity(&self, entity_id: &str) -> Option<&CanonicalEntity>

Look up a canonical entity by its stable ID.

pub fn stats(&self) -> &ResolverStats

Current resolution statistics.