@cybermem/mcp 0.5.3 → 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,30 +1,205 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
-const backup_1 = require("./commands/backup");
-const deploy_1 = require("./commands/deploy");
-const restore_1 = require("./commands/restore");
-const program = new commander_1.Command();
-program
-    .name('mcp')
-    .description('CyberMem - Deploy your AI memory server in one command')
-    .version('1.0.0');
-// Default Command: Deploy
-program
-    .command('deploy', { isDefault: true })
-    .description('Deploy CyberMem (Default)')
-    .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(deploy_1.deploy);
-program
-    .command('backup')
-    .description('Backup CyberMem data to a tarball')
-    .action(backup_1.backup);
-program
-    .command('restore')
-    .description('Restore CyberMem data from a backup file')
-    .argument('<file>', 'Backup file to restore')
-    .action(restore_1.restore);
-program.parse(process.argv);
+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 {
+        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;
+                await getClient().delete(`/${id}`);
+                return { content: [{ type: "text", text: `Memory ${id} deleted` }] };
+            }
+            case "update_memory": {
+                const { id, ...updates } = args;
+                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) {
+        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;
+            }
+            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 {
+                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 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);
+});

package/package.json

@@ -1,48 +1,49 @@
 {
   "name": "@cybermem/mcp",
-  "version": "0.5.3",
-  "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

package/server.py

@@ -0,0 +1,347 @@
+#!/usr/bin/env python3
+"""
+CyberMem MCP Server
+
+MCP server that exposes shared memory functionality to several LLM.
+"""
+
+import asyncio
+import os
+from typing import Any
+
+import httpx
+from mcp import types
+from mcp.server import NotificationOptions, Server
+from mcp.server.models import InitializationOptions
+from mcp.server.stdio import stdio_server
+
+# CyberMem configuration (OpenMemory backend)
+OPENMEMORY_URL = os.getenv("OPENMEMORY_URL", "http://localhost:8080")
+CYBERMEM_API_KEY = os.getenv("CYBERMEM_API_KEY", "dev-secret-key")
+
+# Create MCP server instance
+server = Server("cybermem")
+
+
+@server.list_tools()
+async def handle_list_tools() -> list[types.Tool]:
+    """List available memory management tools."""
+    return [
+        types.Tool(
+            name="add_memory",
+            description="Store information in long-term memory. Use this to remember important facts, decisions, or context for future conversations.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "content": {
+                        "type": "string",
+                        "description": "The information to remember (text content)",
+                    },
+                    "metadata": {
+                        "type": "object",
+                        "description": "Optional metadata (tags, category, importance, etc.)",
+                        "additionalProperties": True,
+                    },
+                },
+                "required": ["content"],
+            },
+        ),
+        types.Tool(
+            name="search_memory",
+            description="Search through stored memories to find relevant information. Use this to recall past conversations, decisions, or facts.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "What to search for (semantic search query)",
+                    },
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum number of results (default: 5)",
+                        "default": 5,
+                    },
+                },
+                "required": ["query"],
+            },
+        ),
+        types.Tool(
+            name="list_memories",
+            description="List recent memories stored in the system. Useful for browsing what has been remembered.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "number",
+                        "description": "Maximum number of memories to retrieve (default: 10)",
+                        "default": 10,
+                    }
+                },
+            },
+        ),
+        types.Tool(
+            name="delete_memory",
+            description="Delete a specific memory by its ID. Use this to remove outdated or incorrect information.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "memory_id": {
+                        "type": "string",
+                        "description": "The UUID of the memory to delete",
+                    }
+                },
+                "required": ["memory_id"],
+            },
+        ),
+        types.Tool(
+            name="update_memory",
+            description="Update an existing memory's content, tags, or metadata.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "memory_id": {
+                        "type": "string",
+                        "description": "The UUID of the memory to update",
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "New content for the memory (optional)",
+                    },
+                    "tags": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "New tags for the memory (optional)",
+                    },
+                    "metadata": {
+                        "type": "object",
+                        "description": "New metadata for the memory (optional)",
+                        "additionalProperties": True,
+                    },
+                },
+                "required": ["memory_id"],
+            },
+        ),
+    ]
+
+
+@server.call_tool()
+async def handle_call_tool(
+    name: str, arguments: dict[str, Any]
+) -> list[types.TextContent]:
+    """Handle tool execution requests."""
+
+    # Get client info from MCP context
+    client_name, client_version = "unknown", "unknown"
+    try:
+        ctx = server.request_context
+        if hasattr(ctx, "session"):
+            session = ctx.session
+            if hasattr(session, "_client_params"):
+                client_params = session._client_params
+                if client_params and hasattr(client_params, "clientInfo"):
+                    client_info = client_params.clientInfo
+                    client_name = client_info.name or "unknown"
+                    client_version = client_info.version or "unknown"
+    except Exception:
+        pass
+
+    headers = {
+        "Authorization": f"Bearer {CYBERMEM_API_KEY}",
+        "Content-Type": "application/json",
+        "X-Client-Name": client_name,
+        "X-Client-Version": client_version,
+    }
+
+    async with httpx.AsyncClient(timeout=30.0) as client:
+        try:
+            if name == "add_memory":
+                # Store memory in OpenMemory
+                content = arguments.get("content")
+                metadata = arguments.get("metadata", {})
+
+                response = await client.post(
+                    f"{OPENMEMORY_URL}/memory/add",
+                    json={"content": content, "metadata": metadata},
+                    headers=headers,
+                )
+                response.raise_for_status()
+                result = response.json()
+
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"✅ Memory stored successfully!\n\nID: {result.get('id')}\nChunks: {result.get('chunks')}\nSectors: {', '.join(result.get('sectors', []))}",
+                    )
+                ]
+
+            elif name == "search_memory":
+                # Search memories in OpenMemory
+                query = arguments.get("query")
+                limit = arguments.get("limit", 5)
+
+                response = await client.post(
+                    f"{OPENMEMORY_URL}/memory/query",
+                    json={"query": query, "k": limit},
+                    headers=headers,
+                )
+                response.raise_for_status()
+                data = response.json()
+                matches = data.get("matches", [])
+
+                if not matches:
+                    return [
+                        types.TextContent(
+                            type="text",
+                            text="🔍 No memories found matching your query.",
+                        )
+                    ]
+
+                # Format search results
+                formatted_results = []
+                for i, memory in enumerate(matches, 1):
+                    content = memory.get("content", "")
+                    score = memory.get("score", 0)
+                    sector = memory.get("primary_sector", "")
+
+                    formatted_results.append(
+                        f"**Result {i}** (score: {score:.2f}, sector: {sector})\n{content}\n"
+                    )
+
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"🔍 Found {len(matches)} memories:\n\n"
+                        + "\n".join(formatted_results),
+                    )
+                ]
+
+            elif name == "list_memories":
+                # List recent memories
+                limit = arguments.get("limit", 10)
+
+                # Note: OpenMemory doesn't have a /list endpoint yet,
+                # so we'll do a broad query with generic term
+                response = await client.post(
+                    f"{OPENMEMORY_URL}/memory/query",
+                    json={"query": "memory context", "k": limit},
+                    headers=headers,
+                )
+                response.raise_for_status()
+                data = response.json()
+                matches = data.get("matches", [])
+
+                if not matches:
+                    return [
+                        types.TextContent(
+                            type="text", text="📋 No memories stored yet."
+                        )
+                    ]
+
+                # Format list
+                formatted_list = []
+                for i, memory in enumerate(matches, 1):
+                    content = memory.get("content", "")
+                    sector = memory.get("primary_sector", "")
+                    # Truncate long content
+                    if len(content) > 100:
+                        content = content[:97] + "..."
+                    formatted_list.append(f"{i}. [{sector}] {content}")
+
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"📋 Recent memories ({len(matches)}):\n\n"
+                        + "\n".join(formatted_list),
+                    )
+                ]
+
+            elif name == "delete_memory":
+                # Delete memory by ID
+                memory_id = arguments.get("memory_id")
+
+                try:
+                    response = await client.delete(
+                        f"{OPENMEMORY_URL}/memory/{memory_id}", headers=headers
+                    )
+                    response.raise_for_status()
+                    result = response.json()
+                    status = result.get("ok", "deleted")
+                except httpx.HTTPStatusError as e:
+                    # Workaround: OpenMemory returns 500 on successful delete (bug in OpenMemory)
+                    # We'll treat it as success since the memory is actually deleted
+                    if e.response.status_code == 500:
+                        status = "deleted (500 ignored - OpenMemory bug)"
+                    else:
+                        raise
+
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"🗑️ Memory deleted successfully!\n\nID: {memory_id}\nStatus: {status}",
+                    )
+                ]
+
+            elif name == "update_memory":
+                # Update memory by ID
+                memory_id = arguments.get("memory_id")
+                content = arguments.get("content")
+                tags = arguments.get("tags")
+                metadata = arguments.get("metadata")
+
+                payload = {}
+                if content:
+                    payload["content"] = content
+                if tags:
+                    payload["tags"] = tags
+                if metadata:
+                    payload["metadata"] = metadata
+
+                response = await client.patch(
+                    f"{OPENMEMORY_URL}/memory/{memory_id}",
+                    json=payload,
+                    headers=headers,
+                )
+                response.raise_for_status()
+                result = response.json()
+
+                return [
+                    types.TextContent(
+                        type="text",
+                        text=f"✏️ Memory updated successfully!\n\nID: {result.get('id', memory_id)}",
+                    )
+                ]
+
+            else:
+                raise ValueError(f"Unknown tool: {name}")
+
+        except httpx.HTTPStatusError as e:
+            return [
+                types.TextContent(
+                    type="text",
+                    text=f"❌ API Error: {e.response.status_code}\n{e.response.text}",
+                )
+            ]
+        except Exception as e:
+            return [types.TextContent(type="text", text=f"❌ Error: {str(e)}")]
+
+
+async def main():
+    """Run the MCP server."""
+
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(
+            read_stream,
+            write_stream,
+            InitializationOptions(
+                server_name="cybermem",
+                server_version="0.1.0",
+                capabilities=server.get_capabilities(
+                    notification_options=NotificationOptions(),
+                    experimental_capabilities={},
+                ),
+            ),
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())