purmemo-mcp 3.2.0 → 3.2.2

package/README.md

@@ -50,13 +50,15 @@ This repository contains the **open-source MCP protocol wrapper** that connects
 
 ### 1. Get Your API Key
 
-Sign up at [app.purmemo.ai](https://app.purmemo.ai) to get your free API key.
+1. Sign up at [purmemo.ai/register](https://www.purmemo.ai/register)
+2. Sign in and go to [purmemo.ai/settings](https://www.purmemo.ai/settings)
+3. Click "API Keys" tab → "Create New Key"
+4. Name it (e.g., "Claude Desktop") → "Create Key"
+5. Copy the key immediately (won't be shown again)
 
-### 2. Install the MCP Server
+### 2. No Installation Needed!
 
-```bash
-npm install -g purmemo-mcp
-```
+Claude Desktop will automatically download the MCP server using `npx` (see configuration below).
 
 ### 3. Configure Claude Desktop
 
@@ -232,9 +234,8 @@ The following remain proprietary:
 ## 🆘 Support
 
 - 📧 Email: support@purmemo.ai
-- 💬 Discord: [discord.gg/purmemo](https://discord.gg/purmemo)
 - 🐛 Issues: [GitHub Issues](https://github.com/coladapo/purmemo-mcp/issues)
-- 🌐 Status: [status.purmemo.ai](https://status.purmemo.ai)
+- 🌐 Website: [purmemo.ai](https://purmemo.ai)
 
 ## 🗺️ Roadmap
 

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "purmemo-mcp",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "Official Model Context Protocol (MCP) server for Purmemo - Your AI-powered second brain with 5 complete tools",
-  "main": "src/server-final.js",
+  "main": "src/server.js",
   "type": "module",
   "bin": {
-    "purmemo-mcp": "./src/server-final.js",
+    "purmemo-mcp": "./src/server.js",
     "purmemo-mcp-setup": "./src/setup.js"
   },
   "files": [
-    "src/",
-    "bin/",
+    "src/server.js",
+    "src/setup.js",
+    "src/index.js",
+    "src/auth/",
+    "src/diagnose.js",
+    "src/diagnose-production.js",
+    "src/setup-emergency.js",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "start": "node src/server-final.js",
+    "start": "node src/server.js",
     "setup": "node src/setup.js setup",
     "status": "node src/setup.js status",
     "logout": "node src/setup.js logout",

package/src/server.js

@@ -1,28 +1,22 @@
 #!/usr/bin/env node
 /**
- * pūrmemo MCP Server - Secure Thin Client v1.1.2
- * All processing happens on pūrmemo servers
+ * Final Working Purmemo MCP Server v3.1.0
+ * Fixed search endpoint to use correct HTTP method
  */
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import fetch from 'node-fetch';
-
-// Check for required environment variables
-const API_KEY = process.env.PUO_MEMO_API_KEY;
-const API_URL = process.env.PUO_MEMO_API_URL || 'https://api.puo-memo.com';
-
-if (!API_KEY) {
-  console.error('❌ PUO_MEMO_API_KEY environment variable is required');
-  console.error('Get your API key at https://app.purmemo.ai');
-  process.exit(1);
-}
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+// Configuration
+const API_URL = process.env.PURMEMO_API_URL || 'https://api.purmemo.ai';
+const USER_AGENT = 'purmemo-mcp/3.1.0';
+
+// Store auth token in memory
+let authToken = null;
+let tokenExpiry = null;
 
-// Tool definitions - just schemas, no implementation
+// Tool definitions
 const TOOLS = [
   {
     name: 'memory',
@@ -32,8 +26,7 @@ const TOOLS = [
       properties: {
         content: { type: 'string', description: 'What to remember' },
         title: { type: 'string', description: 'Optional: Title for the memory' },
-        tags: { type: 'array', items: { type: 'string' }, description: 'Optional: Tags' },
-        attachments: { type: 'array', items: { type: 'string' }, description: 'Optional: File paths or URLs' }
+        tags: { type: 'array', items: { type: 'string' }, description: 'Optional: Tags' }
       },
       required: ['content']
     }
@@ -45,23 +38,19 @@ const TOOLS = [
       type: 'object',
       properties: {
         query: { type: 'string', description: 'What to search for' },
-        limit: { type: 'integer', description: 'How many results (default: 10)', default: 10 },
-        search_type: { type: 'string', enum: ['keyword', 'semantic', 'hybrid'], default: 'hybrid' }
-      }
+        limit: { type: 'integer', description: 'How many results (default: 10)', default: 10 }
+      },
+      required: ['query']
     }
   },
   {
     name: 'entities',
-    description: '🧠 List entities or get entity graph',
+    description: '🏷️ Extract entities from memories',
     inputSchema: {
       type: 'object',
       properties: {
-        entity_name: { type: 'string', description: 'Entity to get graph for' },
-        entity_type: { 
-          type: 'string', 
-          enum: ['person', 'organization', 'location', 'event', 'project'],
-          description: 'Filter by entity type'
-        }
+        entity_name: { type: 'string', description: 'Optional: Specific entity to look up' },
+        entity_type: { type: 'string', description: 'Optional: Filter by entity type' }
       }
     }
   },
@@ -72,9 +61,10 @@ const TOOLS = [
       type: 'object',
       properties: {
         memory_id: { type: 'string', description: 'Memory ID to attach files to' },
-        file_paths: { type: 'array', items: { type: 'string' }, description: 'File paths or URLs' }
+        files: { type: 'array', items: { type: 'string' }, description: 'File paths or URLs to attach' },
+        description: { type: 'string', description: 'Optional: Description of the attachments' }
       },
-      required: ['memory_id', 'file_paths']
+      required: ['memory_id', 'files']
     }
   },
   {
@@ -83,154 +73,408 @@ const TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        memory_id: { type: 'string', description: 'ID of the memory to correct' },
-        correction: { type: 'string', description: 'The corrected content' },
-        reason: { type: 'string', description: 'Optional: Reason for the correction' }
+        memory_id: { type: 'string', description: 'Memory ID to add correction to' },
+        correction: { type: 'string', description: 'The correction text or details' },
+        type: { type: 'string', enum: ['factual', 'spelling', 'update', 'clarification'], description: 'Type of correction', default: 'update' }
       },
       required: ['memory_id', 'correction']
     }
   }
 ];
 
-// Create MCP server
+// Create server
 const server = new Server(
-  {
-    name: 'purmemo',
-    vendor: 'pūrmemo',
-    version: '1.1.2'
-  },
-  {
-    capabilities: {
-      tools: {}
+  { name: 'purmemo-mcp', version: '3.2.0' },
+  { capabilities: { tools: {} } }
+);
+
+// Authentication function supporting both API key and login
+async function authenticate() {
+  // Check for API key first (more secure)
+  const apiKey = process.env.PURMEMO_API_KEY;
+  if (apiKey) {
+    // API keys don't expire, return directly
+    return apiKey;
+  }
+  
+  // Fallback to token-based auth if no API key
+  if (authToken && tokenExpiry && Date.now() < tokenExpiry) {
+    return authToken;
+  }
+  
+  // Get credentials from environment
+  const email = process.env.PURMEMO_EMAIL || process.env.PUO_MEMO_EMAIL || 'demo@puo-memo.com';
+  const password = process.env.PURMEMO_PASSWORD || process.env.PUO_MEMO_PASSWORD || 'demodemo123';
+  
+  try {
+    const response = await fetch(`${API_URL}/api/auth/login`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'User-Agent': USER_AGENT
+      },
+      body: new URLSearchParams({
+        username: email,  // OAuth2 uses 'username' field for email
+        password: password,
+        grant_type: 'password'
+      })
+    });
+    
+    if (response.ok) {
+      const data = await response.json();
+      authToken = data.access_token;
+      // Token expires in 1 hour, refresh 5 minutes early
+      tokenExpiry = Date.now() + (55 * 60 * 1000);
+      return authToken;
     }
+  } catch (error) {
+    // Silent failure for MCP compatibility
   }
-);
+  
+  return null;
+}
 
-// Handle tool listing
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: TOOLS
-}));
+// Create auth message
+function createAuthMessage(toolName) {
+  return {
+    content: [{
+      type: 'text',
+      text: `🔐 Authentication Required\n\n` +
+            `To use ${toolName}, please set up credentials:\n\n` +
+            `**Recommended (Secure)**: Use API Key\n` +
+            `"env": {\n` +
+            `  "PURMEMO_API_KEY": "your-api-key-here"\n` +
+            `}\n\n` +
+            `Get your API key at: https://app.purmemo.ai/settings/api-keys\n\n` +
+            `**Alternative**: Use email/password\n` +
+            `"env": {\n` +
+            `  "PURMEMO_EMAIL": "your-email@example.com",\n` +
+            `  "PURMEMO_PASSWORD": "your-password"\n` +
+            `}\n\n` +
+            `Then restart Claude Desktop.`
+    }]
+  };
+}
 
-// Handle tool execution - forward all to API
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
+// API call helper
+async function makeApiCall(endpoint, options = {}) {
+  const token = await authenticate();
+  
+  if (!token) {
+    throw new Error('NO_AUTH');
+  }
+  
+  const defaultHeaders = {
+    'Authorization': `Bearer ${token}`,
+    'User-Agent': USER_AGENT
+  };
   
+  // Only add Content-Type for POST/PUT requests with body
+  if (options.body) {
+    defaultHeaders['Content-Type'] = 'application/json';
+  }
+  
+  const response = await fetch(`${API_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      ...defaultHeaders,
+      ...options.headers
+    }
+  });
+  
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API Error ${response.status}: ${errorText}`);
+  }
+  
+  return await response.json();
+}
+
+// Tool handlers
+async function handleMemory(args) {
   try {
-    let response;
+    const data = await makeApiCall('/api/v5/memories/', {
+      method: 'POST',
+      body: JSON.stringify({
+        content: args.content,
+        title: args.title,
+        tags: args.tags || []
+      })
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `✅ Memory saved successfully!\n\n` +
+              `📝 Content: ${args.content}\n` +
+              `🔗 ID: ${data.id || data.memory_id || 'Unknown'}\n` +
+              (args.title ? `📋 Title: ${args.title}\n` : '') +
+              (args.tags?.length ? `🏷️ Tags: ${args.tags.join(', ')}\n` : '')
+      }]
+    };
+  } catch (error) {
+    if (error.message === 'NO_AUTH') {
+      return createAuthMessage('memory');
+    }
+    return {
+      content: [{
+        type: 'text',
+        text: `❌ Error saving memory: ${error.message}`
+      }]
+    };
+  }
+}
+
+async function handleRecall(args) {
+  try {
+    // FIXED: Use GET with query parameter instead of POST to /search
+    const params = new URLSearchParams({
+      query: args.query,
+      page_size: String(args.limit || 10)
+    });
     
-    switch (name) {
-      case 'memory':
-        // POST request for creating memory
-        response = await fetch(`${API_URL}/api/v5/memories`, {
-          method: 'POST',
-          headers: {
-            'Authorization': `Bearer ${API_KEY}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'purmemo-mcp/1.1.2'
-          },
-          body: JSON.stringify(args)
-        });
-        break;
-        
-      case 'recall':
-        // GET request for search
-        const searchParams = new URLSearchParams({
-          q: args.query || '',
-          limit: args.limit || 10,
-          search_type: args.search_type || 'hybrid'
-        });
-        response = await fetch(`${API_URL}/api/v5/memories/search?${searchParams}`, {
-          headers: {
-            'Authorization': `Bearer ${API_KEY}`,
-            'User-Agent': 'purmemo-mcp/1.1.2'
-          }
-        });
-        break;
-        
-      case 'entities':
-        // GET request for entities
-        const entityParams = new URLSearchParams();
-        if (args.entity_name) entityParams.append('name', args.entity_name);
-        if (args.entity_type) entityParams.append('type', args.entity_type);
-        
-        response = await fetch(`${API_URL}/api/v5/entities?${entityParams}`, {
-          headers: {
-            'Authorization': `Bearer ${API_KEY}`,
-            'User-Agent': 'purmemo-mcp/1.1.2'
-          }
-        });
-        break;
-        
-      case 'attach':
-        // POST request for attachments
-        response = await fetch(`${API_URL}/api/v5/memories/${args.memory_id}/attachments`, {
-          method: 'POST',
-          headers: {
-            'Authorization': `Bearer ${API_KEY}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'purmemo-mcp/1.1.2'
-          },
-          body: JSON.stringify({ file_paths: args.file_paths })
-        });
-        break;
-        
-      case 'correction':
-        // POST request for corrections
-        response = await fetch(`${API_URL}/api/v5/memories/${args.memory_id}/corrections`, {
-          method: 'POST',
-          headers: {
-            'Authorization': `Bearer ${API_KEY}`,
-            'Content-Type': 'application/json',
-            'User-Agent': 'purmemo-mcp/1.1.2'
-          },
-          body: JSON.stringify({
-            correction: args.correction,
-            reason: args.reason
-          })
-        });
-        break;
-        
-      default:
-        throw new Error(`Unknown tool: ${name}`);
+    const data = await makeApiCall(`/api/v5/memories/?${params}`, {
+      method: 'GET'  // Use GET not POST
+    });
+
+    // Handle both direct array response and paginated response
+    const memories = data.results || data.memories || data;
+    
+    if (!memories || (Array.isArray(memories) && memories.length === 0)) {
+      return {
+        content: [{
+          type: 'text',
+          text: `🔍 No memories found for "${args.query}"`
+        }]
+      };
     }
+
+    const memoryList = Array.isArray(memories) ? memories : [memories];
+    let resultText = `🔍 Found ${memoryList.length} memories for "${args.query}"\n\n`;
     
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`API error: ${error}`);
+    memoryList.forEach((memory, index) => {
+      resultText += `${index + 1}. **${memory.title || 'Untitled'}**\n`;
+      resultText += `   📝 ${memory.content.substring(0, 150)}${memory.content.length > 150 ? '...' : ''}\n`;
+      if (memory.tags?.length) {
+        resultText += `   🏷️ ${memory.tags.join(', ')}\n`;
+      }
+      if (memory.created_at) {
+        resultText += `   📅 ${new Date(memory.created_at).toLocaleDateString()}\n`;
+      }
+      resultText += '\n';
+    });
+
+    return {
+      content: [{ type: 'text', text: resultText }]
+    };
+  } catch (error) {
+    if (error.message === 'NO_AUTH') {
+      return createAuthMessage('recall');
     }
+    return {
+      content: [{
+        type: 'text',
+        text: `❌ Error searching memories: ${error.message}`
+      }]
+    };
+  }
+}
+
+async function handleEntities(args) {
+  try {
+    const params = new URLSearchParams();
+    if (args.entity_name) params.set('name', args.entity_name);
+    if (args.entity_type) params.set('type', args.entity_type);
     
-    const result = await response.json();
+    const data = await makeApiCall(`/api/v5/entities?${params}`, {
+      method: 'GET'
+    });
+
+    // Check for backend error
+    if (data.error) {
+      // Handle known error about missing entities table
+      if (data.error.includes('entities table')) {
+        return {
+          content: [{
+            type: 'text',
+            text: `🏷️ Entity extraction is being set up\n\n` +
+                  `The entity extraction feature is currently being configured.\n` +
+                  `This feature will automatically extract:\n\n` +
+                  `• People: names mentioned in memories\n` +
+                  `• Places: locations referenced\n` +
+                  `• Organizations: companies, teams\n` +
+                  `• Technologies: tools, frameworks\n` +
+                  `• Concepts: ideas, topics\n\n` +
+                  `Please check back later once setup is complete.`
+          }]
+        };
+      }
+      // Other errors
+      throw new Error(data.error);
+    }
+
+    // Handle empty entities
+    if (!data.entities || data.entities.length === 0) {
+      return {
+        content: [{
+          type: 'text',
+          text: `🏷️ No entities found\n\n` +
+                `Entities are extracted from your memories. ` +
+                `Save some memories first, and entities will be automatically extracted.\n\n` +
+                `Examples of entities:\n` +
+                `• People: names mentioned in memories\n` +
+                `• Places: locations referenced\n` +
+                `• Organizations: companies, teams\n` +
+                `• Concepts: ideas, technologies`
+        }]
+      };
+    }
+
+    let resultText = `🏷️ Found ${data.entities.length} entities\n\n`;
     
+    data.entities.forEach(entity => {
+      // Handle both camelCase and snake_case field names
+      const name = entity.name || entity.entity_name;
+      const type = entity.entityType || entity.entity_type || entity.type;
+      const occurrences = entity.metrics?.occurrences || entity.occurrence_count || entity.frequency;
+      
+      resultText += `**${name}** (${type})\n`;
+      if (occurrences) {
+        resultText += `   📊 Mentioned ${occurrences} times\n`;
+      }
+      if (entity.metrics?.confidence) {
+        resultText += `   🎯 Confidence: ${(entity.metrics.confidence * 100).toFixed(0)}%\n`;
+      }
+      resultText += '\n';
+    });
+
+    if (data.summary) {
+      resultText += `\n📈 Summary:\n`;
+      resultText += `   Total entities: ${data.summary.totalEntities}\n`;
+      resultText += `   Types found: ${data.summary.typesFound}\n`;
+      if (data.summary.averageConfidence) {
+        resultText += `   Average confidence: ${(data.summary.averageConfidence * 100).toFixed(0)}%\n`;
+      }
+    }
+
+    return {
+      content: [{ type: 'text', text: resultText }]
+    };
+  } catch (error) {
+    if (error.message === 'NO_AUTH') {
+      return createAuthMessage('entities');
+    }
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify(result, null, 2)
+        text: `❌ Error fetching entities: ${error.message}`
+      }]
+    };
+  }
+}
+
+async function handleAttach(args) {
+  try {
+    const data = await makeApiCall(`/api/v5/memories/${args.memory_id}/attachments`, {
+      method: 'POST',
+      body: JSON.stringify({
+        files: args.files,
+        description: args.description || ""
+      })
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `✅ Files attached successfully!\n\n` +
+              `📎 Memory ID: ${args.memory_id}\n` +
+              `📁 Files: ${args.files.join(', ')}\n` +
+              (args.description ? `📝 Description: ${args.description}\n` : '') +
+              `🔗 Attachment ID: ${data.id || data.attachment_id || 'Unknown'}`
       }]
     };
-    
   } catch (error) {
-    console.error('Tool execution error:', error);
+    if (error.message === 'NO_AUTH') {
+      return createAuthMessage('attach');
+    }
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({ error: error.message }, null, 2)
+        text: `❌ Error attaching files: ${error.message}`
       }]
     };
   }
