@prmichaelsen/remember-mcp 2.6.12 → 2.7.0

package/CHANGELOG.md

@@ -5,6 +5,45 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.7.0] - 2026-02-17
+
+### Fixed
+
+- **CRITICAL: `remember_update_memory` Now Uses `replace()` Instead of `update()`**
+  - Switched from `collection.data.update()` to `collection.data.replace()`
+  - Fixes Weaviate bug where `update()` only persists if vectorized fields change
+  - Now fetches full object and merges updates before replacing
+  - Updates to non-vectorized fields (title, type, weight, tags, etc.) now persist correctly
+  - Resolves issue where updates returned success but changes weren't saved
+  - **Breaking Change**: This is a minor version bump due to behavior change (more reliable updates)
+
+### Changed
+
+- Fetch strategy: Now fetches all properties (not just 3) since we need full object for replace
+- Update strategy: Merge updates with existing properties, then replace entire object
+- Logging: Changed "Calling Weaviate update" to "Calling Weaviate replace"
+
+### Root Cause
+
+- Weaviate has a known bug where `update()` only persists changes if at least one vectorized field is modified
+- Our schema only vectorizes `content` and `observation`
+- Updates to `title`, `type`, `weight`, `tags`, etc. were silently ignored
+- `replace()` doesn't have this limitation and always persists changes
+
+---
+
+## [2.6.13] - 2026-02-17
+
+### Changed
+
+- **Enhanced Logging for `remember_update_memory`**: Added detailed Weaviate update logging
+  - Logs update fields and values before calling Weaviate
+  - Logs confirmation after Weaviate update completes
+  - Helps diagnose if updates are being called but not persisting
+  - Shows exact values being sent to Weaviate
+
+---
+
 ## [2.6.12] - 2026-02-17
 
 ### Fixed

package/dist/server-factory.js

@@ -1948,9 +1948,7 @@ async function handleUpdateMemory(args, userId) {
     const collection = getMemoryCollection(userId);
     let existingMemory;
     try {
-      existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ["user_id", "doc_type", "version"]
-      });
+      existingMemory = await collection.query.fetchObjectById(args.memory_id);
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);
       logger.error("Failed to fetch memory for update:", {
@@ -1961,7 +1959,7 @@ async function handleUpdateMemory(args, userId) {
       });
       throw new Error(`Failed to fetch memory ${args.memory_id}: ${fetchErrorMsg}`);
     }
