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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
package storage
import (
"elefant/models"
"fmt"
"log"
"log/slog"
"os"
"testing"
"time"
sqlite_vec "github.com/asg017/sqlite-vec-go-bindings/ncruces"
_ "github.com/glebarez/go-sqlite"
"github.com/jmoiron/sqlx"
"github.com/ncruces/go-sqlite3"
)
func TestMemories(t *testing.T) {
db, err := sqlx.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("Failed to open SQLite in-memory database: %v", err)
}
defer db.Close()
_, err = db.Exec(`
CREATE TABLE IF NOT EXISTS memories (
agent TEXT NOT NULL,
topic TEXT NOT NULL,
mind TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (agent, topic)
);`)
if err != nil {
t.Fatalf("Failed to create chat table: %v", err)
}
provider := ProviderSQL{
db: db,
logger: slog.New(slog.NewJSONHandler(os.Stdout, nil)),
}
// Create a sample memory for testing
sampleMemory := models.Memory{
Agent: "testAgent",
Topic: "testTopic",
Mind: "testMind",
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
sampleMemoryRewrite := models.Memory{
Agent: "testAgent",
Topic: "testTopic",
Mind: "same topic, new mind",
}
cases := []struct {
memories []models.Memory
}{
{memories: []models.Memory{sampleMemory, sampleMemoryRewrite}},
}
for i, tc := range cases {
t.Run(fmt.Sprintf("run_%d", i), func(t *testing.T) {
// Recall topics: get no rows
topics, err := provider.RecallTopics(tc.memories[0].Agent)
if err != nil {
t.Fatalf("Failed to recall topics: %v", err)
}
if len(topics) != 0 {
t.Fatalf("Expected no topics, got: %v", topics)
}
// Memorise
_, err = provider.Memorise(&tc.memories[0])
if err != nil {
t.Fatalf("Failed to memorise: %v", err)
}
// Recall topics: has topics
topics, err = provider.RecallTopics(tc.memories[0].Agent)
if err != nil {
t.Fatalf("Failed to recall topics: %v", err)
}
if len(topics) == 0 {
t.Fatalf("Expected topics, got none")
}
// Recall
content, err := provider.Recall(tc.memories[0].Agent, tc.memories[0].Topic)
if err != nil {
t.Fatalf("Failed to recall: %v", err)
}
if content != tc.memories[0].Mind {
t.Fatalf("Expected content: %v, got: %v", tc.memories[0].Mind, content)
}
// rewrite mind of same agent-topic
newMem, err := provider.Memorise(&tc.memories[1])
if err != nil {
t.Fatalf("Failed to memorise: %v", err)
}
if newMem.Mind == tc.memories[0].Mind {
t.Fatalf("Failed to change mind: %v", newMem.Mind)
}
})
}
}
func TestChatHistory(t *testing.T) {
// Create an in-memory SQLite database
db, err := sqlx.Open("sqlite", ":memory:")
if err != nil {
t.Fatalf("Failed to open SQLite in-memory database: %v", err)
}
defer db.Close()
// Create the chat table
_, err = db.Exec(`
CREATE TABLE chats (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
msgs TEXT NOT NULL,
agent TEXT NOT NULL,
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);`)
if err != nil {
t.Fatalf("Failed to create chat table: %v", err)
}
// Initialize the ProviderSQL struct
provider := ProviderSQL{db: db}
// List chats (should be empty)
chats, err := provider.ListChats()
if err != nil {
t.Fatalf("Failed to list chats: %v", err)
}
if len(chats) != 0 {
t.Errorf("Expected 0 chats, got %d", len(chats))
}
// Upsert a chat
chat := &models.Chat{
ID: 1,
Name: "Test Chat",
Msgs: "Hello World",
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
}
updatedChat, err := provider.UpsertChat(chat)
if err != nil {
t.Fatalf("Failed to upsert chat: %v", err)
}
if updatedChat == nil {
t.Errorf("Expected non-nil chat after upsert")
}
// Get chat by ID
fetchedChat, err := provider.GetChatByID(chat.ID)
if err != nil {
t.Fatalf("Failed to get chat by ID: %v", err)
}
if fetchedChat == nil {
t.Errorf("Expected non-nil chat after get")
}
if fetchedChat.Name != chat.Name {
t.Errorf("Expected chat name %s, got %s", chat.Name, fetchedChat.Name)
}
// List chats (should contain the upserted chat)
chats, err = provider.ListChats()
if err != nil {
t.Fatalf("Failed to list chats: %v", err)
}
if len(chats) != 1 {
t.Errorf("Expected 1 chat, got %d", len(chats))
}
// Remove chat
err = provider.RemoveChat(chat.ID)
if err != nil {
t.Fatalf("Failed to remove chat: %v", err)
}
// List chats (should be empty again)
chats, err = provider.ListChats()
if err != nil {
t.Fatalf("Failed to list chats: %v", err)
}
if len(chats) != 0 {
t.Errorf("Expected 0 chats, got %d", len(chats))
}
}
func TestVecTable(t *testing.T) {
// healthcheck
db, err := sqlite3.Open(":memory:")
if err != nil {
t.Fatal(err)
}
stmt, _, err := db.Prepare(`SELECT sqlite_version(), vec_version()`)
if err != nil {
t.Fatal(err)
}
stmt.Step()
log.Printf("sqlite_version=%s, vec_version=%s\n", stmt.ColumnText(0), stmt.ColumnText(1))
stmt.Close()
// migration
err = db.Exec("CREATE VIRTUAL TABLE vec_items USING vec0(embedding float[4], chat_name TEXT NOT NULL)")
if err != nil {
t.Fatal(err)
}
// data prep and insert
items := map[int][]float32{
1: {0.1, 0.1, 0.1, 0.1},
2: {0.2, 0.2, 0.2, 0.2},
3: {0.3, 0.3, 0.3, 0.3},
4: {0.4, 0.4, 0.4, 0.4},
5: {0.5, 0.5, 0.5, 0.5},
}
q := []float32{0.28, 0.3, 0.3, 0.3}
stmt, _, err = db.Prepare("INSERT INTO vec_items(rowid, embedding, chat_name) VALUES (?, ?, ?)")
if err != nil {
t.Fatal(err)
}
for id, values := range items {
v, err := sqlite_vec.SerializeFloat32(values)
if err != nil {
t.Fatal(err)
}
stmt.BindInt(1, id)
stmt.BindBlob(2, v)
stmt.BindText(3, "some_chat")
err = stmt.Exec()
if err != nil {
t.Fatal(err)
}
stmt.Reset()
}
stmt.Close()
// select | vec search
stmt, _, err = db.Prepare(`
SELECT
rowid,
distance,
embedding
FROM vec_items
WHERE embedding MATCH ?
ORDER BY distance
LIMIT 3
`)
if err != nil {
t.Fatal(err)
}
query, err := sqlite_vec.SerializeFloat32(q)
if err != nil {
t.Fatal(err)
}
stmt.BindBlob(1, query)
for stmt.Step() {
rowid := stmt.ColumnInt64(0)
distance := stmt.ColumnFloat(1)
emb := stmt.ColumnRawText(2)
floats := decodeUnsafe(emb)
log.Printf("rowid=%d, distance=%f, floats=%v\n", rowid, distance, floats)
}
if err := stmt.Err(); err != nil {
t.Fatal(err)
}
err = stmt.Close()
if err != nil {
t.Fatal(err)
}
err = db.Close()
if err != nil {
t.Fatal(err)
}
}
|
