mem0-mcp 0.2.0

package/dist/transport/tools/memory-search.tool.js

@@ -0,0 +1,27 @@
+import { memorySearchInputSchema } from '../../domain/memory.types.js';
+import { scopeJsonSchema } from './shared-schemas.js';
+export function createMemorySearchTool(store) {
+    return {
+        name: 'memory_search',
+        description: 'Run a scoped semantic memory search using the configured Ollama embedding model.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }] },
+                scope: scopeJsonSchema,
+                kind: {
+                    type: 'string',
+                    enum: ['decision', 'preference', 'summary', 'artifact_context', 'note'],
+                },
+                limit: { type: 'integer', minimum: 1, maximum: 25, default: 5 },
+            },
+            required: ['query', 'scope'],
+            additionalProperties: false,
+        },
+        handler: async (args) => {
+            const input = memorySearchInputSchema.parse(args);
+            const results = await store.searchMemory(input);
+            return { results };
+        },
+    };
+}

package/dist/transport/tools/memory-store.tool.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryStorePort } from '../../ports/memory-store.port.js';
+import type { ToolDefinition } from '../mcp-server.js';
+export declare function createMemoryStoreTool(store: MemoryStorePort): ToolDefinition;

package/dist/transport/tools/memory-store.tool.js

@@ -0,0 +1,32 @@
+import { memoryStoreInputSchema } from '../../domain/memory.types.js';
+import { scopeJsonSchema, provenanceJsonSchema } from './shared-schemas.js';
+export function createMemoryStoreTool(store) {
+    return {
+        name: 'memory_store',
+        description: 'Persist a scoped memory with mandatory checkpoint provenance back to SQLite.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kind: {
+                    type: 'string',
+                    enum: ['decision', 'preference', 'summary', 'artifact_context', 'note'],
+                },
+                content: { type: 'string' },
+                scope: scopeJsonSchema,
+                provenance: provenanceJsonSchema,
+                metadata: {
+                    type: 'object',
+                    additionalProperties: { type: 'string' },
+                    default: {},
+                },
+            },
+            required: ['kind', 'content', 'scope', 'provenance'],
+            additionalProperties: false,
+        },
+        handler: async (args) => {
+            const input = memoryStoreInputSchema.parse(args);
+            const memory = await store.storeMemory(input);
+            return { memory };
+        },
+    };
+}

package/dist/transport/tools/memory-update.tool.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryStorePort } from '../../ports/memory-store.port.js';
+import type { ToolDefinition } from '../mcp-server.js';
+export declare function createMemoryUpdateTool(store: MemoryStorePort): ToolDefinition;

package/dist/transport/tools/memory-update.tool.js

@@ -0,0 +1,24 @@
+import { memoryUpdateInputSchema } from '../../domain/memory.types.js';
+import { scopeJsonSchema } from './shared-schemas.js';
+export function createMemoryUpdateTool(store) {
+    return {
+        name: 'memory_update',
+        description: 'Update an existing memory with new content or metadata.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryId: { type: 'string', format: 'uuid' },
+                scope: scopeJsonSchema,
+                content: { type: 'string' },
+                metadata: { type: 'object', additionalProperties: { type: 'string' } },
+            },
+            required: ['memoryId', 'scope'],
+            additionalProperties: false,
+        },
+        handler: async (args) => {
+            const input = memoryUpdateInputSchema.parse(args);
+            const memory = await store.updateMemory(input);
+            return { memory };
+        },
+    };
+}

package/dist/transport/tools/setup-wizard.tool.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDefinition } from '../mcp-server.js';
+interface SetupWizardToolOptions {
+    embedModel: string;
+    runCommand?: (command: string, args: string[]) => Promise<void>;
+}
+export declare function createSetupWizardTool(options: SetupWizardToolOptions): ToolDefinition;
+export {};

package/dist/transport/tools/setup-wizard.tool.js

@@ -0,0 +1,35 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { getErrorMessage } from '../../domain/errors.js';
+const execFileAsync = promisify(execFile);
+const emptyInputSchema = z.object({}).strict();
+export function createSetupWizardTool(options) {
+    const runCommand = options.runCommand ?? defaultRunCommand;
+    return {
+        name: 'setup_wizard',
+        description: 'Initialize mem0 by checking dependencies and pulling the configured embedding model via Ollama.',
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        handler: async (args) => {
+            emptyInputSchema.parse(args ?? {});
+            try {
+                await runCommand('ollama', ['pull', options.embedModel]);
+                return {
+                    success: true,
+                    model: options.embedModel,
+                    message: `Ollama model ${options.embedModel} pulled successfully.`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    model: options.embedModel,
+                    message: `Failed to pull Ollama model ${options.embedModel}: ${getErrorMessage(error)}`,
+                };
+            }
+        },
+    };
+}
+async function defaultRunCommand(command, args) {
+    await execFileAsync(command, args);
+}

