memtrace-mcp-server 1.0.0

package/index.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+const API_URL = process.env.MEMTRACE_API_URL || 'http://localhost:3000/api/v1';
+const TOKEN = process.env.MEMTRACE_TOKEN;
+
+if (!TOKEN) {
+  console.error('Error: MEMTRACE_TOKEN environment variable is required');
+  process.exit(1);
+}
+
+// Helper to make API calls
+async function apiCall(endpoint, method = 'GET', body = null) {
+  const options = {
+    method,
+    headers: {
+      'Authorization': `Bearer ${TOKEN}`,
+      'Content-Type': 'application/json',
+    },
+  };
+
+  if (body) {
+    options.body = JSON.stringify(body);
+  }
+
+  const response = await fetch(`${API_URL}${endpoint}`, options);
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: 'Request failed' }));
+    throw new Error(error.error || `HTTP ${response.status}`);
+  }
+
+  return response.json();
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'memtrace',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: 'search_knowledge',
+        description: 'Search for relevant knowledge items using semantic search. Use this to find information that might help with the current task.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'The search query to find relevant knowledge',
+            },
+            limit: {
+              type: 'number',
+              description: 'Maximum number of results to return (default: 10)',
+            },
+          },
+          required: ['query'],
+        },
+      },
+      {
+        name: 'push_knowledge',
+        description: 'Store new knowledge items for future reference. Use this to save important information, decisions, preferences, or learnings.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            items: {
+              type: 'array',
+              description: 'Array of knowledge items to store',
+              items: {
+                type: 'object',
+                properties: {
+                  title: {
+                    type: 'string',
+                    description: 'Short descriptive title for the knowledge',
+                  },
+                  content: {
+                    type: 'string',
+                    description: 'The knowledge content to store',
+                  },
+                  category: {
+                    type: 'string',
+                    enum: ['fact', 'preference', 'procedure', 'decision', 'insight', 'other'],
+                    description: 'Category of the knowledge',
+                  },
+                  tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Tags for organizing the knowledge',
+                  },
+                },
+                required: ['title', 'content'],
+              },
+            },
+          },
+          required: ['items'],
+        },
+      },
+      {
+        name: 'pull_knowledge',
+        description: 'Retrieve recent knowledge items. Use this to get context from previous sessions.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            limit: {
+              type: 'number',
+              description: 'Maximum number of items to retrieve (default: 10)',
+            },
+            category: {
+              type: 'string',
+              description: 'Filter by category',
+            },
+          },
+        },
+      },
+      {
+        name: 'get_startup_context',
+        description: 'Get startup context including pinned knowledge and recent items. Call this at the beginning of a session.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_id: {
+              type: 'string',
+              description: 'Optional project identifier to filter context',
+            },
+            max_tokens: {
+              type: 'number',
+              description: 'Maximum tokens budget for the context (default: 4000)',
+            },
+          },
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'search_knowledge': {
+        const results = await apiCall('/mcp/knowledge/search', 'POST', {
+          query: args.query,
+          limit: args.limit || 10,
+        });
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'push_knowledge': {
+        const result = await apiCall('/mcp/knowledge/push', 'POST', {
+          items: args.items,
+        });
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Successfully stored ${result.items_created} knowledge item(s).`,
+            },
+          ],
+        };
+      }
+
+      case 'pull_knowledge': {
+        const results = await apiCall('/mcp/knowledge/pull', 'POST', {
+          limit: args.limit || 10,
+          category: args.category,
+        });
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'get_startup_context': {
+        const context = await apiCall('/context/startup', 'POST', {
+          project_id: args.project_id,
+          max_tokens: args.max_tokens || 4000,
+        });
+        return {
+          content: [
+            {
+              type: 'text',
+              text: context.context || JSON.stringify(context, null, 2),
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// List resources
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return {
+    resources: [
+      {
+        uri: 'memtrace://knowledge/recent',
+        name: 'Recent Knowledge',
+        description: 'Recently added or accessed knowledge items',
+        mimeType: 'application/json',
+      },
+      {
+        uri: 'memtrace://knowledge/pinned',
+        name: 'Pinned Knowledge',
+        description: 'Important pinned knowledge items',
+        mimeType: 'application/json',
+      },
+    ],
+  };
+});
+
+// Read resources
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+
+  try {
+    if (uri === 'memtrace://knowledge/recent') {
+      const results = await apiCall('/mcp/knowledge/pull', 'POST', { limit: 20 });
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: 'application/json',
+            text: JSON.stringify(results, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (uri === 'memtrace://knowledge/pinned') {
+      const results = await apiCall('/knowledge?pinned=true&limit=20', 'GET');
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: 'application/json',
+            text: JSON.stringify(results.data || [], null, 2),
+          },
+        ],
+      };
+    }
+
+    throw new Error(`Unknown resource: ${uri}`);
+  } catch (error) {
+    throw new Error(`Failed to read resource: ${error.message}`);
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('MemTrace MCP server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "memtrace-mcp-server",
+  "version": "1.0.0",
+  "description": "MCP server for MemTrace - AI context memory service",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "memtrace-mcp-server": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": ["mcp", "memtrace", "ai", "context", "memory", "claude"],
+  "author": "MemTrace",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}