Files
waggle-os/packages/memory-mem0/tests/mem0-store.test.ts
shumeiko.it 8555d84b75 feat(memory): refuse to open a memory store with a different embedder
Vectors of different models are not comparable even at the same size; the
store records its embedder in waggle-memory.json and names the mismatch.
Also drop the weaver references from the cli and server tsconfigs.
2026-10-24 12:06:10 +02:00

186 lines
7.8 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, 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('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!));
});
});