mentedb 0.41.0

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

//! A memory stored again under an id the vector index has seen before must be
//! found by its new vector: after a forget, after an in place edit, after a
//! re embed, and after a reopen.

use mentedb::MenteDb;
use mentedb_core::MemoryNode;
use mentedb_core::memory::MemoryType;
use mentedb_core::types::{AgentId, MemoryId};
use mentedb_embedding::HashEmbeddingProvider;

fn node(agent: AgentId, content: &str, embedding: Vec<f32>) -> MemoryNode {
    MemoryNode::new(agent, MemoryType::Semantic, content.to_string(), embedding)
}

fn axis(i: usize) -> Vec<f32> {
    let mut v = vec![0.0; 8];
    v[i] = 1.0;
    v
}

fn top(db: &MenteDb, q: &[f32]) -> Option<MemoryId> {
    db.recall_similar(q, 1).unwrap().first().map(|h| h.0)
}

/// A few unrelated memories so the index is a graph, not a single node.
fn store_neighbours(db: &MenteDb, agent: AgentId) {
    for (i, text) in ["alpha notes", "bravo notes", "charlie notes"]
        .iter()
        .enumerate()
    {
        db.store(node(agent, text, axis(i + 4))).unwrap();
    }
}

#[test]
fn store_after_forget_with_the_same_id_is_recalled() {
    let dir = tempfile::tempdir().unwrap();
    let agent = AgentId::new();
    let db = MenteDb::open(dir.path()).unwrap();
    store_neighbours(&db, agent);

    let original = node(agent, "the deploy runs on jenkins", axis(0));
    let id = original.id;
    db.store(original).unwrap();
    assert_eq!(top(&db, &axis(0)), Some(id));

    // The edit flow: forget, then store the edited memory under the same id.
    db.forget(id).unwrap();
    assert_ne!(top(&db, &axis(0)), Some(id));
    let mut edited = node(agent, "the deploy runs on github actions", axis(1));
    edited.id = id;
    db.store(edited).unwrap();

    assert_eq!(top(&db, &axis(1)), Some(id), "found by the edited vector");
    assert_eq!(
        db.get_memory(id).unwrap().content,
        "the deploy runs on github actions"
    );
    db.close().unwrap();

    // Still found after a reopen, with the edited content.
    let db = MenteDb::open(dir.path()).unwrap();
    assert_eq!(top(&db, &axis(1)), Some(id), "found after reopen");
    assert_eq!(
        db.get_memory(id).unwrap().content,
        "the deploy runs on github actions"
    );
    db.close().unwrap();
}

#[test]
fn restore_of_a_live_id_replaces_its_vector() {
    let dir = tempfile::tempdir().unwrap();
    let agent = AgentId::new();
    let db = MenteDb::open(dir.path()).unwrap();
    store_neighbours(&db, agent);

    let original = node(agent, "standup is at nine", axis(0));
    let id = original.id;
    db.store(original).unwrap();

    let mut edited = node(agent, "standup moved to ten thirty", axis(2));
    edited.id = id;
    db.store(edited).unwrap();

    assert_eq!(top(&db, &axis(2)), Some(id), "found by the new vector");
    assert_ne!(top(&db, &axis(0)), Some(id), "old vector no longer indexed");
    let hits = db.recall_similar(&axis(2), 10).unwrap();
    assert_eq!(hits.iter().filter(|h| h.0 == id).count(), 1, "listed once");
    db.close().unwrap();

    let db = MenteDb::open(dir.path()).unwrap();
    assert_eq!(top(&db, &axis(2)), Some(id), "found after reopen");
    db.close().unwrap();
}

#[test]
fn reembed_of_an_indexed_memory_keeps_it_searchable() {
    // The memory already has an indexed vector at an old dimension. Re
    // embedding tombstones that vector and indexes the new one under the
    // same id, which used to fail as a duplicate id and leave the memory out
    // of vector search.
    let dir = tempfile::tempdir().unwrap();
    let agent = AgentId::new();
    let m = node(agent, "the deploy runs on github actions", vec![0.5; 4]);
    let id = m.id;
    {
        let db = MenteDb::open(dir.path()).unwrap();
        db.store(m).unwrap();
        assert_eq!(top(&db, &[0.5; 4]), Some(id));
        db.close().unwrap();
    }

    let db =
        MenteDb::open_with_embedder(dir.path(), Box::new(HashEmbeddingProvider::new(16))).unwrap();
    assert_eq!(db.reembed_all().unwrap(), 1);
    assert_eq!(db.get_memory(id).unwrap().embedding.len(), 16);

    let q = db
        .embed_text("the deploy runs on github actions")
        .unwrap()
        .unwrap();
    assert_eq!(top(&db, &q), Some(id), "re embedded memory is recalled");
    db.close().unwrap();

    let db =
        MenteDb::open_with_embedder(dir.path(), Box::new(HashEmbeddingProvider::new(16))).unwrap();
    assert_eq!(top(&db, &q), Some(id), "still recalled after reopen");
    db.close().unwrap();
}

#[test]
fn rebuild_indexes_keeps_every_memory_once() {
    let dir = tempfile::tempdir().unwrap();
    let agent = AgentId::new();
    let db = MenteDb::open(dir.path()).unwrap();
    store_neighbours(&db, agent);
    let m = node(agent, "on call rotation is weekly", axis(0));
    let id = m.id;
    db.store(m).unwrap();

    db.rebuild_indexes().unwrap();
    db.rebuild_indexes().unwrap();
    let hits = db.recall_similar(&axis(0), 10).unwrap();
    assert_eq!(hits.len(), 4, "no memory listed twice");
    assert_eq!(hits[0].0, id);
    db.close().unwrap();
}