do-memory-core 0.1.34

Core episodic learning system for AI agents with pattern extraction, reward scoring, and dual storage backend
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Procedural memory management
//!
//! Procedural memory stores learned heuristics-as-skills, providing actionable
//! workflows synthesized from past experiences.

mod types;

pub use types::ProceduralMemory;

#[cfg(test)]
mod tests;

use crate::types::TaskContext;
use chrono::Utc;
use uuid::Uuid;

impl ProceduralMemory {
    /// Create a new procedural memory
    pub fn new(
        name: String,
        description: String,
        context: TaskContext,
        steps: Vec<crate::memory::playbook::PlaybookStep>,
    ) -> Self {
        let now = Utc::now();
        Self {
            id: Uuid::new_v4(),
            name,
            description,
            context,
            steps,
            effectiveness: crate::patterns::PatternEffectiveness::default(),
            source_episodes: Vec::new(),
            source_patterns: Vec::new(),
            created_at: now,
            updated_at: now,
        }
    }

    /// Check if this procedural memory is relevant to a given context
    #[must_use]
    pub fn is_relevant_to(&self, query_context: &TaskContext) -> bool {
        // Match on domain
        if self.context.domain == query_context.domain {
            return true;
        }

        // Match on language
        if self.context.language == query_context.language && self.context.language.is_some() {
            return true;
        }

        // Match on tags
        let common_tags: Vec<_> = self
            .context
            .tags
            .iter()
            .filter(|t| query_context.tags.contains(t))
            .collect();

        if !common_tags.is_empty() {
            return true;
        }

        false
    }

    /// Record that this procedural memory was retrieved in a query
    pub fn record_retrieval(&mut self) {
        self.effectiveness.record_retrieval();
        self.updated_at = Utc::now();
    }

    /// Record that this procedural memory was applied with an outcome
    pub fn record_application(&mut self, success: bool, reward_delta: f32) {
        self.effectiveness.record_application(success, reward_delta);
        self.updated_at = Utc::now();
    }

    /// Add a source episode ID
    pub fn add_source_episode(&mut self, episode_id: Uuid) {
        if !self.source_episodes.contains(&episode_id) {
            self.source_episodes.push(episode_id);
            self.updated_at = Utc::now();
        }
    }

    /// Add a source pattern ID
    pub fn add_source_pattern(&mut self, pattern_id: crate::episode::PatternId) {
        if !self.source_patterns.contains(&pattern_id) {
            self.source_patterns.push(pattern_id);
            self.updated_at = Utc::now();
        }
    }
}