@prmichaelsen/remember-mcp 2.0.2 → 2.0.4

package/dist/server.js

@@ -1610,9 +1610,13 @@ async function handleSearchMemory(args, userId) {
     });
     return JSON.stringify(searchResult, null, 2);
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error("Failed to search memories:", { error: errorMessage, userId, query: args.query });
-    throw new Error(`Failed to search memories: ${errorMessage}`);
+    handleToolError(error, {
+      toolName: "remember_search_memory",
+      operation: "search memories",
+      userId,
+      query: args.query,
+      includeRelationships: args.include_relationships
+    });
   }
 }
 
@@ -1686,8 +1690,13 @@ async function handleDeleteMemory(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to delete memory:", error);
-    throw new Error(`Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_delete_memory",
+      operation: "delete memory",
+      userId,
+      memoryId: args.memory_id,
+      deleteRelationships: args.delete_relationships
+    });
   }
 }
 
@@ -1865,23 +1874,14 @@ async function handleUpdateMemory(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorStack = error instanceof Error ? error.stack : void 0;
-    logger.error("Failed to update memory:", {
-      error: errorMessage,
-      stack: errorStack,
+    handleToolError(error, {
+      toolName: "remember_update_memory",
+      operation: "update memory",
       userId,
       memoryId: args.memory_id,
-      providedFields: Object.keys(args).filter((k) => k !== "memory_id")
+      providedFields: Object.keys(args).filter((k) => k !== "memory_id").join(", "),
+      updateCount: Object.keys(args).filter((k) => k !== "memory_id").length
     });
-    throw new Error(
-      `Failed to update memory: ${errorMessage}` + (errorStack ? `
-
-Stack trace:
-${errorStack}` : "") + `
-
-Context: userId=${userId}, memoryId=${args.memory_id}`
-    );
   }
 }
 
@@ -2005,8 +2005,14 @@ async function handleFindSimilar(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to find similar memories:", error);
-    throw new Error(`Failed to find similar memories: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_find_similar",
+      operation: "find similar memories",
+      userId,
+      memoryId: args.memory_id,
+      searchText: args.text,
+      limit: args.limit
+    });
   }
 }
 
@@ -2168,8 +2174,13 @@ ${content}${tags}`;
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to query memories:", error);
-    throw new Error(`Failed to query memories: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_query_memory",
+      operation: "query memories",
+      userId,
+      query: args.query,
+      format: args.format
+    });
   }
 }
 
@@ -2237,6 +2248,7 @@ async function handleCreateRelationship(args, userId, context) {
     }
     await ensureMemoryCollection(userId);
     const collection = getMemoryCollection(userId);
+    logger.info("Validating memories", { userId, memoryIds: args.memory_ids });
     const memoryChecks = await Promise.all(
       args.memory_ids.map(async (memoryId) => {
         try {
@@ -2244,12 +2256,23 @@ async function handleCreateRelationship(args, userId, context) {
             returnProperties: ["user_id", "doc_type", "relationships"]
           });
           if (!memory) {
+            logger.warn("Memory not found", { userId, memoryId });
             return { memoryId, error: "Memory not found" };
           }
           if (memory.properties.user_id !== userId) {
+            logger.warn("Unauthorized memory access attempt", {
+              userId,
+              memoryId,
+              actualUserId: memory.properties.user_id
+            });
             return { memoryId, error: "Unauthorized: Memory belongs to another user" };
           }
           if (memory.properties.doc_type !== "memory") {
+            logger.warn("Invalid doc_type for relationship", {
+              userId,
+              memoryId,
+              docType: memory.properties.doc_type
+            });
             return { memoryId, error: "Cannot create relationship with non-memory document" };
           }
           return {
@@ -2258,15 +2281,30 @@ async function handleCreateRelationship(args, userId, context) {
             relationships: memory.properties.relationships || []
           };
         } catch (error) {
-          return { memoryId, error: `Failed to fetch memory: ${error}` };
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          logger.error("Failed to fetch memory for relationship", {
+            userId,
+            memoryId,
+            error: errorMsg
+          });
+          return { memoryId, error: `Failed to fetch memory: ${errorMsg}` };
         }
       })
     );
     const errors = memoryChecks.filter((check) => check.error);
     if (errors.length > 0) {
       const errorMessages = errors.map((e) => `${e.memoryId}: ${e.error}`).join("; ");
+      logger.error("Memory validation failed", {
+        userId,
+        errorCount: errors.length,
+        errors: errorMessages
+      });
       throw new Error(`Memory validation failed: ${errorMessages}`);
     }
