Files
waggle-os/packages/memory-mem0/tests/mem0-store.test.ts
shumeiko.it 784ca770b1 refactor(memory): run agent recall, memory tools and the server on the memory contract (P1.5)
- Orchestrator, memory tools, context loader and pattern write-back use a
  MemoryStore and a workspace scope instead of MindDB layers; the knowledge
  graph tools, cognify, memory linker and feedback handler are gone (graph
  hidden in v1, ADR-0002).
- The server opens one mem0 store in <dataDir>/memory/, embedded by the
  in-process model on first use, and extracts facts about the user in the
  background with the model the user chose (memoryExtraction setting).
- Legacy .mind memories are copied into the store once, in the background;
  the legacy files are only read.
- Weaver consolidation, harvest, wiki, memory import, memory lanes, vector
  backfill and index reconciliation are removed; agent runs, loops, sub-agent
  results, connector fetch and the failed-turn capture write through the
  contract. Workspace sessions no longer hold a mind handle.
- FileIndexer and the install audit move to waggle.db; recall date helpers and
  the reranker are copied into core.
- The CLI REPL opens the same memory store.
2026-10-24 11:56:26 +02:00

176 lines
7.3 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 } from '@waggle/memory-contract';
import { createMem0MemoryStore, createWordEmbedder, 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('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!));
});
});