Struct EntityResolver 

pub struct EntityResolver<'a> { /* private fields */ }

Implementations

impl<'a> EntityResolver<'a>

pub fn new(store: &'a GraphStore) -> Self

pub fn with_embedding_store(self, store: &'a Arc<EmbeddingStore>) -> Self

pub fn with_provider(self, provider: &'a AnyProvider) -> Self

pub fn with_thresholds(self, similarity: f32, ambiguous: f32) -> Self

pub fn fallback_count(&self) -> Arc<AtomicU64>

Shared fallback counter — tests can clone this Arc to inspect the value.

pub async fn resolve( &self, name: &str, entity_type: &str, summary: Option<&str>, ) -> Result<(i64, ResolutionOutcome), MemoryError>

Resolve an extracted entity using the alias-first canonicalization pipeline.

Pipeline:

1. Normalize: trim, lowercase, strip control chars, truncate to 512 bytes.
2. Parse entity type (fallback to Concept on unknown).
3. Alias lookup: search graph_entity_aliases by normalized name + entity_type. If found, touch last_seen_at and return the existing entity id.
4. Canonical name lookup: search graph_entities by canonical_name + entity_type. If found, touch last_seen_at and return the existing entity id.
5. When embedding_store and provider are configured, performs embedding-based fuzzy matching: cosine similarity search (Qdrant), LLM disambiguation for ambiguous range, merge or create based on result. Failures degrade gracefully to step 6.
6. Create: upsert new entity with canonical_name = normalized name.
7. Register the normalized form (and original trimmed form if different) as aliases.

Errors

Returns an error if the entity name is empty after normalization, or if a DB operation fails.

pub async fn resolve_batch( &self, entities: &[ExtractedEntity], ) -> Result<Vec<(i64, ResolutionOutcome)>, MemoryError>

Resolve a batch of extracted entities concurrently.

Returns a Vec of (entity_id, ResolutionOutcome) in the same order as input.

Errors

Returns an error if any DB operation fails.

Panics

Panics if an internal stream collection bug causes a result index to be missing. This indicates a programming error and should never occur in correct usage.

pub async fn resolve_edge( &self, source_id: i64, target_id: i64, relation: &str, fact: &str, confidence: f32, episode_id: Option<MessageId>, ) -> Result<Option<i64>, MemoryError>

Resolve an extracted edge: deduplicate or supersede existing edges.

• If an active edge with the same direction and relation exists with an identical fact, returns None (deduplicated).
• If an active edge with the same direction and relation exists with a different fact, invalidates the old edge and inserts the new one, returning Some(new_id).
• If no matching edge exists, inserts a new edge and returns Some(new_id).

Relation and fact strings are sanitized (control chars stripped, length-capped).

Errors

Returns an error if any database operation fails.

pub async fn resolve_edge_typed( &self, source_id: i64, target_id: i64, relation: &str, fact: &str, confidence: f32, episode_id: Option<MessageId>, edge_type: EdgeType, ) -> Result<Option<i64>, MemoryError>

Resolve a typed edge: deduplicate or supersede existing edges of the same type.

Identical to [resolve_edge] but includes edge_type in the matching key. An active edge with the same (source, target, relation, edge_type) and identical fact returns None; same relation+type with different fact is superseded.

This ensures that different MAGMA edge types for the same entity pair are stored independently (critic mitigation: dedup key includes edge_type).

Errors

Returns an error if any database operation fails.