@prmichaelsen/remember-mcp 2.0.2 → 2.0.4

package/agent/tasks/task-25-fix-update-memory-errors.md

@@ -0,0 +1,116 @@
+# Task 25: Fix Update Memory Errors
+
+**Milestone**: M8 - Testing & Quality
+**Estimated Time**: 2 hours
+**Dependencies**: None
+**Status**: Completed
+**Priority**: Medium
+**Completed**: 2026-02-15
+
+---
+
+## Objective
+
+Investigate and fix intermittent `remember_update_memory` errors occurring in production. While less frequent than relationship errors, these failures prevent users from updating their memories.
+
+## Problem Statement
+
+Production logs show occasional errors:
+```
+Tool execution failed for remember_update_memory:
+```
+
+**Frequency**: Less common than relationship errors  
+**Impact**: Users cannot update existing memories  
+**Severity**: Medium (not blocking all operations)
+
+## Steps
+
+1. **Gather Error Details**
+   - Review full error messages in Cloud Run logs
+   - Identify which update operations are failing
+   - Check if specific memory IDs or update types fail
+   - Determine if errors correlate with specific fields being updated
+
+2. **Review Update Memory Code**
+   - Examine [`src/tools/update-memory.ts`](../../src/tools/update-memory.ts)
+   - Check memory fetch logic (lines ~67-76 in error logs)
+   - Review partial update logic
+   - Verify version increment logic
+   - Check ownership verification
+
+3. **Analyze Error Context**
+   - Review error handler implementation (added in v2.0.1)
+   - Check if error context includes all necessary information
+   - Verify stack traces are captured
+   - Ensure userId and memoryId are logged
+
+4. **Identify Common Patterns**
+   - Check if errors occur with specific content types
+   - Verify if large updates fail more often
+   - Test with various field combinations
+   - Check for race conditions with concurrent updates
+
+5. **Implement Enhanced Validation**
+   - Add pre-update validation for all fields
+   - Verify memory exists before attempting update
+   - Check ownership before any modifications
+   - Validate content type if being updated
+   - Ensure weight/trust bounds (0-1)
+
+6. **Add Better Error Messages**
+   - Specify which validation failed
+   - Include attempted update values in error
+   - Add suggestions for fixing invalid inputs
+   - Log full update payload on error
+
+7. **Add Tests**
+   - Unit test for non-existent memory update
+   - Unit test for invalid field values
+   - Unit test for cross-user update attempts
+   - Unit test for concurrent updates
+   - Integration test with real Weaviate
+
+8. **Deploy and Monitor**
+   - Deploy fix to production
+   - Monitor error logs for 24 hours
+   - Verify error rate decreases
+   - Check error messages are helpful
+
+## Verification
+
+- [ ] Update memory errors have clear, actionable messages
+- [ ] Valid updates succeed consistently
+- [ ] Invalid updates return helpful error messages
+- [ ] Error rate in production drops significantly
+- [ ] Unit tests cover all error scenarios
+- [ ] Integration tests pass with real Weaviate
+- [ ] Error context includes userId, memoryId, and update fields
+
+## Files to Modify
+
+- `src/tools/update-memory.ts` - Enhance validation and error handling
+- `src/utils/error-handler.ts` - Add update-specific error context
+- `src/tools/update-memory.spec.ts` - Add error case tests (create if needed)
+
+## Potential Root Causes
+
+1. **Memory Not Found**: Attempting to update deleted/non-existent memory
+2. **Ownership Mismatch**: User trying to update another user's memory
+3. **Invalid Field Values**: Out-of-bounds weight/trust, invalid content type
+4. **Weaviate Connection**: Transient connection issues
+5. **Race Conditions**: Concurrent updates to same memory
+6. **Large Payloads**: Updates with very large content
+
+## Expected Outcome
+
+- Clear error messages for all update failure scenarios
+- Reduced error rate in production logs
+- Better user experience with actionable feedback
+- Comprehensive test coverage for error cases
+- Improved debugging with detailed error context
+
+---
+
+**Next Task**: Task 26 - Add Production Error Monitoring  
+**Related**: Task 22 (Comprehensive Error Handling)

package/dist/server-factory.js

@@ -1568,9 +1568,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
+    });
   }
 }
 
@@ -1644,8 +1648,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
+    });
   }
 }
 
@@ -1823,23 +1832,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}`
-    );
   }
 }
 
@@ -1963,8 +1963,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
+    });
   }
 }
 
@@ -2126,8 +2132,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
+    });
   }
 }
 
@@ -2195,6 +2206,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 {
@@ -2202,12 +2214,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 {
@@ -2216,15 +2239,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
@@ -2297,8 +2335,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
+    });
   }
 }
 
@@ -2421,12 +2467,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.
@@ -2494,63 +2546,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);
@@ -2586,8 +2621,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
+    });
   }
 }
 
@@ -2688,8 +2728,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
+    });
   }
 }
 
@@ -3059,8 +3103,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
+    });
   }
 }
 
@@ -3116,8 +3164,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
+    });
   }
 }