+    logger.info("All memories validated successfully", {
+      userId,
+      validatedCount: memoryChecks.length
+    });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const relationship = {
       // Core identity
@@ -2339,8 +2377,16 @@ async function handleCreateRelationship(args, userId, context) {
     };
     return JSON.stringify(response, null, 2);
   } catch (error) {
-    logger.error("Failed to create relationship:", error);
-    throw new Error(`Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_create_relationship",
+      operation: "create relationship",
+      userId,
+      memoryIds: args.memory_ids.join(", "),
+      memoryCount: args.memory_ids.length,
+      relationshipType: args.relationship_type,
+      observation: args.observation?.substring(0, 100)
+      // First 100 chars
+    });
   }
 }
 
@@ -2463,12 +2509,18 @@ async function handleUpdateRelationship(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to update relationship:", error);
-    throw new Error(`Failed to update relationship: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_update_relationship",
+      operation: "update relationship",
+      userId,
+      relationshipId: args.relationship_id,
+      updatedFields: Object.keys(args).filter((k) => k !== "relationship_id")
+    });
   }
 }
 
 // src/tools/search-relationship.ts
+import { Filters as Filters2 } from "weaviate-client";
 var searchRelationshipTool = {
   name: "remember_search_relationship",
   description: `Search relationships by observation text or relationship type.
@@ -2536,63 +2588,46 @@ async function handleSearchRelationship(args, userId) {
     const collection = getMemoryCollection(userId);
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
-    const whereFilters = [
-      {
-        path: "doc_type",
-        operator: "Equal",
-        valueText: "relationship"
-      }
-    ];
+    const filterList = [];
+    filterList.push(
+      collection.filter.byProperty("doc_type").equal("relationship")
+    );
     if (args.relationship_types && args.relationship_types.length > 0) {
       if (args.relationship_types.length === 1) {
-        whereFilters.push({
-          path: "relationship_type",
-          operator: "Equal",
-          valueText: args.relationship_types[0]
-        });
+        filterList.push(
+          collection.filter.byProperty("relationship_type").equal(args.relationship_types[0])
+        );
       } else {
-        whereFilters.push({
-          operator: "Or",
-          operands: args.relationship_types.map((type) => ({
-            path: "relationship_type",
-            operator: "Equal",
-            valueText: type
-          }))
-        });
+        const typeFilters = args.relationship_types.map(
+          (type) => collection.filter.byProperty("relationship_type").equal(type)
+        );
+        filterList.push(Filters2.or(...typeFilters));
       }
     }
     if (args.strength_min !== void 0) {
-      whereFilters.push({
-        path: "strength",
-        operator: "GreaterThanEqual",
-        valueNumber: args.strength_min
-      });
+      filterList.push(
+        collection.filter.byProperty("strength").greaterOrEqual(args.strength_min)
+      );
     }
     if (args.confidence_min !== void 0) {
-      whereFilters.push({
-        path: "confidence",
-        operator: "GreaterThanEqual",
-        valueNumber: args.confidence_min
-      });
+      filterList.push(
+        collection.filter.byProperty("confidence").greaterOrEqual(args.confidence_min)
+      );
     }
     if (args.tags && args.tags.length > 0) {
-      whereFilters.push({
-        path: "tags",
-        operator: "ContainsAny",
-        valueTextArray: args.tags
-      });
+      filterList.push(
+        collection.filter.byProperty("tags").containsAny(args.tags)
+      );
     }
+    const combinedFilters = filterList.length > 1 ? Filters2.and(...filterList) : filterList[0];
     const searchOptions = {
       alpha: 1,
       // Pure semantic search for relationships
       limit: limit + offset
       // Get extra for offset
     };
-    if (whereFilters.length > 0) {
-      searchOptions.filters = whereFilters.length > 1 ? {
-        operator: "And",
-        operands: whereFilters
-      } : whereFilters[0];
+    if (combinedFilters) {
+      searchOptions.filters = combinedFilters;
     }
     const results = await collection.query.hybrid(args.query, searchOptions);
     const paginatedResults = results.objects.slice(offset, offset + limit);
@@ -2628,8 +2663,13 @@ async function handleSearchRelationship(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to search relationships:", error);
-    throw new Error(`Failed to search relationships: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_search_relationship",
+      operation: "search relationships",
+      userId,
+      query: args.query,
+      limit: args.limit
+    });
   }
 }
 
