synaptic-memory 0.4.0

Conversation memory: Buffer, Window, Summary, SummaryBuffer, TokenBuffer strategies
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::sync::Arc;

use synaptic_core::{ChatResponse, MemoryStore, Message};
use synaptic_memory::{ChatMessageHistory, ConversationSummaryBufferMemory};

fn new_store() -> Arc<ChatMessageHistory> {
    Arc::new(ChatMessageHistory::new(Arc::new(
        synaptic_store::InMemoryStore::new(),
    )))
}
use synaptic_models::ScriptedChatModel;

#[tokio::test]
async fn under_limit_no_summary() {
    let model = Arc::new(ScriptedChatModel::new(vec![]));
    let store = new_store();
    // max_token_limit high enough that no summarization happens
    let memory = ConversationSummaryBufferMemory::new(store, model, 1000);

    memory.append("s1", Message::human("hello")).await.unwrap();
    memory.append("s1", Message::ai("hi there")).await.unwrap();

    let loaded = memory.load("s1").await.unwrap();
    assert_eq!(loaded.len(), 2);
    assert_eq!(loaded[0].content(), "hello");
    assert_eq!(loaded[1].content(), "hi there");
}

#[tokio::test]
async fn over_limit_triggers_summary() {
    // Provide multiple summary responses in case multiple summarizations occur
    let model = Arc::new(ScriptedChatModel::new(vec![
        ChatResponse {
            message: Message::ai("User greeted and chatted about weather."),
            usage: None,
        },
        ChatResponse {
            message: Message::ai("User greeted and chatted about weather more."),
            usage: None,
        },
        ChatResponse {
            message: Message::ai("Extended conversation."),
            usage: None,
        },
    ]));

    let store = new_store();
    // Very low token limit to trigger summarization quickly
    let memory = ConversationSummaryBufferMemory::new(store, model, 5);

    memory.append("s1", Message::human("hello")).await.unwrap();
    memory.append("s1", Message::ai("hi there")).await.unwrap();
    memory
        .append("s1", Message::human("how is the weather?"))
        .await
        .unwrap();
    memory
        .append("s1", Message::ai("it is sunny today"))
        .await
        .unwrap();

    let loaded = memory.load("s1").await.unwrap();

    // Should have a summary system message + some recent messages
    assert!(loaded[0].is_system());
    assert!(loaded[0]
        .content()
        .contains("Summary of earlier conversation"));
}

#[tokio::test]
async fn preserves_recent_messages() {
    let model = Arc::new(ScriptedChatModel::new(vec![
        ChatResponse {
            message: Message::ai("Summary of conversation so far."),
            usage: None,
        },
        ChatResponse {
            message: Message::ai("Updated summary."),
            usage: None,
        },
        ChatResponse {
            message: Message::ai("Another summary."),
            usage: None,
        },
    ]));

    let store = new_store();
    let memory = ConversationSummaryBufferMemory::new(store, model, 5);

    memory.append("s1", Message::human("msg1")).await.unwrap();
    memory.append("s1", Message::ai("msg2")).await.unwrap();
    memory.append("s1", Message::human("msg3")).await.unwrap();
    memory.append("s1", Message::ai("msg4")).await.unwrap();

    let loaded = memory.load("s1").await.unwrap();

    // The last message should always be preserved
    let last = loaded.last().unwrap();
    assert!(last.content() == "msg4" || last.content() == "msg3" || loaded.len() > 1);
}

#[tokio::test]
async fn clear_removes_summary() {
    let model = Arc::new(ScriptedChatModel::new(vec![
        ChatResponse {
            message: Message::ai("A summary."),
            usage: None,
        },
        ChatResponse {
            message: Message::ai("Another summary."),
            usage: None,
        },
        ChatResponse {
            message: Message::ai("Yet another."),
            usage: None,
        },
    ]));

    let store = new_store();
    let memory = ConversationSummaryBufferMemory::new(store, model, 5);

    memory.append("s1", Message::human("a")).await.unwrap();
    memory
        .append("s1", Message::ai("long response here"))
        .await
        .unwrap();
    memory.append("s1", Message::human("b")).await.unwrap();
    memory
        .append("s1", Message::ai("another long response"))
        .await
        .unwrap();

    memory.clear("s1").await.unwrap();
    let loaded = memory.load("s1").await.unwrap();
    assert!(loaded.is_empty());
}