elizaos-plugin-memory 2.0.0

Memory management plugin for ElizaOS (Rust)
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

#![allow(missing_docs)]

use serde_json::json;

use crate::error::Result;
use crate::types::*;

/// Provide memory context from stored long-term memories
pub fn get_memory_context(memories: &[serde_json::Value]) -> Result<ProviderResult> {
    let plugin_memories: Vec<&serde_json::Value> = memories
        .iter()
        .filter(|m| {
            m.get("source")
                .and_then(|s| s.as_str())
                .map(|s| s == memory_source())
                .unwrap_or(false)
        })
        .collect();

    if plugin_memories.is_empty() {
        return Ok(ProviderResult::new("No stored memories available"));
    }

    let mut parsed_entries: Vec<(ParsedMemory, String, i64)> = Vec::new();

    for mem in &plugin_memories {
        let text = mem.get("text").and_then(|t| t.as_str()).unwrap_or("");
        let id = mem
            .get("id")
            .and_then(|i| i.as_str())
            .unwrap_or("")
            .to_string();
        let created_at = mem.get("createdAt").and_then(|c| c.as_i64()).unwrap_or(0);

        let parsed = decode_memory_text(text);
        parsed_entries.push((parsed, id, created_at));
    }

    // Sort by importance (desc) then recency (desc)
    parsed_entries.sort_by(|a, b| {
        let imp_cmp = (b.0.importance as u8).cmp(&(a.0.importance as u8));
        if imp_cmp != std::cmp::Ordering::Equal {
            return imp_cmp;
        }
        b.2.cmp(&a.2)
    });

    parsed_entries.truncate(20);

    let memory_list: Vec<String> = parsed_entries
        .iter()
        .map(|(parsed, _id, _created_at)| {
            let tag_str = if parsed.tags.is_empty() {
                String::new()
            } else {
                format!(" [{}]", parsed.tags.join(", "))
            };
            format!("- ({}) {}{}", parsed.importance, parsed.content, tag_str)
        })
        .collect();

    let count = parsed_entries.len();
    let text = format!("Stored Memories ({}):\n{}", count, memory_list.join("\n"));

    Ok(ProviderResult::with_data(
        text,
        json!({
            "memories": parsed_entries.iter().map(|(p, id, _)| json!({
                "id": id,
                "content": p.content,
                "tags": p.tags,
                "importance": p.importance as u8,
            })).collect::<Vec<_>>(),
            "count": count,
        }),
    ))
}