@cybermem/mcp 0.5.3 → 0.6.2

package/src/index.ts

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Tool
+} from "@modelcontextprotocol/sdk/types.js";
+import axios from "axios";
+import cors from "cors";
+import dotenv from "dotenv";
+import express from "express";
+
+dotenv.config();
+
+// Parse CLI args for remote mode
+const args = process.argv.slice(2);
+const getArg = (name: string): string | undefined => {
+  const idx = args.indexOf(name);
+  return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+};
+
+const cliUrl = getArg('--url');
+const cliApiKey = getArg('--api-key');
+const cliClientName = getArg('--client-name');
+
+// Use CLI args first, then env, then defaults
+// Default to local CyberMem backend (via Traefik on port 8626)
+const API_URL = cliUrl || process.env.CYBERMEM_URL || "http://localhost:8626/memory";
+const API_KEY = cliApiKey || process.env.OM_API_KEY || "";
+
+// Track client name per session
+let currentClientName = cliClientName || "cybermem-mcp";
+
+const server = new Server(
+  {
+    name: "cybermem-mcp",
+    version: "0.2.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+const tools: Tool[] = [
+  {
+    name: "add_memory",
+    description: "Store a new memory in CyberMem",
+    inputSchema: {
+      type: "object",
+      properties: {
+        content: { type: "string" },
+        user_id: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+      },
+      required: ["content"],
+    },
+  },
+  {
+    name: "query_memory",
+    description: "Search for relevant memories",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string" },
+        k: { type: "number", default: 5 },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "list_memories",
+    description: "List recent memories",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", default: 10 },
+      },
+    },
+  },
+  {
+    name: "delete_memory",
+    description: "Delete a memory by ID",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+      },
+      required: ["id"],
+    },
+  },
+  {
+    name: "update_memory",
+    description: "Update a memory by ID",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string" },
+        content: { type: "string" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+      },
+      required: ["id"],
+    },
+  }
+];
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools,
+}));
+
+// Create axios instance
+const apiClient = axios.create({
+  baseURL: API_URL,
+  headers: {
+    "Authorization": `Bearer ${API_KEY}`,
+  },
+});
+
+// Helper to get client with context
+function getClient(customHeaders: Record<string, string> = {}) {
+    // Identity is taken from currentClientName which is updated per-request in SSE mode
+    const clientName = customHeaders["X-Client-Name"] || currentClientName;
+
+    return {
+        ...apiClient,
+        get: (url: string, config?: any) => apiClient.get(url, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        post: (url: string, data?: any, config?: any) => apiClient.post(url, data, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        put: (url: string, data?: any, config?: any) => apiClient.put(url, data, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        patch: (url: string, data?: any, config?: any) => apiClient.patch(url, data, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        delete: (url: string, config?: any) => apiClient.delete(url, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+    }
+}
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "add_memory": {
+        const response = await getClient().post("/add", args);
+        return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+      }
+      case "query_memory": {
+        const response = await getClient().post("/query", args);
+        return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+      }
+      case "list_memories": {
+        const limit = args?.limit || 10;
+        const response = await getClient().get(`/all?l=${limit}`);
+        return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+      }
+      case "delete_memory": {
+        const { id } = args as { id: string };
+        await getClient().delete(`/${id}`);
+        return { content: [{ type: "text", text: `Memory ${id} deleted` }] };
+      }
+      case "update_memory": {
+        const { id, ...updates } = args as { id: string; [key: string]: any };
+        const response = await getClient().patch(`/${id}`, updates);
+        return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error: any) {
+    return {
+      content: [{ type: "text", text: `Error: ${error.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function run() {
+  const isSse = process.argv.includes("--sse") || !!process.env.PORT;
+
+  if (isSse) {
+    const app = express();
+    app.use(cors());
+    const port = process.env.PORT || 8627;
+
+    let transport: SSEServerTransport | null = null;
+
+    app.get("/sse", async (req, res) => {
+      // Extract client name from header
+      const clientName = req.headers["x-client-name"] as string;
+      if (clientName) {
+        currentClientName = clientName;
+      }
+
+      transport = new SSEServerTransport("/messages", res);
+      await server.connect(transport);
+    });
+
+    app.post("/messages", async (req, res) => {
+      // Also check headers on messages
+      const clientName = req.headers["x-client-name"] as string;
+      if (clientName) {
+        currentClientName = clientName;
+      }
+
+      if (transport) {
+        await transport.handlePostMessage(req, res);
+      } else {
+        res.status(400).send("Session not established");
+      }
+    });
+
+    app.listen(port, () => {
+      console.error(`CyberMem MCP Server running on SSE at http://localhost:${port}`);
+      console.error(`  - SSE endpoint: http://localhost:${port}/sse`);
+      console.error(`  - Message endpoint: http://localhost:${port}/messages`);
+    });
+
+  } else {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("CyberMem MCP Server running on stdio");
+  }
+}
+
+run().catch((error) => {
+  console.error("Fatal error running server:", error);
+  process.exit(1);
+});

package/test_mcp.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""
+Test script for OpenMemory MCP Server
+
+Demonstrates MCP server functionality by simulating tool calls.
+"""
+
+import asyncio
+import httpx
+import json
+
+
+OPENMEMORY_URL = "http://localhost/memory"
+OPENMEMORY_API_KEY = "dev-secret-key"
+
+
+async def test_add_memory():
+    """Test adding a memory."""
+    print("\n🧪 Test 1: Adding memory...")
+
+    headers = {
+        "Authorization": f"Bearer {OPENMEMORY_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(
+            f"{OPENMEMORY_URL}/add",
+            json={
+                "content": "MCP server test: Claude Code can now remember conversations and context",
+                "metadata": {
+                    "source": "mcp_test",
+                    "category": "integration_test",
+                    "timestamp": "2025-11-30"
+                }
+            },
+            headers=headers
+        )
+
+        if response.status_code == 200:
+            result = response.json()
+            print(f"✅ Memory added successfully!")
+            print(f"   ID: {result.get('id')}")
+            print(f"   Chunks: {result.get('chunks')}")
+            print(f"   Sectors: {', '.join(result.get('sectors', []))}")
+            return result.get('id')
+        else:
+            print(f"❌ Failed: {response.status_code} - {response.text}")
+            return None
+
+
+async def test_search_memory():
+    """Test searching memories."""
+    print("\n🧪 Test 2: Searching memory...")
+
+    headers = {
+        "Authorization": f"Bearer {OPENMEMORY_API_KEY}",
+        "Content-Type": "application/json"
+    }
+
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        response = await client.post(
+            f"{OPENMEMORY_URL}/query",
+            json={
+                "query": "Claude Code remember conversations",
+                "k": 3
+            },
+            headers=headers
+        )
+
+        if response.status_code == 200:
+            data = response.json()
+            matches = data.get("matches", [])
+            print(f"✅ Found {len(matches)} memories:")
+            for i, memory in enumerate(matches, 1):
+                content = memory.get("content", "")
+                score = memory.get("score", 0)
+                sector = memory.get("primary_sector", "")
+                print(f"\n   Result {i} (score: {score:.2f}, sector: {sector}):")
+                print(f"   {content[:100]}...")
+        else:
+            print(f"❌ Failed: {response.status_code} - {response.text}")
+
+
+async def test_mcp_integration():
+    """Run full MCP integration test."""
+    print("=" * 60)
+    print("OpenMemory MCP Server - Integration Test")
+    print("=" * 60)
+
+    # Test 1: Add memory
+    memory_id = await test_add_memory()
+
+    # Wait a bit for indexing
+    await asyncio.sleep(2)
+
+    # Test 2: Search memory
+    await test_search_memory()
+
+    print("\n" + "=" * 60)
+    print("✅ Integration test completed!")
+    print("=" * 60)
+    print("\nNext steps:")
+    print("1. Restart Claude Code to load the MCP server")
+    print("2. Try asking Claude Code to remember something")
+    print("3. Check Grafana dashboard for audit trail")
+    print("   → http://localhost:3000/d/cybermem-memory")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_mcp_integration())

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}

package/dist/commands/__tests__/backup.test.js

@@ -1,75 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const backup_1 = require("../backup");
-// Mock dependencies
-jest.mock('execa');
-jest.mock('fs');
-jest.mock('path', () => ({
-    ...jest.requireActual('path'),
-    resolve: jest.fn((...args) => args.join('/')),
-    basename: jest.fn((p) => p.split('/').pop() || ''),
-    dirname: jest.fn((p) => p.split('/').slice(0, -1).join('/') || '/'),
-}));
-// Mock console to keep output clean
-const originalConsoleLog = console.log;
-const originalConsoleError = console.error;
-describe('backup command', () => {
-    beforeAll(() => {
-        console.log = jest.fn();
-        console.error = jest.fn();
-    });
-    afterAll(() => {
-        console.log = originalConsoleLog;
-        console.error = originalConsoleError;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        // Default process.cwd
-        jest.spyOn(process, 'cwd').mockReturnValue('/mock/cwd');
-    });
-    it('should create a backup successfully when openmemory container exists', async () => {
-        // Mock docker inspect success
-        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
-        // Mock docker run success
-        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
-        // Mock fs.existsSync to true (file created)
-        fs_1.default.existsSync.mockReturnValue(true);
-        // Mock fs.statSync
-        fs_1.default.statSync.mockReturnValue({ size: 5 * 1024 * 1024 }); // 5MB
-        await (0, backup_1.backup)({});
-        // Expect docker inspect check
-        expect(execa_1.default).toHaveBeenCalledWith('docker', ['inspect', 'cybermem-openmemory']);
-        // Expect docker run tar
-        const tarCall = execa_1.default.mock.calls[1];
-        expect(tarCall[0]).toBe('docker');
-        expect(tarCall[1]).toContain('run');
-        expect(tarCall[1]).toContain('tar');
-        expect(tarCall[1]).toContain('czf');
-        // Check volumes from
-        expect(tarCall[1]).toContain('--volumes-from');
-        expect(tarCall[1]).toContain('cybermem-openmemory');
-    });
-    it('should fail if openmemory container does not exist', async () => {
-        // Mock inspect failure
-        execa_1.default.mockRejectedValueOnce(new Error('No such container'));
-        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
-        await (0, backup_1.backup)({});
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
-        expect(exitSpy).toHaveBeenCalledWith(1);
-    });
-    it('should error if backup file is not created', async () => {
-        execa_1.default.mockResolvedValue({ exitCode: 0 }); // inspect OK
-        execa_1.default.mockResolvedValue({ exitCode: 0 }); // run OK
-        // Mock file check false
-        fs_1.default.existsSync.mockReturnValue(false);
-        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
-        await (0, backup_1.backup)({});
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Backup failed'));
-        expect(exitSpy).toHaveBeenCalledWith(1);
-    });
-});

package/dist/commands/__tests__/restore.test.js

@@ -1,70 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const restore_1 = require("../restore");
-jest.mock('execa');
-jest.mock('fs');
-jest.mock('path', () => ({
-    ...jest.requireActual('path'),
-    resolve: jest.fn((...args) => args.join('/')),
-    basename: jest.fn((p) => p.split('/').pop() || ''),
-    dirname: jest.fn((p) => p.split('/').slice(0, -1).join('/') || '/'),
-}));
-const originalConsoleLog = console.log;
-const originalConsoleError = console.error;
-describe('restore command', () => {
-    beforeAll(() => {
-        console.log = jest.fn();
-        console.error = jest.fn();
-    });
-    afterAll(() => {
-        console.log = originalConsoleLog;
-        console.error = originalConsoleError;
-    });
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.spyOn(process, 'cwd').mockReturnValue('/mock/cwd');
-    });
-    it('should restore successfully', async () => {
-        // Mock file exists
-        fs_1.default.existsSync.mockReturnValue(true);
-        // Mock docker stop (success)
-        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
-        // Mock docker run tar (success)
-        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
-        // Mock docker start (success)
-        execa_1.default.mockResolvedValueOnce({ exitCode: 0 });
-        await (0, restore_1.restore)('backup.tar.gz', {});
-        // Check docker stop
-        expect(execa_1.default).toHaveBeenCalledWith('docker', ['stop', 'cybermem-openmemory']);
-        // Check docker run tar
-        const tarCall = execa_1.default.mock.calls[1];
-        expect(tarCall[0]).toBe('docker');
-        expect(tarCall[1]).toContain('run');
-        expect(tarCall[1]).toContain('tar xzf /backup/backup.tar.gz -C / && chown -R 1001:1001 /data');
-        // Check docker start
-        expect(execa_1.default).toHaveBeenCalledWith('docker', ['start', 'cybermem-openmemory']);
-    });
-    it('should ignore docker stop error (if container not running)', async () => {
-        fs_1.default.existsSync.mockReturnValue(true);
-        // Mock docker stop FAIL
-        execa_1.default.mockRejectedValueOnce(new Error('No such container'));
-        // Mock succeeding calls
-        execa_1.default.mockResolvedValue({ exitCode: 0 });
-        await (0, restore_1.restore)('backup.tar.gz', {});
-        // Should still proceed to restore
-        expect(execa_1.default).toHaveBeenCalledWith('docker', expect.arrayContaining(['run']));
-        expect(execa_1.default).toHaveBeenCalledWith('docker', ['start', 'cybermem-openmemory']);
-    });
-    it('should fail if backup file missing', async () => {
-        fs_1.default.existsSync.mockReturnValue(false);
-        const exitSpy = jest.spyOn(process, 'exit').mockImplementation((() => { }));
-        await (0, restore_1.restore)('mia.tar.gz', {});
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('not found'));
-        expect(exitSpy).toHaveBeenCalledWith(1);
-    });
-});

package/dist/commands/backup.js

@@ -1,52 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.backup = backup;
-const chalk_1 = __importDefault(require("chalk"));
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-async function backup(options) {
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const filename = `cybermem-backup-${timestamp}.tar.gz`;
-    const outputPath = path_1.default.resolve(process.cwd(), filename);
-    console.log(chalk_1.default.blue(`📦 Creating backup: ${filename}...`));
-    try {
-        // Check if container exists
-        try {
-            await (0, execa_1.default)('docker', ['inspect', 'cybermem-openmemory']);
-        }
-        catch (e) {
-            console.error(chalk_1.default.red('Error: cybermem-openmemory container not found. Is CyberMem installed?'));
-            process.exit(1);
-        }
-        // Use a transient alpine container to tar the /data volume
-        // We mount the current working directory to /backup in the container
-        // And we use --volumes-from to access the data volume of the running service
-        const cmd = [
-            'run', '--rm',
-            '--volumes-from', 'cybermem-openmemory',
-            '-v', `${process.cwd()}:/backup`,
-            'alpine',
-            'tar', 'czf', `/backup/${filename}`, '-C', '/', 'data'
-        ];
-        console.log(chalk_1.default.gray(`Running: docker ${cmd.join(' ')}`));
-        await (0, execa_1.default)('docker', cmd, { stdio: 'inherit' });
-        if (fs_1.default.existsSync(outputPath)) {
-            const stats = fs_1.default.statSync(outputPath);
-            const sizeMb = (stats.size / 1024 / 1024).toFixed(2);
-            console.log(chalk_1.default.green(`\n✅ Backup created successfully!`));
-            console.log(`File: ${chalk_1.default.bold(outputPath)}`);
-            console.log(`Size: ${sizeMb} MB`);
-        }
-        else {
-            throw new Error('Backup file not found after generation.');
-        }
-    }
-    catch (error) {
-        console.error(chalk_1.default.red('Backup failed:'), error);
-        process.exit(1);
-    }
-}