mem0-mcp 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## 0.2.0 - 2026-04-01
+
+### Added
+- Added deterministic deduplication with a stable `dedupe_key` so exact memory updates do not silently preserve stale content.
+- Added abortable Ollama requests with configurable `MEM0_OLLAMA_TIMEOUT_MS`.
+- Added repository metadata and installable package metadata for npm-based distribution.
+
+### Changed
+- `setup_wizard` now respects the configured embedding model instead of always pulling `qwen3-embedding:latest`.
+- MCP initialization now reports the real package version from `package.json`.
+- README now documents installation, host launch guidance, and current release highlights.
+
+### Fixed
+- Fixed soft deduplication behavior that could return the old content while only updating provenance and timestamps.
+- Fixed package metadata drift between `package.json`, lockfile, and license declarations.
+
+## 0.1.0 - 2026-03-31
+
+### Added
+- Initial dedicated `mem0` MCP server with SQLite-backed scope storage, provenance-aware memory tools, and Ollama embeddings.

package/LICENSE

@@ -0,0 +1,27 @@
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+Licensor:  Giulio Leone
+Licensed Work:  mem0-mcp
+Additional Use Grant:  You may use the Licensed Work for non-commercial and non-production purposes (e.g., development, testing, research, and personal projects) free of charge. Any commercial or production use requires prior written authorization from the Licensor.
+Change Date:  2030-03-22
+Change License:  Apache License, Version 2.0
+
+Terms
+The Licensor hereby grants you the right to copy, modify, create derivative works, redistribute, and make non-production use of the Licensed Work. The Licensor may make an Additional Use Grant, above, permitting limited production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly available distribution of a specific version of the Licensed Work under this License, whichever comes first, the Licensor hereby grants you the rights provided under the Change License, and this Business Source License will terminate as to that version.
+
+If your use of the Licensed Work does not comply with the requirements currently in effect as described in this License, you must purchase a commercial license from the Licensor, its affiliated entities, or authorized resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works of the Licensed Work, are subject to this License. This License applies separately for each version of the Licensed Work and the Change Date may vary for each version of the Licensed Work.
+
+Any copy of the Licensed Work must prominently display this License with the Notice. Any distribution of the Licensed Work must include this License with the Notice.
+
+You must not remove or alter any copyright, trademark, or patent notice, any license or the Notice.
+
+Notice
+Any use of the Licensed Work is subject to the Business Source License 1.1.

package/README.md

@@ -0,0 +1,71 @@
+# mem0-mcp
+
+A dedicated repository for the `mem0` MCP server we developed: file-backed scoped memory records, mandatory checkpoint provenance, and Ollama-based embeddings.
+
+Release notes and migration details live in [CHANGELOG.md](CHANGELOG.md).
+
+## Installation
+
+```bash
+npm install -g mem0-mcp
+```
+
+## Release Highlights (0.2.0)
+
+- Deterministic memory deduplication through a stable `dedupe_key` instead of similarity-based soft merging.
+- Config-aware `setup_wizard` that validates and pulls the configured embedding model instead of assuming one hard-coded model.
+- Abortable Ollama requests with `MEM0_OLLAMA_TIMEOUT_MS` across health checks and embedding calls.
+- MCP `initialize` now reports the real package version from `package.json`.
+- Package metadata is ready for installable distribution, including repository, homepage, and issue tracker links.
+
+## Architecture boundary
+
+This repository contains only the `mem0` server/runtime surface:
+
+- `src/transport/mcp-server.ts`
+- `src/adapters/sqlite/sqlite-memory-store.ts`
+- `src/adapters/ollama/ollama-embedder.ts`
+- `src/bin/mem0-mcp.ts`
+
+Generic MCP transport mechanics are implemented inside this repository under `src/transport/`, so `mem0-mcp` can build and install independently without requiring sibling repositories.
+
+## Environment
+
+- `MEM0_STORE_PATH` (default: `~/.copilot/mem0`)
+- `OLLAMA_BASE_URL` (default: `http://127.0.0.1:11434`)
+- `MEM0_EMBED_MODEL` (default: `qwen3-embedding:latest`)
+- `MEM0_OLLAMA_TIMEOUT_MS` (default: `10000`)
+
+## Commands
+
+```bash
+npm install
+npm run typecheck
+npm run build
+npm test
+npm run mem0:mcp
+```
+
+## Host Launch Guidance
+
+If an MCP host isolates native modules poorly, prefer launching the server as `node <absolute-path>/dist/bin/mem0-mcp.js` instead of a symlinked shim. This avoids native module resolution failures around `better-sqlite3` in some host runtimes.
+
+## Tool surface
+
+- `health`
+- `memory_store`
+- `memory_recall`
+- `memory_search`
+- `memory_update`
+- `memory_forget`
+- `setup_wizard`
+
+## License
+
+This project is licensed under the **Business Source License 1.1 (BSL)**.
+
+**You may use this software for non-commercial and non-production purposes (e.g., development, testing, research, and personal projects) free of charge.**
+
+**Commercial and production use is strictly prohibited without prior written authorization.**
+
+On March 22, 2030 (the Change Date), this license automatically converts to the **Apache License, Version 2.0**.