@@ -2730,8 +2770,12 @@ async function handleDeleteRelationship(args, userId) {
     };
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to delete relationship:", error);
-    throw new Error(`Failed to delete relationship: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_delete_relationship",
+      operation: "delete relationship",
+      userId,
+      relationshipId: args.relationship_id
+    });
   }
 }
 
@@ -3101,8 +3145,12 @@ async function handleSetPreference(args, userId) {
     logger.info("Preferences set successfully", { userId });
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error("Failed to set preferences:", error);
-    throw new Error(`Failed to set preferences: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_set_preference",
+      operation: "set preference",
+      userId,
+      preferencesProvided: Object.keys(args.preferences || {}).length
+    });
   }
 }
 
@@ -3158,8 +3206,12 @@ async function handleGetPreferences(args, userId) {
     logger.info("Preferences retrieved successfully", { userId, category, isDefault });
     return JSON.stringify(response, null, 2);
   } catch (error) {
-    logger.error("Failed to get preferences:", error);
-    throw new Error(`Failed to get preferences: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: "remember_get_preferences",
+      operation: "get preferences",
+      userId,
+      category: args.category
+    });
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/tools/create-relationship.ts

@@ -6,6 +6,7 @@
 import type { Relationship, MemoryContext } from '../types/memory.js';
 import { ensureMemoryCollection, getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 
 /**
  * Tool definition for remember_create_relationship
@@ -110,6 +111,8 @@ export async function handleCreateRelationship(
     const collection = getMemoryCollection(userId);
 
     // Verify all memories exist and belong to user
+    logger.info('Validating memories', { userId, memoryIds: args.memory_ids });
+    
     const memoryChecks = await Promise.all(
       args.memory_ids.map(async (memoryId) => {
         try {
@@ -118,24 +121,41 @@ export async function handleCreateRelationship(
           });
           
           if (!memory) {
+            logger.warn('Memory not found', { userId, memoryId });
             return { memoryId, error: 'Memory not found' };
           }
           
           if (memory.properties.user_id !== userId) {
+            logger.warn('Unauthorized memory access attempt', {
+              userId,
+              memoryId,
+              actualUserId: memory.properties.user_id
+            });
             return { memoryId, error: 'Unauthorized: Memory belongs to another user' };
           }
           
           if (memory.properties.doc_type !== 'memory') {
+            logger.warn('Invalid doc_type for relationship', {
+              userId,
+              memoryId,
+              docType: memory.properties.doc_type
+            });
             return { memoryId, error: 'Cannot create relationship with non-memory document' };
           }
           
-          return { 
-            memoryId, 
+          return {
+            memoryId,
             memory,
             relationships: (memory.properties.relationships as string[]) || []
           };
         } catch (error) {
-          return { memoryId, error: `Failed to fetch memory: ${error}` };
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          logger.error('Failed to fetch memory for relationship', {
+            userId,
+            memoryId,
+            error: errorMsg
+          });
+          return { memoryId, error: `Failed to fetch memory: ${errorMsg}` };
         }
       })
     );
@@ -144,8 +164,18 @@ export async function handleCreateRelationship(
     const errors = memoryChecks.filter(check => check.error);
     if (errors.length > 0) {
       const errorMessages = errors.map(e => `${e.memoryId}: ${e.error}`).join('; ');
+      logger.error('Memory validation failed', {
+        userId,
+        errorCount: errors.length,
+        errors: errorMessages
+      });
       throw new Error(`Memory validation failed: ${errorMessages}`);
     }
+    
+    logger.info('All memories validated successfully', {
+      userId,
+      validatedCount: memoryChecks.length
+    });
 
     // Build relationship object
     const now = new Date().toISOString();
@@ -239,7 +269,14 @@ export async function handleCreateRelationship(
 
     return JSON.stringify(response, null, 2);
   } catch (error) {
-    logger.error('Failed to create relationship:', error);
-    throw new Error(`Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_create_relationship',
+      operation: 'create relationship',
+      userId,
+      memoryIds: args.memory_ids.join(', '),
+      memoryCount: args.memory_ids.length,
+      relationshipType: args.relationship_type,
+      observation: args.observation?.substring(0, 100), // First 100 chars
+    });
   }
 }