-});
+}
 
-// Start the server
-async function main() {
-  console.error('🚀 pūrmemo MCP Server v1.1.2 - Hybrid Open-Core Model');
-  console.error('📡 Connected to:', API_URL);
-  console.error('🔐 OAuth 2.1 + API key authentication');
-  console.error('💡 94% accuracy with <50ms retrieval');
-  
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+async function handleCorrection(args) {
+  try {
+    const data = await makeApiCall(`/api/v5/memories/${args.memory_id}/corrections`, {
+      method: 'POST',
+      body: JSON.stringify({
+        correction: args.correction,
+        type: args.type || 'update'
+      })
+    });
+
+    return {
+      content: [{
+        type: 'text',
+        text: `✅ Correction added successfully!\n\n` +
+              `📝 Memory ID: ${args.memory_id}\n` +
+              `✏️ Correction: ${args.correction}\n` +
+              `🏷️ Type: ${args.type || 'update'}\n` +
+              `🔗 Correction ID: ${data.id || data.correction_id || 'Unknown'}`
+      }]
+    };
+  } catch (error) {
+    if (error.message === 'NO_AUTH') {
+      return createAuthMessage('correction');
+    }
+    return {
+      content: [{
+        type: 'text',
+        text: `❌ Error adding correction: ${error.message}`
+      }]
+    };
+  }
 }
 
-main().catch((error) => {
-  console.error('Server error:', error);
-  process.exit(1);
-});
+// Request handlers
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  
+  try {
+    switch (name) {
+      case 'memory':
+        return await handleMemory(args);
+      case 'recall':
+        return await handleRecall(args);
+      case 'entities':
+        return await handleEntities(args);
+      case 'attach':
+        return await handleAttach(args);
+      case 'correction':
+        return await handleCorrection(args);
+      default:
+        return {
+          content: [{
+            type: 'text',
+            text: `❌ Unknown tool: ${name}\n\nAvailable tools:\n• memory - Save memories\n• recall - Search memories\n• entities - List entities\n• attach - Attach files\n• correction - Add corrections`
+          }]
+        };
+    }
+  } catch (error) {
+    return {
+      content: [{
+        type: 'text',
+        text: `❌ Unexpected error: ${error.message}`
+      }]
+    };
+  }
+});
+
+// Start server
+const transport = new StdioServerTransport();
+server.connect(transport).catch(() => process.exit(1));

package/bin/purmemo-mcp

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-require('../src/index.js');