package/dist/transport/tools/shared-schemas.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared JSON Schema fragments used by multiple tool definitions.
+ * Single source of truth — eliminates duplication across tool files.
+ */
+export declare const scopeJsonSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly workspace: {
+            readonly type: "string";
+        };
+        readonly project: {
+            readonly type: "string";
+        };
+        readonly campaign: {
+            readonly type: "string";
+        };
+        readonly task: {
+            readonly type: "string";
+        };
+        readonly run: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["workspace", "project"];
+    readonly additionalProperties: false;
+};
+export declare const provenanceJsonSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly checkpointId: {
+            readonly type: "string";
+        };
+        readonly artifactIds: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly default: readonly [];
+        };
+        readonly note: {
+            readonly type: "string";
+        };
+    };
+    readonly required: readonly ["checkpointId"];
+    readonly additionalProperties: false;
+};

package/dist/transport/tools/shared-schemas.js

@@ -0,0 +1,30 @@
+/**
+ * Shared JSON Schema fragments used by multiple tool definitions.
+ * Single source of truth — eliminates duplication across tool files.
+ */
+export const scopeJsonSchema = {
+    type: 'object',
+    properties: {
+        workspace: { type: 'string' },
+        project: { type: 'string' },
+        campaign: { type: 'string' },
+        task: { type: 'string' },
+        run: { type: 'string' },
+    },
+    required: ['workspace', 'project'],
+    additionalProperties: false,
+};
+export const provenanceJsonSchema = {
+    type: 'object',
+    properties: {
+        checkpointId: { type: 'string' },
+        artifactIds: {
+            type: 'array',
+            items: { type: 'string' },
+            default: [],
+        },
+        note: { type: 'string' },
+    },
+    required: ['checkpointId'],
+    additionalProperties: false,
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "mem0-mcp",
+  "version": "0.2.0",
+  "description": "A dedicated mem0 MCP server with file-backed storage and Ollama embeddings.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": "dist/bin/mem0-mcp.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "package.json",
+    "scripts/prepare.cjs"
+  ],
+  "scripts": {
+    "prepare": "node scripts/prepare.cjs",
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "npm run build && node --test dist/test/**/*.test.js && npm run test:prepare",
+    "test:prepare": "node --test scripts/prepare.test.cjs",
+    "mem0:mcp": "node dist/bin/mem0-mcp.js",
+    "mem0:mcp:dev": "tsx src/bin/mem0-mcp.ts",
+    "build:exe": "npm run build && pkg . --targets node18-macos-arm64,node18-macos-x64,node18-linux-x64,node18-win-x64 --out-path bin/"
+  },
+  "keywords": [
+    "mem0",
+    "mcp",
+    "ollama",
+    "memory"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/giulio-leone/mem0-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/giulio-leone/mem0-mcp/issues"
+  },
+  "homepage": "https://github.com/giulio-leone/mem0-mcp#readme",
+  "license": "BUSL-1.1",
+  "dependencies": {
+    "better-sqlite3": "^12.8.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.5.0",
+    "pkg": "^5.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/scripts/prepare.cjs

@@ -0,0 +1,59 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+function resolveWithinCwd(cwd, segments) {
+  return path.join(cwd, ...segments);
+}
+
+function hasFile(existsSync, cwd, segments) {
+  return existsSync(resolveWithinCwd(cwd, segments));
+}
+
+function isDependencyInstall(cwd, initCwd) {
+  return Boolean(initCwd) && path.resolve(initCwd) !== path.resolve(cwd);
+}
+
+function buildMissingDistMessage(packageName) {
+  return (
+    `dist missing for ${packageName}; run npm install in ${packageName} ` +
+    '(or build it) before installing downstream consumers'
+  );
+}
+
+function runPrepare(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const initCwd = options.initCwd ?? process.env.INIT_CWD;
+  const existsSync = options.existsSync ?? fs.existsSync;
+  const execSync = options.execSync ?? cp.execSync;
+  const log = options.log ?? console.log;
+
+  const dependencyInstall = isDependencyInstall(cwd, initCwd);
+  const hasDist = hasFile(existsSync, cwd, ['dist', 'index.js']);
+  const hasTypescript = hasFile(existsSync, cwd, ['node_modules', 'typescript', 'package.json']);
+
+  if (!dependencyInstall && hasTypescript) {
+    execSync('npm run build', {
+      cwd,
+      stdio: 'inherit',
+    });
+    return 'built';
+  }
+
+  if (!hasDist) {
+    throw new Error(buildMissingDistMessage('mem0-mcp'));
+  }
+
+  log('Skipping prepare build: using existing dist for dependency install');
+  return 'skipped';
+}
+
+if (require.main === module) {
+  runPrepare();
+}
+
+module.exports = {
+  buildMissingDistMessage,
+  isDependencyInstall,
+  runPrepare,
+};