package/src/tools/delete-memory.ts

@@ -5,6 +5,7 @@
 
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 
 /**
  * Tool definition for remember_delete_memory
@@ -120,7 +121,12 @@ export async function handleDeleteMemory(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to delete memory:', error);
-    throw new Error(`Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_delete_memory',
+      operation: 'delete memory',
+      userId,
+      memoryId: args.memory_id,
+      deleteRelationships: args.delete_relationships,
+    });
   }
 }

package/src/tools/delete-relationship.ts

@@ -5,6 +5,7 @@
 
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 
 /**
  * Tool definition for remember_delete_relationship
@@ -154,7 +155,11 @@ export async function handleDeleteRelationship(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to delete relationship:', error);
-    throw new Error(`Failed to delete relationship: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_delete_relationship',
+      operation: 'delete relationship',
+      userId,
+      relationshipId: args.relationship_id,
+    });
   }
 }

package/src/tools/find-similar.ts

@@ -6,6 +6,7 @@
 import type { Memory } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 
 /**
  * Tool definition for remember_find_similar
@@ -193,7 +194,13 @@ export async function handleFindSimilar(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to find similar memories:', error);
-    throw new Error(`Failed to find similar memories: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_find_similar',
+      operation: 'find similar memories',
+      userId,
+      memoryId: args.memory_id,
+      searchText: args.text,
+      limit: args.limit,
+    });
   }
 }

package/src/tools/get-preferences.ts

@@ -5,6 +5,7 @@
 
 import { PreferencesDatabaseService } from '../services/preferences-database.service.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 import {
   UserPreferences,
   PreferenceCategory,
@@ -105,7 +106,11 @@ export async function handleGetPreferences(
 
     return JSON.stringify(response, null, 2);
   } catch (error) {
-    logger.error('Failed to get preferences:', error);
-    throw new Error(`Failed to get preferences: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_get_preferences',
+      operation: 'get preferences',
+      userId,
+      category: args.category,
+    });
   }
 }

package/src/tools/query-memory.ts

@@ -6,6 +6,7 @@
 import type { Memory, SearchFilters } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 import { buildCombinedSearchFilters } from '../utils/weaviate-filters.js';
 
 /**
@@ -231,7 +232,12 @@ export async function handleQueryMemory(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to query memories:', error);
-    throw new Error(`Failed to query memories: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_query_memory',
+      operation: 'query memories',
+      userId,
+      query: args.query,
+      format: args.format,
+    });
   }
 }

package/src/tools/search-memory.ts

@@ -6,6 +6,7 @@
 import type { Memory, Relationship, SearchOptions, SearchResult, SearchFilters } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 import { buildCombinedSearchFilters, buildMemoryOnlyFilters } from '../utils/weaviate-filters.js';
 
 /**
@@ -191,8 +192,12 @@ export async function handleSearchMemory(
 
     return JSON.stringify(searchResult, null, 2);
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error('Failed to search memories:', { error: errorMessage, userId, query: args.query });
-    throw new Error(`Failed to search memories: ${errorMessage}`);
+    handleToolError(error, {
+      toolName: 'remember_search_memory',
+      operation: 'search memories',
+      userId,
+      query: args.query,
+      includeRelationships: args.include_relationships,
+    });
   }
 }