mindcore 0.2.0

Pluggable, feature-gated memory engine for AI agent applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::collections::HashMap;

use crate::error::Result;
use crate::memory::RelationType;
use crate::traits::{MemoryMeta, ScoredResult};

/// Post-write hook: when a new memory is stored, optionally update
/// related existing memories (their metadata, keywords, links).
pub trait EvolutionStrategy: Send + Sync {
    /// Given a newly stored memory and its top-k similar existing memories,
    /// return updates to apply to existing memories.
    fn evolve(
        &self,
        new_memory: &MemoryMeta,
        similar: &[ScoredResult],
    ) -> Result<Vec<EvolutionAction>>;
}

/// Actions that memory evolution can take on existing memories.
#[derive(Debug, Clone)]
pub enum EvolutionAction {
    /// Update metadata on an existing memory.
    UpdateMetadata {
        target_id: i64,
        metadata: HashMap<String, String>,
    },
    /// Create a relationship between memories.
    Relate {
        source_id: i64,
        target_id: i64,
        relation: RelationType,
    },
    /// No changes needed.
    Noop,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::traits::MemoryType;
    use chrono::Utc;

    struct NoopEvolution;

    impl EvolutionStrategy for NoopEvolution {
        fn evolve(&self, _new: &MemoryMeta, _similar: &[ScoredResult]) -> Result<Vec<EvolutionAction>> {
            Ok(vec![EvolutionAction::Noop])
        }
    }

    #[test]
    fn trait_object_works() {
        let strategy: Box<dyn EvolutionStrategy> = Box::new(NoopEvolution);
        let meta = MemoryMeta {
            id: Some(1),
            searchable_text: "test".into(),
            memory_type: MemoryType::Semantic,
            importance: 5,
            category: None,
            created_at: Utc::now(),
            metadata: Default::default(),
        };
        let result = strategy.evolve(&meta, &[]).expect("evolve");
        assert!(matches!(result[0], EvolutionAction::Noop));
    }
}