mentedb 0.32.2

A purpose-built database engine for AI agent memory
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207

//! Store-time paraphrase dedup for regular memories: reworded copies of the
//! same fact are skipped, while value updates (which share the frame but swap
//! a value token) stay storable so supersession can handle them.

use mentedb::MenteDb;
use mentedb::prelude::*;

fn now_us() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_micros() as u64
}

fn node(agent: AgentId, content: &str, emb: Vec<f32>, at: u64) -> MemoryNode {
    let mut n = MemoryNode::new(agent, MemoryType::Semantic, content.into(), emb);
    n.created_at = at;
    n
}

#[test]
fn paraphrase_is_skipped() {
    let dir = tempfile::tempdir().unwrap();
    let db = MenteDb::open(dir.path()).unwrap();
    let agent = AgentId::new();
    let t = now_us();

    // Same fact, reworded: near-identical embedding, high token overlap.
    let a = node(
        agent,
        "User is building a SaaS app called TaskPilot using Next.js and Supabase",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t,
    );
    let b = node(
        agent,
        "The user is building a SaaS app called TaskPilot using Next.js and Supabase",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t + 1,
    );
    let b_id = b.id;
    db.store(a).unwrap();
    db.store(b).unwrap();

    assert!(
        db.get_memory(b_id).is_err(),
        "a reworded copy of an existing fact must be skipped"
    );
    assert_eq!(db.memory_count(), 1, "only the original survives");
}

#[test]
fn value_update_is_not_swallowed() {
    let dir = tempfile::tempdir().unwrap();
    let db = MenteDb::open(dir.path()).unwrap();
    let agent = AgentId::new();
    let t = now_us();

    // Same frame, different value: token overlap drops below the gate, so the
    // correction stores (and write inference supersedes the old fact).
    let a = node(
        agent,
        "The user's favorite coffee order is a cortado",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t,
    );
    let b = node(
        agent,
        "The user's favorite coffee order is a flat white",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t + 1,
    );
    let b_id = b.id;
    db.store(a).unwrap();
    db.store(b).unwrap();

    assert!(
        db.get_memory(b_id).is_ok(),
        "a value update must store, never be absorbed as a paraphrase"
    );
}

#[test]
fn value_update_invalidates_the_stale_fact() {
    // The reported production bug: "i use next.js for the front end" then
    // "now i use react for the front end" left BOTH facts live, and recall
    // kept answering with the stale one. The value sits mid sentence
    // (wrapped by the shared "for the front end" tail), which the old
    // prefix-only frame test could not see; and even when the rule fired it
    // only created an edge, never invalidating the loser out of recall.
    let dir = tempfile::tempdir().unwrap();
    let db = MenteDb::open(dir.path()).unwrap();
    let agent = AgentId::new();
    let t = now_us();

    let a = node(
        agent,
        "The user uses Next.js for the front end",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t,
    );
    let a_id = a.id;
    let b = node(
        agent,
        "The user uses React for the front end",
        vec![1.0, 0.08, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t + 1,
    );
    let b_id = b.id;
    db.store(a).unwrap();
    db.store(b).unwrap();

    let stale = db.get_memory(a_id).unwrap();
    assert!(
        stale.valid_until.is_some(),
        "the older value must be invalidated so recall stops returning it"
    );
    let fresh = db.get_memory(b_id).unwrap();
    assert!(fresh.valid_until.is_none(), "the newer value stays live");
}

#[test]
fn value_update_resolves_against_store_order() {
    // Async enrichment can store the OLDER turn's fact after the newer one.
    // Resolution follows created_at (the turn's time), not arrival order, so
    // the stale value loses whichever lands last.
    let dir = tempfile::tempdir().unwrap();
    let db = MenteDb::open(dir.path()).unwrap();
    let agent = AgentId::new();
    let t = now_us();

    // The react fact carries the LATER timestamp but stores FIRST.
    let b = node(
        agent,
        "The user uses React for the front end",
        vec![1.0, 0.08, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t + 1,
    );
    let b_id = b.id;
    let a = node(
        agent,
        "The user uses Next.js for the front end",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t,
    );
    let a_id = a.id;
    db.store(b).unwrap();
    db.store(a).unwrap();

    assert!(
        db.get_memory(a_id).unwrap().valid_until.is_some(),
        "the older turn's fact loses even when it stores last"
    );
    assert!(
        db.get_memory(b_id).unwrap().valid_until.is_none(),
        "the newer turn's fact survives arrival order inversion"
    );
}

#[test]
fn cross_owner_is_never_deduped() {
    let dir = tempfile::tempdir().unwrap();
    let db = MenteDb::open(dir.path()).unwrap();
    let t = now_us();

    let content = "The staging environment runs in eu-west-1";
    let emb = vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
    let a = node(AgentId::new(), content, emb.clone(), t);
    let b = node(AgentId::new(), content, emb, t + 1);
    let b_id = b.id;
    db.store(a).unwrap();
    db.store(b).unwrap();

    assert!(
        db.get_memory(b_id).is_ok(),
        "another owner's identical fact is their own memory, never deduped away"
    );
}

#[test]
fn disabled_config_stores_everything() {
    let dir = tempfile::tempdir().unwrap();
    let cfg = mentedb::CognitiveConfig {
        memory_dedup: false,
        ..mentedb::CognitiveConfig::default()
    };
    let db = MenteDb::open_with_config(dir.path(), cfg).unwrap();
    let agent = AgentId::new();
    let t = now_us();

    let a = node(
        agent,
        "User is building a SaaS app called TaskPilot",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t,
    );
    let b = node(
        agent,
        "The user is building a SaaS app called TaskPilot",
        vec![1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
        t + 1,
    );
    let b_id = b.id;
    db.store(a).unwrap();
    db.store(b).unwrap();
    assert!(db.get_memory(b_id).is_ok(), "dedup off means both store");
}