@cybermem/mcp 0.5.1 → 0.6.0

package/README.md

@@ -1,5 +1,5 @@
 # @cybermem/mcp
 
-Universal Long-Term Memory for AI Agents.
+CyberMem MCP Server — AI Memory via Model Context Protocol.
 
 🌐 [cybermem.dev](https://cybermem.dev) · 📖 [Docs](https://docs.cybermem.dev) · 📦 [GitHub](https://github.com/mikhailkogan17/cybermem)

package/dist/index.js

@@ -1,212 +1,205 @@
-#!/usr/bin/env node
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const chalk_1 = __importDefault(require("chalk"));
-const commander_1 = require("commander");
-const crypto_1 = __importDefault(require("crypto"));
-const execa_1 = __importDefault(require("execa"));
-const fs_1 = __importDefault(require("fs"));
-const inquirer_1 = __importDefault(require("inquirer"));
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const program = new commander_1.Command();
-program
-    .name('mcp')
-    .description('CyberMem - Deploy your AI memory server in one command')
-    .version('1.0.0')
-    .option('--rpi', 'Deploy to Raspberry Pi (default: local)')
-    .option('--vps', 'Deploy to VPS/Cloud server')
-    .option('-h, --host <host>', 'SSH Host (user@ip) for remote deployment')
-    .option('--remote-access', 'Enable Tailscale Funnel for HTTPS remote access')
-    .action(async (options) => {
-    // Determine target from flags
-    let target = 'local';
-    if (options.rpi)
-        target = 'rpi';
-    if (options.vps)
-        target = 'vps';
-    const useTailscale = options.remoteAccess;
-    console.log(chalk_1.default.blue(`Deploying CyberMem (${target})...`));
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const axios_1 = __importDefault(require("axios"));
+const cors_1 = __importDefault(require("cors"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const express_1 = __importDefault(require("express"));
+dotenv_1.default.config();
+// Parse CLI args for remote mode
+const args = process.argv.slice(2);
+const getArg = (name) => {
+    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 index_js_1.Server({
+    name: "cybermem-mcp",
+    version: "0.2.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+const tools = [
+    {
+        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(types_js_1.ListToolsRequestSchema, async () => ({
+    tools,
+}));
+// Create axios instance
+const apiClient = axios_1.default.create({
+    baseURL: API_URL,
+    headers: {
+        "Authorization": `Bearer ${API_KEY}`,
+    },
+});
+// Helper to get client with context
+function getClient(customHeaders = {}) {
+    // Identity is taken from currentClientName which is updated per-request in SSE mode
+    const clientName = customHeaders["X-Client-Name"] || currentClientName;
+    return {
+        ...apiClient,
+        get: (url, config) => apiClient.get(url, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        post: (url, data, config) => apiClient.post(url, data, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        put: (url, data, config) => apiClient.put(url, data, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        patch: (url, data, config) => apiClient.patch(url, data, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+        delete: (url, config) => apiClient.delete(url, { ...config, headers: { "X-Client-Name": clientName, ...config?.headers } }),
+    };
+}
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
     try {
-        // Resolve Template Directory (Support both Dev and Prod)
-        let templateDir = path_1.default.resolve(__dirname, '../templates');
-        if (!fs_1.default.existsSync(templateDir)) {
-            templateDir = path_1.default.resolve(__dirname, '../../templates');
-        }
-        if (!fs_1.default.existsSync(templateDir)) {
-            templateDir = path_1.default.resolve(process.cwd(), 'packages/cli/templates');
-        }
-        if (!fs_1.default.existsSync(templateDir)) {
-            throw new Error(`Templates not found at ${templateDir}. Please ensure package is built correctly.`);
-        }
-        if (target === 'local') {
-            const composeFile = path_1.default.join(templateDir, 'docker-compose.yml');
-            const internalEnvExample = path_1.default.join(templateDir, 'envs/local.example');
-            if (!fs_1.default.existsSync(composeFile)) {
-                console.error(chalk_1.default.red(`Internal Error: Template not found at ${composeFile}`));
-                process.exit(1);
+        switch (name) {
+            case "add_memory": {
+                const response = await getClient().post("/add", args);
+                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
             }
-            // Home Directory Config
-            const homeDir = os_1.default.homedir();
-            const configDir = path_1.default.join(homeDir, '.cybermem');
-            const envFile = path_1.default.join(configDir, '.env');
-            const dataDir = path_1.default.join(configDir, 'data');
-            // 1. Ensure ~/.cybermem exists
-            if (!fs_1.default.existsSync(configDir)) {
-                fs_1.default.mkdirSync(configDir, { recursive: true });
-                fs_1.default.mkdirSync(dataDir, { recursive: true });
+            case "query_memory": {
+                const response = await getClient().post("/query", args);
+                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
             }
-            // 2. Local Mode: Simplified setup without mandatory API key
-            if (!fs_1.default.existsSync(envFile)) {
-                console.log(chalk_1.default.yellow(`Initializing local configuration in ${configDir}...`));
-                const envContent = fs_1.default.readFileSync(internalEnvExample, 'utf-8');
-                fs_1.default.writeFileSync(envFile, envContent);
-                console.log(chalk_1.default.green(`Created .env at ${envFile}`));
+            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) }] };
             }
-            console.log(chalk_1.default.blue('Starting CyberMem services in Local Mode...'));
-            await (0, execa_1.default)('docker-compose', [
-                '-f', composeFile,
-                '--env-file', envFile,
-                '--project-name', 'cybermem',
-                'up', '-d', '--remove-orphans'
-            ], {
-                stdio: 'inherit',
-                env: {
-                    ...process.env,
-                    DATA_DIR: dataDir,
-                    CYBERMEM_ENV_PATH: envFile,
-                    CYBERMEM_API_KEY: ''
-                }
-            });
-            console.log(chalk_1.default.green('\n🎉 CyberMem Installed!'));
-            console.log('');
-            console.log(chalk_1.default.bold('Next Steps:'));
-            console.log(`  1. Open ${chalk_1.default.underline('http://localhost:3000/client-connect')} to connect your MCP clients`);
-            console.log(`  2. Default password: ${chalk_1.default.bold('admin')} (you'll be prompted to change it)`);
-            console.log('');
-            console.log(chalk_1.default.dim('Local mode is active: No API key required for connections from this laptop.'));
-        }
-        else if (target === 'rpi') {
-            const composeFile = path_1.default.join(templateDir, 'docker-compose.yml');
-            const internalEnvExample = path_1.default.join(templateDir, 'envs/rpi.example');
-            let sshHost = options.host;
-            if (!sshHost) {
-                const answers = await inquirer_1.default.prompt([
-                    {
-                        type: 'input',
-                        name: 'host',
-                        message: 'Enter SSH Host (e.g. pi@raspberrypi.local):',
-                        validate: (input) => input.includes('@') ? true : 'Format must be user@host'
-                    }
-                ]);
-                sshHost = answers.host;
+            case "delete_memory": {
+                const { id } = args;
+                await getClient().delete(`/${id}`);
+                return { content: [{ type: "text", text: `Memory ${id} deleted` }] };
             }
-            console.log(chalk_1.default.blue(`Remote deploying to ${sshHost}...`));
-            // 1. Create remote directory
-            await (0, execa_1.default)('ssh', [sshHost, 'mkdir -p ~/.cybermem/data']);
-            // 2. Initial Env Setup (if missing)
-            try {
-                await (0, execa_1.default)('ssh', [sshHost, '[ -f ~/.cybermem/.env ]']);
-                console.log(chalk_1.default.gray('Remote .env exists, skipping generation.'));
+            case "update_memory": {
+                const { id, ...updates } = args;
+                const response = await getClient().patch(`/${id}`, updates);
+                return { content: [{ type: "text", text: JSON.stringify(response.data) }] };
             }
-            catch (e) {
-                console.log(chalk_1.default.yellow('Generating remote .env...'));
-                let envContent = fs_1.default.readFileSync(internalEnvExample, 'utf-8');
-                const newKey = `sk-${crypto_1.default.randomBytes(16).toString('hex')}`;
-                if (envContent.includes('CYBERMEM_API_KEY=')) {
-                    envContent = envContent.replace(/CYBERMEM_API_KEY=.*/, `CYBERMEM_API_KEY=${newKey}`);
-                }
-                const tempEnv = path_1.default.join(os_1.default.tmpdir(), 'cybermem-rpi.env');
-                fs_1.default.writeFileSync(tempEnv, envContent);
-                await (0, execa_1.default)('scp', [tempEnv, `${sshHost}:~/.cybermem/.env`]);
-                fs_1.default.unlinkSync(tempEnv);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        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 = (0, express_1.default)();
+        app.use((0, cors_1.default)());
+        const port = process.env.PORT || 8627;
+        let transport = null;
+        app.get("/sse", async (req, res) => {
+            // Extract client name from header
+            const clientName = req.headers["x-client-name"];
+            if (clientName) {
+                currentClientName = clientName;
             }
-            // 3. Copy Docker Compose
-            console.log(chalk_1.default.blue('Uploading templates...'));
-            await (0, execa_1.default)('scp', [composeFile, `${sshHost}:~/.cybermem/docker-compose.yml`]);
-            // 4. Run Docker Compose Remotely
-            console.log(chalk_1.default.blue('Starting services on RPi...'));
-            // DOCKER_DEFAULT_PLATFORM=linux/arm64 forces arm64 images on RPi with 64-bit kernel but 32-bit Docker
-            const remoteCmd = `
-                export CYBERMEM_ENV_PATH=~/.cybermem/.env
-                export DATA_DIR=~/.cybermem/data
-                export DOCKER_DEFAULT_PLATFORM=linux/arm64
-                docker-compose -f ~/.cybermem/docker-compose.yml up -d --remove-orphans
-            `;
-            await (0, execa_1.default)('ssh', [sshHost, remoteCmd], { stdio: 'inherit' });
-            console.log(chalk_1.default.green('\n✅ RPi deployment successful!'));
-            const hostIp = sshHost.split('@')[1];
-            console.log(chalk_1.default.bold('Access Points (LAN):'));
-            console.log(`  - Dashboard:   ${chalk_1.default.underline(`http://${hostIp}:3000`)} (admin/admin)`);
-            console.log(`  - OpenMemory:  ${chalk_1.default.underline(`http://${hostIp}:8080`)}`);
-            // Tailscale Funnel setup
-            if (useTailscale) {
-                console.log(chalk_1.default.blue('\n🔗 Setting up Remote Access (Tailscale Funnel)...'));
-                try {
-                    try {
-                        await (0, execa_1.default)('ssh', [sshHost, 'which tailscale']);
-                    }
-                    catch (e) {
-                        console.log(chalk_1.default.yellow('  Tailscale not found. Installing...'));
-                        await (0, execa_1.default)('ssh', [sshHost, 'curl -fsSL https://tailscale.com/install.sh | sh'], { stdio: 'inherit' });
-                    }
-                    console.log(chalk_1.default.blue('  Ensuring Tailscale is up...'));
-                    try {
-                        await (0, execa_1.default)('ssh', [sshHost, 'tailscale status']);
-                    }
-                    catch (e) {
-                        console.log(chalk_1.default.yellow('  ⚠️  Tailscale authentication required. Please follow the prompts:'));
-                        await (0, execa_1.default)('ssh', [sshHost, 'sudo tailscale up'], { stdio: 'inherit' });
-                    }
-                    console.log(chalk_1.default.blue('  Configuring HTTPS Funnel (requires sudo access)...'));
-                    console.log(chalk_1.default.gray('  You may be prompted for your RPi password.'));
-                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve reset'], { stdio: 'inherit' }).catch(() => { });
-                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve --bg --set-path /cybermem http://127.0.0.1:8626'], { stdio: 'inherit' });
-                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale serve --bg http://127.0.0.1:3000'], { stdio: 'inherit' });
-                    await (0, execa_1.default)('ssh', ['-t', sshHost, 'sudo tailscale funnel --bg 443'], { stdio: 'inherit' });
-                    const { stdout } = await (0, execa_1.default)('ssh', [sshHost, "tailscale status --json | jq -r '.Self.DNSName' | sed 's/\\.$//'"]);
-                    const dnsName = stdout.trim();
-                    console.log(chalk_1.default.green('\n🌐 Remote Access Active (HTTPS):'));
-                    console.log(`  - Dashboard: ${chalk_1.default.underline(`https://${dnsName}/`)}`);
-                    console.log(`  - MCP API:   ${chalk_1.default.underline(`https://${dnsName}/cybermem/mcp`)}`);
-                }
-                catch (e) {
-                    console.log(chalk_1.default.red('\n❌ Remote Access setup failed:'));
-                    console.error(e);
-                    console.log(chalk_1.default.gray('Manual setup: curl -fsSL https://tailscale.com/install.sh | sh && sudo tailscale up'));
-                }
+            transport = new sse_js_1.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"];
+            if (clientName) {
+                currentClientName = clientName;
+            }
+            if (transport) {
+                await transport.handlePostMessage(req, res);
             }
             else {
-                console.log(chalk_1.default.gray('\n💡 For remote access, re-run with: npx @cybermem/mcp --rpi --remote-access'));
+                res.status(400).send("Session not established");
             }
-        }
-        else if (target === 'vps') {
-            console.log(chalk_1.default.yellow('VPS deployment is similar to RPi.'));
-            console.log(chalk_1.default.blue('\n📋 VPS Deployment Steps:'));
-            console.log('1. Run: npx @cybermem/mcp --rpi --host user@your-vps-ip');
-            console.log('2. For HTTPS, choose one of:');
-            console.log(chalk_1.default.gray('   a) Tailscale Funnel: --remote-access flag'));
-            console.log(chalk_1.default.gray('   b) Caddy (recommended for public VPS):'));
-            console.log(chalk_1.default.gray('      - Install Caddy: sudo apt install caddy'));
-            console.log(chalk_1.default.gray('      - Configure /etc/caddy/Caddyfile:'));
-            console.log(chalk_1.default.cyan(`
-        cybermem.yourdomain.com {
-            reverse_proxy localhost:3000
-        }
-        api.cybermem.yourdomain.com {
-            reverse_proxy localhost:8080
-        }
-      `));
-            console.log(chalk_1.default.gray('      - Restart: sudo systemctl restart caddy'));
-            console.log(chalk_1.default.green('\n📚 Full docs: https://cybermem.dev/docs#https'));
-        }
+        });
+        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`);
+        });
     }
-    catch (error) {
-        console.error(chalk_1.default.red('Deployment failed:'), error);
-        process.exit(1);
+    else {
+        const transport = new stdio_js_1.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);
 });
-program.parse(process.argv);

package/package.json

@@ -1,48 +1,49 @@
 {
   "name": "@cybermem/mcp",
-  "version": "0.5.1",
-  "description": "CyberMem — Universal Long-Term Memory for AI Agents",
-  "homepage": "https://cybermem.dev",
+  "version": "0.6.0",
+  "description": "CyberMem MCP Server (TypeScript)",
+  "main": "dist/index.js",
+  "bin": {
+    "cybermem-mcp": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/mikhailkogan17/cybermem.git",
-    "directory": "packages/cli"
+    "directory": "packages/mcp"
   },
-  "bin": {
-    "mcp": "./dist/index.js"
-  },
-  "files": [
-    "dist",
-    "templates"
-  ],
-  "scripts": {
-    "build": "tsc && cp -r templates dist/",
-    "start": "ts-node src/index.ts",
-    "test:e2e": "ts-node e2e/test-mcp.ts",
-    "prepublishOnly": "npm run build"
+  "homepage": "https://cybermem.dev",
+  "bugs": {
+    "url": "https://github.com/mikhailkogan17/cybermem/issues"
   },
   "keywords": [
-    "cybermem",
-    "cli",
-    "ai",
-    "mcp"
+    "mcp",
+    "ai-memory",
+    "claude",
+    "cursor",
+    "antigravity",
+    "openmemory",
+    "llm"
   ],
-  "author": "Mikhail Kogan",
+  "author": "Mikhail Kogan <mikhailkogan17@gmail.com>",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "type": "commonjs",
   "dependencies": {
-    "chalk": "^4.1.2",
-    "commander": "^9.0.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.13.2",
+    "cors": "^2.8.5",
     "dotenv": "^16.0.0",
-    "execa": "^5.1.1",
-    "inquirer": "^8.2.0",
-    "ora": "^5.4.1"
+    "express": "^5.2.1"
   },
   "devDependencies": {
-    "@types/inquirer": "^9.0.3",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
     "@types/node": "^18.0.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.0"

package/requirements.txt

@@ -0,0 +1,2 @@
+mcp>=0.9.0
+httpx>=0.27.0