package/dist/adapters/ollama/ollama-embedder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Adapter: Ollama Embedder — HTTP client for the Ollama embedding API.
+ * Implements EmbedderPort.
+ */
+import type { Mem0Config } from '../../domain/memory.types.js';
+import type { EmbedderPort, EmbedderHealthStatus } from '../../ports/embedder.port.js';
+export declare class OllamaEmbedder implements EmbedderPort {
+    private readonly config;
+    private readonly baseUrl;
+    constructor(config: Pick<Mem0Config, 'ollamaBaseUrl' | 'embedModel' | 'ollamaTimeoutMs'>);
+    healthCheck(): Promise<EmbedderHealthStatus>;
+    embedText(text: string): Promise<number[]>;
+    private tryModernEndpoint;
+    private tryLegacyEndpoint;
+    private fetchWithTimeout;
+}

package/dist/adapters/ollama/ollama-embedder.js

@@ -0,0 +1,132 @@
+/**
+ * Adapter: Ollama Embedder — HTTP client for the Ollama embedding API.
+ * Implements EmbedderPort.
+ */
+import { getErrorMessage } from '../../domain/errors.js';
+export class OllamaEmbedder {
+    config;
+    baseUrl;
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = config.ollamaBaseUrl.replace(/\/+$/, '');
+    }
+    async healthCheck() {
+        try {
+            const response = await this.fetchWithTimeout('/api/tags');
+            if (!response.ok) {
+                return {
+                    ok: false,
+                    modelAvailable: false,
+                    details: `Ollama /api/tags returned ${response.status}`,
+                };
+            }
+            const payload = (await response.json());
+            const modelAvailable = (payload.models ?? []).some((model) => model.name === this.config.embedModel ||
+                model.model === this.config.embedModel);
+            return {
+                ok: modelAvailable,
+                modelAvailable,
+                details: modelAvailable
+                    ? undefined
+                    : `Embedding model ${this.config.embedModel} is not available in Ollama`,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                modelAvailable: false,
+                details: getErrorMessage(error),
+            };
+        }
+    }
+    async embedText(text) {
+        const modern = await this.tryModernEndpoint(text);
+        if (modern !== null)
+            return modern;
+        return this.tryLegacyEndpoint(text);
+    }
+    async tryModernEndpoint(text) {
+        const response = await this.fetchWithTimeout('/api/embed', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ model: this.config.embedModel, input: text }),
+        });
+        if (response.status === 404 || response.status === 405) {
+            return null;
+        }
+        if (!response.ok) {
+            const body = await safeReadText(response);
+            throw new Error(`Ollama modern embedding request failed (${response.status}): ${body || response.statusText}`);
+        }
+        const payload = (await response.json());
+        if (!Array.isArray(payload.embeddings) ||
+            payload.embeddings.length === 0 ||
+            !Array.isArray(payload.embeddings[0])) {
+            return null;
+        }
+        return ensureNumericVector(payload.embeddings[0]);
+    }
+    async tryLegacyEndpoint(text) {
+        let response;
+        try {
+            response = await this.fetchWithTimeout('/api/embeddings', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ model: this.config.embedModel, prompt: text }),
+            });
+        }
+        catch (error) {
+            throw new Error(`Unable to reach Ollama at ${this.baseUrl}: ${getErrorMessage(error)}`);
+        }
+        if (!response.ok) {
+            const body = await safeReadText(response);
+            throw new Error(`Ollama embedding request failed (${response.status}): ${body || response.statusText}`);
+        }
+        const payload = (await response.json());
+        if (!Array.isArray(payload.embedding)) {
+            throw new Error('Ollama /api/embeddings returned no embedding vector');
+        }
+        return ensureNumericVector(payload.embedding);
+    }
+    async fetchWithTimeout(path, init) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => {
+            controller.abort();
+        }, this.config.ollamaTimeoutMs);
+        try {
+            return await fetch(`${this.baseUrl}${path}`, {
+                ...init,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Timed out after ${this.config.ollamaTimeoutMs}ms contacting Ollama at ${this.baseUrl}`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+function ensureNumericVector(values) {
+    const vector = values.map((value) => {
+        if (typeof value !== 'number' || Number.isNaN(value)) {
+            throw new Error('Embedding vector contains a non-numeric value');
+        }
+        return value;
+    });
+    if (vector.length === 0) {
+        throw new Error('Embedding vector is empty');
+    }
+    return vector;
+}
+async function safeReadText(response) {
+    try {
+        return await response.text();
+    }
+    catch {
+        return '';
+    }
+}

package/dist/adapters/sqlite/sqlite-memory-store.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Adapter: SQLite Memory Store — better-sqlite3 implementation of MemoryStorePort.
+ */
+import { type HealthCheckResult, type Mem0Config, type MemoryForgetInput, type MemoryRecallInput, type MemorySearchInput, type MemorySearchResult, type MemoryStoreInput, type MemoryUpdateInput, type PublicMemoryRecord } from '../../domain/memory.types.js';
+import type { EmbedderPort } from '../../ports/embedder.port.js';
+import type { MemoryStorePort } from '../../ports/memory-store.port.js';
+export declare class SqliteMem0Adapter implements MemoryStorePort {
+    private readonly config;
+    private readonly db;
+    private readonly embedder;
+    constructor(config: Mem0Config, embedder?: EmbedderPort);
+    static fromEnv(env?: NodeJS.ProcessEnv): SqliteMem0Adapter;
+    healthCheck(): Promise<HealthCheckResult>;
+    storeMemory(input: MemoryStoreInput): Promise<PublicMemoryRecord>;
+    recallMemory(input: MemoryRecallInput): Promise<PublicMemoryRecord | null>;
+    searchMemory(input: MemorySearchInput): Promise<MemorySearchResult[]>;
+    updateMemory(input: MemoryUpdateInput): Promise<PublicMemoryRecord>;
+    deleteMemory(input: MemoryForgetInput): Promise<void>;
+    listWorkspaces(): Promise<string[]>;
+    listProjects(workspace: string): Promise<string[]>;
+    private initDb;
+    private getAllRecords;
+    private getRecordsByScope;
+    private ensureLegacyColumns;
+    private backfillMissingDedupeKeys;
+    private mapRowToRecord;
+}

package/dist/adapters/sqlite/sqlite-memory-store.js

@@ -0,0 +1,217 @@
+/**
+ * Adapter: SQLite Memory Store — better-sqlite3 implementation of MemoryStorePort.
+ */
+import { randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import Database from 'better-sqlite3';
+import { loadMem0ConfigFromEnv, toPublicMemoryRecord, } from '../../domain/memory.types.js';
+import { getErrorMessage, MemoryNotFoundError } from '../../domain/errors.js';
+import { matchesScope, cosineSimilarity, buildEmbeddingSource, buildMemoryDedupeKey, } from '../../domain/memory.utils.js';
+import { OllamaEmbedder } from '../ollama/ollama-embedder.js';
+export class SqliteMem0Adapter {
+    config;
+    db;
+    embedder;
+    constructor(config, embedder) {
+        this.config = config;
+        const dbPath = join(config.storePath, 'memories.sqlite');
+        mkdirSync(config.storePath, { recursive: true });
+        this.db = new Database(dbPath);
+        this.embedder = embedder ?? new OllamaEmbedder(config);
+        this.initDb();
+    }
+    static fromEnv(env = process.env) {
+        return new SqliteMem0Adapter(loadMem0ConfigFromEnv(env));
+    }
+    // ─── MemoryStorePort ──────────────────────────────────────────────
+    async healthCheck() {
+        try {
+            const stmt = this.db.prepare('SELECT COUNT(*) as count FROM memories');
+            const { count } = stmt.get();
+            const ollamaHealth = await this.embedder.healthCheck();
+            return {
+                ok: ollamaHealth.ok,
+                storePath: this.config.storePath,
+                ollamaBaseUrl: this.config.ollamaBaseUrl,
+                embedModel: this.config.embedModel,
+                modelAvailable: ollamaHealth.modelAvailable,
+                recordCount: count,
+                details: ollamaHealth.details,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                storePath: this.config.storePath,
+                ollamaBaseUrl: this.config.ollamaBaseUrl,
+                embedModel: this.config.embedModel,
+                modelAvailable: false,
+                recordCount: 0,
+                details: getErrorMessage(error),
+            };
+        }
+    }
+    async storeMemory(input) {
+        const now = new Date().toISOString();
+        const dedupeKey = buildMemoryDedupeKey(input.kind, input.content, input.scope, input.metadata);
+        const duplicateRow = this.db
+            .prepare('SELECT * FROM memories WHERE dedupe_key = ? LIMIT 1')
+            .get(dedupeKey);
+        if (duplicateRow) {
+            const duplicate = this.mapRowToRecord(duplicateRow);
+            this.db
+                .prepare('UPDATE memories SET provenance = ?, updated_at = ? WHERE id = ?')
+                .run(JSON.stringify(input.provenance), now, duplicate.id);
+            duplicate.provenance = input.provenance;
+            duplicate.updatedAt = now;
+            return toPublicMemoryRecord(duplicate);
+        }
+        const sourceText = buildEmbeddingSource(input.kind, input.content, input.scope, input.provenance, input.metadata);
+        const embedding = await this.embedder.embedText(sourceText);
+        const id = randomUUID();
+        this.db.prepare(`
+      INSERT INTO memories (id, kind, content, scope, provenance, metadata, embedding, dedupe_key, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.kind, input.content, JSON.stringify(input.scope), JSON.stringify(input.provenance), JSON.stringify(input.metadata), JSON.stringify(embedding), dedupeKey, now, now);
+        return {
+            id, kind: input.kind, content: input.content,
+            scope: input.scope, provenance: input.provenance,
+            metadata: input.metadata, createdAt: now, updatedAt: now,
+        };
+    }
+    async recallMemory(input) {
+        const row = this.db.prepare('SELECT * FROM memories WHERE id = ?').get(input.memoryId);
+        if (!row)
+            return null;
+        const record = this.mapRowToRecord(row);
+        if (!matchesScope(record.scope, input.scope))
+            return null;
+        return toPublicMemoryRecord(record);
+    }
+    async searchMemory(input) {
+        let records = this.getRecordsByScope(input.scope);
+        if (input.kind !== undefined) {
+            records = records.filter((r) => r.kind === input.kind);
+        }
+        if (records.length === 0)
+            return [];
+        const queries = Array.isArray(input.query) ? input.query : [input.query];
+        const queryEmbeddings = await Promise.all(queries.map((q) => this.embedder.embedText(q)));
+        const results = [];
+        for (const record of records) {
+            let maxScore = -1;
+            for (const qEmb of queryEmbeddings) {
+                const score = cosineSimilarity(qEmb, record.embedding);
+                if (score > maxScore)
+                    maxScore = score;
+            }
+            results.push({ memory: toPublicMemoryRecord(record), score: maxScore });
+        }
+        return results.sort((a, b) => b.score - a.score).slice(0, input.limit);
+    }
+    async updateMemory(input) {
+        const existing = await this.recallMemory({ memoryId: input.memoryId, scope: input.scope });
+        if (!existing)
+            throw new MemoryNotFoundError(input.memoryId);
+        const now = new Date().toISOString();
+        const newContent = input.content ?? existing.content;
+        const newMetadata = input.metadata ?? existing.metadata;
+        let newEmbeddingStr;
+        if (input.content !== undefined || input.metadata !== undefined) {
+            const sourceText = buildEmbeddingSource(existing.kind, newContent, existing.scope, existing.provenance, newMetadata);
+            const newEmbedding = await this.embedder.embedText(sourceText);
+            newEmbeddingStr = JSON.stringify(newEmbedding);
+        }
+        else {
+            const row = this.db.prepare('SELECT embedding FROM memories WHERE id = ?').get(input.memoryId);
+            newEmbeddingStr = row.embedding;
+        }
+        this.db.prepare('UPDATE memories SET content = ?, metadata = ?, embedding = ?, dedupe_key = ?, updated_at = ? WHERE id = ?').run(newContent, JSON.stringify(newMetadata), newEmbeddingStr, buildMemoryDedupeKey(existing.kind, newContent, existing.scope, newMetadata), now, input.memoryId);
+        return { ...existing, content: newContent, metadata: newMetadata, updatedAt: now };
+    }
+    async deleteMemory(input) {
+        const existing = await this.recallMemory({ memoryId: input.memoryId, scope: input.scope });
+        if (!existing)
+            throw new MemoryNotFoundError(input.memoryId);
+        this.db.prepare('DELETE FROM memories WHERE id = ?').run(input.memoryId);
+    }
+    async listWorkspaces() {
+        const records = this.getAllRecords();
+        const workspaces = new Set();
+        for (const r of records)
+            workspaces.add(r.scope.workspace);
+        return Array.from(workspaces);
+    }
+    async listProjects(workspace) {
+        const records = this.getAllRecords();
+        const projects = new Set();
+        for (const r of records) {
+            if (r.scope.workspace === workspace)
+                projects.add(r.scope.project);
+        }
+        return Array.from(projects);
+    }
+    // ─── Private ──────────────────────────────────────────────────────
+    initDb() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        kind TEXT NOT NULL,
+        content TEXT NOT NULL,
+        scope TEXT NOT NULL,
+        provenance TEXT NOT NULL,
+        metadata TEXT NOT NULL,
+        embedding TEXT NOT NULL,
+        dedupe_key TEXT NOT NULL DEFAULT '',
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
+        this.ensureLegacyColumns();
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memories_dedupe_key
+      ON memories (dedupe_key)
+    `);
+        this.backfillMissingDedupeKeys();
+    }
+    getAllRecords() {
+        const rows = this.db.prepare('SELECT * FROM memories').all();
+        return rows.map(this.mapRowToRecord);
+    }
+    getRecordsByScope(scope) {
+        return this.getAllRecords().filter((r) => matchesScope(r.scope, scope));
+    }
+    ensureLegacyColumns() {
+        const columns = this.db
+            .prepare('PRAGMA table_info(memories)')
+            .all();
+        if (!columns.some((column) => column.name === 'dedupe_key')) {
+            this.db.exec(`ALTER TABLE memories ADD COLUMN dedupe_key TEXT NOT NULL DEFAULT ''`);
+        }
+    }
+    backfillMissingDedupeKeys() {
+        const rows = this.db
+            .prepare(`SELECT id, kind, content, scope, metadata
+         FROM memories
+         WHERE dedupe_key = '' OR dedupe_key IS NULL`)
+            .all();
+        const updateStatement = this.db.prepare('UPDATE memories SET dedupe_key = ? WHERE id = ?');
+        for (const row of rows) {
+            updateStatement.run(buildMemoryDedupeKey(row.kind, row.content, JSON.parse(row.scope), JSON.parse(row.metadata)), row.id);
+        }
+    }
+    mapRowToRecord(row) {
+        return {
+            id: row.id,
+            kind: row.kind,
+            content: row.content,
+            scope: JSON.parse(row.scope),
+            provenance: JSON.parse(row.provenance),
+            metadata: JSON.parse(row.metadata),
+            embedding: JSON.parse(row.embedding),
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}

package/dist/bin/mem0-mcp.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * Composition Root — wires domain, ports, adapters, and transport.
+ */
+export {};

package/dist/bin/mem0-mcp.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * Composition Root — wires domain, ports, adapters, and transport.
+ */
+import { createRequire } from 'node:module';
+import { loadMem0ConfigFromEnv } from '../domain/memory.types.js';
+import { OllamaEmbedder } from '../adapters/ollama/ollama-embedder.js';
+import { SqliteMem0Adapter } from '../adapters/sqlite/sqlite-memory-store.js';
+import { McpServer } from '../transport/mcp-server.js';
+// Tools
+import { createHealthTool } from '../transport/tools/health.tool.js';
+import { createMemoryStoreTool } from '../transport/tools/memory-store.tool.js';
+import { createMemoryRecallTool } from '../transport/tools/memory-recall.tool.js';
+import { createMemorySearchTool } from '../transport/tools/memory-search.tool.js';
+import { createMemoryUpdateTool } from '../transport/tools/memory-update.tool.js';
+import { createMemoryForgetTool } from '../transport/tools/memory-forget.tool.js';
+import { createSetupWizardTool } from '../transport/tools/setup-wizard.tool.js';
+const requireFromHere = createRequire(import.meta.url);
+async function main() {
+    // 1. Config
+    const config = loadMem0ConfigFromEnv();
+    // 2. Adapters (infrastructure)
+    const embedder = new OllamaEmbedder(config);
+    const store = new SqliteMem0Adapter(config, embedder);
+    // 3. Transport (MCP server)
+    const server = new McpServer({
+        serverInfo: {
+            name: 'mem0-mcp',
+            version: resolvePackageVersion(),
+        },
+        instructions: 'SQLite remains canonical. memory_store requires canonical scope metadata and checkpoint provenance before a memory can be persisted.',
+    });
+    // 4. Register tools
+    server.registerTool(createHealthTool(store));
+    server.registerTool(createMemoryStoreTool(store));
+    server.registerTool(createMemoryRecallTool(store));
+    server.registerTool(createMemorySearchTool(store));
+    server.registerTool(createMemoryUpdateTool(store));
+    server.registerTool(createMemoryForgetTool(store));
+    server.registerTool(createSetupWizardTool({
+        embedModel: config.embedModel,
+    }));
+    // 5. Register resource handler
+    server.registerResourceListHandler(async () => {
+        const workspaces = await store.listWorkspaces();
+        const resources = [];
+        for (const workspace of workspaces) {
+            const projects = await store.listProjects(workspace);
+            for (const project of projects) {
+                resources.push({
+                    uri: `mem0://${workspace}/${project}`,
+                    name: `Memory Scope: ${workspace}/${project}`,
+                });
+            }
+        }
+        return { resources };
+    });
+    // 6. Start
+    server.start();
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exit(1);
+});
+function resolvePackageVersion() {
+    try {
+        const packageJson = requireFromHere('../../package.json');
+        if (typeof packageJson.version === 'string' && packageJson.version.length > 0) {
+            return packageJson.version;
+        }
+    }
+    catch {
+        // Fall back below when package.json is unavailable in constrained runtimes.
+    }
+    return '0.2.0';
+}

package/dist/domain/errors.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Canonical error utilities for the mem0-mcp domain.
+ */
+export declare function getErrorMessage(error: unknown): string;
+export declare class MemoryNotFoundError extends Error {
+    constructor(memoryId: string);
+}

package/dist/domain/errors.js

@@ -0,0 +1,12 @@
+/**
+ * Canonical error utilities for the mem0-mcp domain.
+ */
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export class MemoryNotFoundError extends Error {
+    constructor(memoryId) {
+        super(`Memory ${memoryId} not found in given scope.`);
+        this.name = 'MemoryNotFoundError';
+    }
+}