mem0's delete kept the deleted text in memory_history, and fact extraction keeps the last messages of each scope in the same file. forget now purges the memory's history rows, and forgetting a whole scope also drops the conversation messages mem0 kept for it.
239 lines
10 KiB
TypeScript
239 lines
10 KiB
TypeScript
import fs from 'node:fs';
|
|
import http from 'node:http';
|
|
import type { AddressInfo } from 'node:net';
|
|
import os from 'node:os';
|
|
import path from 'node:path';
|
|
import { afterEach, describe, expect, it, vi } from 'vitest';
|
|
import { PERSONAL_SCOPE, workspaceScope } from '@waggle/memory-contract';
|
|
import Database from 'better-sqlite3';
|
|
import { createMem0MemoryStore, createWordEmbedder, EmbedderMismatchError, type TextEmbedder } from '../src/index.js';
|
|
import { describeMemoryStoreContract } from '../../memory-contract/tests/contract-suite.js';
|
|
|
|
/** Deterministic bag-of-words embedder: texts that share words get similar vectors. */
|
|
const wordEmbedder: TextEmbedder = {
|
|
dimensions: 256,
|
|
async embed(text) {
|
|
const vector = new Array<number>(256).fill(0);
|
|
for (const word of text.toLowerCase().match(/[\p{L}\p{N}]{2,}/gu) ?? []) {
|
|
let hash = 2166136261;
|
|
for (const char of word) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619);
|
|
vector[Math.abs(hash) % 256] += 1;
|
|
}
|
|
const norm = Math.hypot(...vector) || 1;
|
|
return vector.map((value) => value / norm);
|
|
},
|
|
async embedBatch(texts) {
|
|
return Promise.all(texts.map((text) => this.embed(text)));
|
|
},
|
|
};
|
|
|
|
const tempDirs: string[] = [];
|
|
function tempDir(): string {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-mem0-'));
|
|
tempDirs.push(dir);
|
|
return dir;
|
|
}
|
|
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
describeMemoryStoreContract('mem0 store', () =>
|
|
createMem0MemoryStore({ directory: tempDir(), embedder: wordEmbedder }));
|
|
|
|
describe('mem0 store — local behaviour', () => {
|
|
it('keeps memories across a restart', async () => {
|
|
const directory = tempDir();
|
|
const first = await createMem0MemoryStore({ directory, embedder: wordEmbedder });
|
|
const [change] = await first.remember({ scope: PERSONAL_SCOPE, text: 'My sister lives in Zagreb' });
|
|
await first.close();
|
|
|
|
const second = await createMem0MemoryStore({ directory, embedder: wordEmbedder });
|
|
expect(await second.get(change.record.id)).toMatchObject({ text: 'My sister lives in Zagreb' });
|
|
expect(await second.count({ scopes: [PERSONAL_SCOPE] })).toBe(1);
|
|
await second.close();
|
|
expect(fs.existsSync(path.join(directory, 'vectors.db'))).toBe(true);
|
|
expect(fs.existsSync(path.join(directory, 'history.db'))).toBe(true);
|
|
});
|
|
|
|
it('sends nothing to mem0 telemetry and stays out of ~/.mem0', async () => {
|
|
const fetchSpy = vi.spyOn(globalThis, 'fetch');
|
|
const store = await createMem0MemoryStore({ directory: tempDir(), embedder: wordEmbedder });
|
|
const [change] = await store.remember({ scope: PERSONAL_SCOPE, text: 'Prefers morning meetings' });
|
|
await store.search('meetings', { scopes: [PERSONAL_SCOPE] });
|
|
await store.list({ scopes: [PERSONAL_SCOPE] });
|
|
await store.update(change.record.id, { importance: 'important' });
|
|
await store.forget(change.record.id);
|
|
await store.close();
|
|
expect(fetchSpy).not.toHaveBeenCalled();
|
|
expect(fs.existsSync(path.join(os.homedir(), '.mem0'))).toBe(false);
|
|
});
|
|
|
|
it('offers extraction only when a model is configured', async () => {
|
|
const store = await createMem0MemoryStore({ directory: tempDir(), embedder: wordEmbedder });
|
|
expect(store.capabilities).toMatchObject({ extraction: false, semanticSearch: true, history: true });
|
|
await store.close();
|
|
});
|
|
|
|
it('extracts facts from a conversation with the configured model', async () => {
|
|
const requests: Array<{ model: string; response_format?: { type: string } }> = [];
|
|
const server = http.createServer((req, res) => {
|
|
let body = '';
|
|
req.on('data', (chunk) => { body += chunk; });
|
|
req.on('end', () => {
|
|
requests.push(JSON.parse(body));
|
|
res.setHeader('Content-Type', 'application/json');
|
|
res.end(JSON.stringify({
|
|
id: 'chatcmpl-test',
|
|
object: 'chat.completion',
|
|
created: 0,
|
|
model: 'test-model',
|
|
choices: [{
|
|
index: 0,
|
|
finish_reason: 'stop',
|
|
message: { role: 'assistant', content: JSON.stringify({ memory: [{ text: 'Lives in Novi Sad' }] }) },
|
|
}],
|
|
usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
|
|
}));
|
|
});
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const { port } = server.address() as AddressInfo;
|
|
try {
|
|
const store = await createMem0MemoryStore({
|
|
directory: tempDir(),
|
|
embedder: wordEmbedder,
|
|
extractionModel: { baseURL: `http://127.0.0.1:${port}/v1`, apiKey: 'test-key', model: 'test-model' },
|
|
});
|
|
expect(store.capabilities.extraction).toBe(true);
|
|
const changes = await store.remember({
|
|
scope: PERSONAL_SCOPE,
|
|
conversation: [
|
|
{ role: 'user', content: 'I moved to Novi Sad last year.' },
|
|
{ role: 'assistant', content: 'Noted.' },
|
|
],
|
|
kind: 'profile',
|
|
origin: 'chat',
|
|
});
|
|
expect(changes).toHaveLength(1);
|
|
expect(changes[0]).toMatchObject({
|
|
event: 'added',
|
|
record: { text: 'Lives in Novi Sad', scope: PERSONAL_SCOPE, kind: 'profile', origin: 'chat' },
|
|
});
|
|
expect(requests[0]).toMatchObject({ model: 'test-model', response_format: { type: 'json_object' } });
|
|
await store.close();
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
it('reads a model function on every extraction', async () => {
|
|
const models: string[] = [];
|
|
const server = http.createServer((req, res) => {
|
|
let body = '';
|
|
req.on('data', (chunk) => { body += chunk; });
|
|
req.on('end', () => {
|
|
models.push((JSON.parse(body) as { model: string }).model);
|
|
res.setHeader('Content-Type', 'application/json');
|
|
res.end(JSON.stringify({
|
|
id: 'chatcmpl-test',
|
|
object: 'chat.completion',
|
|
created: 0,
|
|
model: 'any',
|
|
choices: [{ index: 0, finish_reason: 'stop', message: { role: 'assistant', content: '{"memory":[]}' } }],
|
|
usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
|
|
}));
|
|
});
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const { port } = server.address() as AddressInfo;
|
|
try {
|
|
let current = 'first-model';
|
|
const store = await createMem0MemoryStore({
|
|
directory: tempDir(),
|
|
embedder: wordEmbedder,
|
|
extractionModel: { baseURL: `http://127.0.0.1:${port}/v1`, apiKey: 'test-key', model: () => current },
|
|
});
|
|
const conversation = [{ role: 'user' as const, content: 'I like tea.' }];
|
|
await store.remember({ scope: PERSONAL_SCOPE, conversation });
|
|
current = 'second-model';
|
|
await store.remember({ scope: PERSONAL_SCOPE, conversation });
|
|
expect(models).toEqual(['first-model', 'second-model']);
|
|
await store.close();
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
it('erases the text of a forgotten memory from the history database', async () => {
|
|
const directory = tempDir();
|
|
const store = await createMem0MemoryStore({ directory, embedder: wordEmbedder });
|
|
const [change] = await store.remember({ scope: PERSONAL_SCOPE, text: 'My passport number is X1234' });
|
|
await store.update(change!.record.id, { text: 'My passport number is Y5678' });
|
|
expect(await store.forget(change!.record.id)).toBe(true);
|
|
expect(await store.history(change!.record.id)).toEqual([]);
|
|
const db = new Database(path.join(directory, 'history.db'), { readonly: true });
|
|
const leftovers = db.prepare("SELECT COUNT(*) AS n FROM memory_history WHERE coalesce(previous_value, '') || coalesce(new_value, '') LIKE '%passport%'").get() as { n: number };
|
|
db.close();
|
|
expect(leftovers.n).toBe(0);
|
|
await store.close();
|
|
});
|
|
|
|
it('erases the conversation mem0 kept for a scope when the whole scope is forgotten', async () => {
|
|
const server = http.createServer((req, res) => {
|
|
req.resume();
|
|
req.on('end', () => {
|
|
res.setHeader('Content-Type', 'application/json');
|
|
res.end(JSON.stringify({
|
|
id: 'chatcmpl-test', object: 'chat.completion', created: 0, model: 'm',
|
|
choices: [{ index: 0, finish_reason: 'stop', message: { role: 'assistant', content: '{"memory":[]}' } }],
|
|
usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 },
|
|
}));
|
|
});
|
|
});
|
|
await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
|
|
const { port } = server.address() as AddressInfo;
|
|
try {
|
|
const directory = tempDir();
|
|
const store = await createMem0MemoryStore({
|
|
directory,
|
|
embedder: wordEmbedder,
|
|
extractionModel: { baseURL: `http://127.0.0.1:${port}/v1`, apiKey: 'k', model: 'm' },
|
|
});
|
|
const scope = workspaceScope('ws&1');
|
|
await store.remember({ scope, conversation: [{ role: 'user', content: 'Our launch is in May.' }] });
|
|
const count = () => {
|
|
const db = new Database(path.join(directory, 'history.db'), { readonly: true });
|
|
const row = db.prepare('SELECT COUNT(*) AS n FROM messages').get() as { n: number };
|
|
db.close();
|
|
return row.n;
|
|
};
|
|
expect(count()).toBeGreaterThan(0);
|
|
await store.forgetMatching({ scopes: [scope] });
|
|
expect(count()).toBe(0);
|
|
await store.close();
|
|
} finally {
|
|
await new Promise<void>((resolve) => server.close(() => resolve()));
|
|
}
|
|
});
|
|
|
|
it('refuses to open a store with a different embedder', async () => {
|
|
const directory = tempDir();
|
|
const first = await createMem0MemoryStore({ directory, embedder: { ...wordEmbedder, id: 'model-a' } });
|
|
await first.close();
|
|
await expect(createMem0MemoryStore({ directory, embedder: { ...wordEmbedder, id: 'model-b' } }))
|
|
.rejects.toThrow(EmbedderMismatchError);
|
|
const again = await createMem0MemoryStore({ directory, embedder: { ...wordEmbedder, id: 'model-a' } });
|
|
await again.close();
|
|
});
|
|
|
|
it('ships a word embedder that ranks shared words higher', async () => {
|
|
const embedder = createWordEmbedder();
|
|
const [tea, coffee, teaAgain] = await embedder.embedBatch(['green tea', 'black coffee', 'tea']);
|
|
const dot = (a: ArrayLike<number>, b: ArrayLike<number>) =>
|
|
Array.from(a).reduce((sum, value, i) => sum + value * b[i]!, 0);
|
|
expect(embedder.dimensions).toBe(256);
|
|
expect(dot(tea!, teaAgain!)).toBeGreaterThan(dot(coffee!, teaAgain!));
|
|
});
|
|
});
|