-    if (!existingMemory) {
+    if (!existingMemory || !existingMemory.properties) {
       throw new Error(`Memory not found: ${args.memory_id}. It may have been deleted or never existed.`);
     }
     if (existingMemory.properties.user_id !== userId) {
@@ -2034,14 +2032,31 @@ async function handleUpdateMemory(args, userId) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     updates.updated_at = now;
     updates.version = existingMemory.properties.version + 1;
+    const mergedProperties = {
+      ...existingMemory.properties,
+      ...updates
+    };
+    logger.info("Calling Weaviate replace", {
+      userId,
+      memoryId: args.memory_id,
+      updateFields: Object.keys(updates),
+      updateValues: updates,
+      collectionName: `Memory_${userId}`,
+      totalProperties: Object.keys(mergedProperties).length
+    });
     try {
-      await collection.data.update({
+      await collection.data.replace({
         id: args.memory_id,
-        properties: updates
+        properties: mergedProperties
+      });
+      logger.info("Weaviate replace completed (no error thrown)", {
+        userId,
+        memoryId: args.memory_id,
+        updatedFields: Object.keys(updates)
       });
     } catch (updateError) {
       const updateErrorMsg = updateError instanceof Error ? updateError.message : String(updateError);
-      logger.error("Failed to perform Weaviate update:", {
+      logger.error("Failed to perform Weaviate replace:", {
         error: updateErrorMsg,
         userId,
         memoryId: args.memory_id,

package/dist/server.js

@@ -2016,9 +2016,7 @@ async function handleUpdateMemory(args, userId) {
     const collection = getMemoryCollection(userId);
     let existingMemory;
     try {
-      existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ["user_id", "doc_type", "version"]
-      });
+      existingMemory = await collection.query.fetchObjectById(args.memory_id);
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);
       logger.error("Failed to fetch memory for update:", {
@@ -2029,7 +2027,7 @@ async function handleUpdateMemory(args, userId) {
       });
       throw new Error(`Failed to fetch memory ${args.memory_id}: ${fetchErrorMsg}`);
     }
-    if (!existingMemory) {
+    if (!existingMemory || !existingMemory.properties) {
       throw new Error(`Memory not found: ${args.memory_id}. It may have been deleted or never existed.`);
     }
     if (existingMemory.properties.user_id !== userId) {
@@ -2102,14 +2100,31 @@ async function handleUpdateMemory(args, userId) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     updates.updated_at = now;
     updates.version = existingMemory.properties.version + 1;
+    const mergedProperties = {
+      ...existingMemory.properties,
+      ...updates
+    };
+    logger.info("Calling Weaviate replace", {
+      userId,
+      memoryId: args.memory_id,
+      updateFields: Object.keys(updates),
+      updateValues: updates,
+      collectionName: `Memory_${userId}`,
+      totalProperties: Object.keys(mergedProperties).length
+    });
     try {
-      await collection.data.update({
+      await collection.data.replace({
         id: args.memory_id,
-        properties: updates
+        properties: mergedProperties
+      });
+      logger.info("Weaviate replace completed (no error thrown)", {
+        userId,
+        memoryId: args.memory_id,
+        updatedFields: Object.keys(updates)
       });
     } catch (updateError) {
       const updateErrorMsg = updateError instanceof Error ? updateError.message : String(updateError);
-      logger.error("Failed to perform Weaviate update:", {
+      logger.error("Failed to perform Weaviate replace:", {
         error: updateErrorMsg,
         userId,
         memoryId: args.memory_id,

package/package.json

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

package/src/tools/update-memory.ts

@@ -130,14 +130,12 @@ export async function handleUpdateMemory(
 
     const collection = getMemoryCollection(userId);
 
-    // Get existing memory to verify ownership and get current version
-    // Only fetch minimal properties needed for validation - don't query optional properties
-    // that may not exist on all records (causes Weaviate gRPC errors)
+    // Get existing memory - fetch ALL properties for replace operation
+    // We need the full object to use replace() instead of update()
+    // (Weaviate bug: update() only persists if vectorized fields change)
     let existingMemory;
     try {
-      existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ['user_id', 'doc_type', 'version'],
-      });
+      existingMemory = await collection.query.fetchObjectById(args.memory_id);
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);
       logger.error('Failed to fetch memory for update:', {
@@ -149,7 +147,7 @@ export async function handleUpdateMemory(
       throw new Error(`Failed to fetch memory ${args.memory_id}: ${fetchErrorMsg}`);
     }
 
-    if (!existingMemory) {
+    if (!existingMemory || !existingMemory.properties) {
       throw new Error(`Memory not found: ${args.memory_id}. It may have been deleted or never existed.`);
     }
 
@@ -249,15 +247,37 @@ export async function handleUpdateMemory(
     updates.updated_at = now;
     updates.version = (existingMemory.properties.version as number) + 1;
 
-    // Perform update in Weaviate
+    // Merge updates with existing properties
+    // Use replace() instead of update() due to Weaviate bug where update() only
+    // persists if vectorized fields (content/observation) are changed
+    const mergedProperties = {
+      ...existingMemory.properties,
+      ...updates,
+    };
+    
+    logger.info('Calling Weaviate replace', {
+      userId,
+      memoryId: args.memory_id,
+      updateFields: Object.keys(updates),
+      updateValues: updates,
+      collectionName: `Memory_${userId}`,
+      totalProperties: Object.keys(mergedProperties).length,
+    });
+    
     try {
-      await collection.data.update({
+      await collection.data.replace({
         id: args.memory_id,
-        properties: updates,
+        properties: mergedProperties,
+      });
+      
+      logger.info('Weaviate replace completed (no error thrown)', {
+        userId,
+        memoryId: args.memory_id,
+        updatedFields: Object.keys(updates),
       });
     } catch (updateError) {
       const updateErrorMsg = updateError instanceof Error ? updateError.message : String(updateError);
-      logger.error('Failed to perform Weaviate update:', {
+      logger.error('Failed to perform Weaviate replace:', {
         error: updateErrorMsg,
         userId,
         memoryId: args.memory_id,