@prmichaelsen/remember-mcp 2.6.8 → 2.6.10

package/CHANGELOG.md

@@ -5,6 +5,40 @@ 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.6.10] - 2026-02-17
+
+### Fixed
+
+- **CRITICAL: `fetchMemoryWithAllProperties()` Graceful Fallback**: Fixed memory content not being copied during publish
+  - Added try-catch wrapper around property fetch with fallback
+  - If fetching with ALL_MEMORY_PROPERTIES fails, falls back to fetching without property specification
+  - Weaviate returns all properties that actually exist on the record when no returnProperties specified
+  - Fixes issue where `remember_confirm` → `executePublishMemory()` only copied comment fields
+  - Published memories now include all content (title, content, tags, etc.)
+  - Prevents data loss during memory publication to shared spaces
+
+---
+
+## [2.6.9] - 2026-02-17
+
+### Fixed
+
+- **`remember_update_memory` Query Issue**: Fixed "Memory not found" error for existing memories
+  - Reduced property query from 6 properties to only 3 essential properties (`user_id`, `doc_type`, `version`)
+  - Removed queries for optional properties (`type`, `weight`, `base_weight`) that may not exist on all records
+  - Weaviate gRPC fails when querying properties that exist in schema but not on specific records
+  - Only fetch properties actually needed for validation (ownership, doc type, version)
+  - Fixes issue where memories with missing optional properties were reported as "not found"
+
+### Added
+
+- **Task 67: Migrate Memory_public Schema**
+  - Created migration plan documentation for updating production `Memory_public` collection
+  - Addresses schema mismatch: only `moderation_flags` present, missing `parent_id` and `thread_root_id`
+  - Documents safe migration approach using `Memory_public_v2` with zero data loss
+
+---
+
 ## [2.6.8] - 2026-02-17
 
 ### 🐛 Fixed

package/agent/tasks/task-67-migrate-memory-public-schema.md

@@ -0,0 +1,226 @@
+# Task 67: Migrate Memory_public Collection Schema
+
+**Milestone**: M12 (Comment System)
+**Estimated Time**: 1 hour
+**Dependencies**: Task 55, Task 66
+**Status**: Not Started
+**Priority**: High
+
+---
+
+## Objective
+
+Update the existing `Memory_public` collection in Weaviate Cloud to include the missing comment fields (`parent_id` and `thread_root_id`). Currently, only `moderation_flags` exists in the production schema.
+
+---
+
+## Problem
+
+The `Memory_public` collection was created before comment fields were added to the schema. Weaviate doesn't support adding properties to existing collections, so we need to migrate the data.
+
+**Current State** (Production):
+- ✅ `moderation_flags` field exists
+- ❌ `parent_id` field missing
+- ❌ `thread_root_id` field missing
+
+**Expected State** (Code):
+- ✅ All three fields defined in `src/weaviate/space-schema.ts` (lines 261-275)
+
+---
+
+## Impact
+
+**Without Migration**:
+- Cannot create comments in shared spaces
+- Cannot thread discussions
+- Published memories missing comment fields
+- Schema mismatch between code and production
+
+**With Migration**:
+- Full comment system functionality in shared spaces
+- Threaded discussions work correctly
+- Schema matches code definition
+
+---
+
+## Migration Options
+
+### Option 1: Delete and Recreate (DESTRUCTIVE)
+
+**Steps**:
+1. Backup all data from `Memory_public`
+2. Delete `Memory_public` collection
+3. Recreate with updated schema (automatic via `ensurePublicCollection`)
+4. Restore data with new fields initialized
+
+**Pros**:
+- Clean schema
+- Simple process
+
+**Cons**:
+- ⚠️ **LOSES ALL DATA** if backup fails
+- Downtime during migration
+- Risky for production
+
+### Option 2: Create New Collection and Migrate (SAFE)
+
+**Steps**:
+1. Create `Memory_public_v2` with updated schema
+2. Copy all data from `Memory_public` to `Memory_public_v2`
+3. Initialize comment fields: `parent_id: null`, `thread_root_id: null`, `moderation_flags: []`
+4. Test `Memory_public_v2` thoroughly
+5. Update code to use `Memory_public_v2`
+6. Delete old `Memory_public` after verification
+
+**Pros**:
+- ✅ Zero data loss
+- ✅ Can rollback if issues
+- ✅ Test before switching
+
+**Cons**:
+- More complex
+- Temporary storage duplication
+
+### Option 3: Live with Current Schema (NOT RECOMMENDED)
+
+**Steps**:
+- Do nothing
+- Comment system only works for personal memories
+- Shared spaces don't support comments
+
+**Pros**:
+- No migration needed
+
+**Cons**:
+- ❌ Incomplete feature
+- ❌ Schema mismatch
+- ❌ Technical debt
+
+---
+
+## Recommended Approach: Option 2 (Safe Migration)
+
+### Step 1: Create Backup Collection
+
+```typescript
+// Create Memory_public_v2 with full schema
+const client = getWeaviateClient();
+await client.collections.create({
+  name: 'Memory_public_v2',
+  // ... full schema from space-schema.ts including comment fields
+});
+```
+
+### Step 2: Migrate Data
+
+```typescript
+// Fetch all objects from Memory_public
+const oldCollection = client.collections.get('Memory_public');
+const objects = await oldCollection.query.fetchObjects({ limit: 10000 });
+
+// Insert into Memory_public_v2 with comment fields
+const newCollection = client.collections.get('Memory_public_v2');
+for (const obj of objects.objects) {
+  await newCollection.data.insert({
+    ...obj.properties,
+    parent_id: null,           // Initialize to null
+    thread_root_id: null,      // Initialize to null
+    moderation_flags: obj.properties.moderation_flags || [], // Preserve existing
+  });
+}
+```
+
+### Step 3: Update Code
+
+```typescript
+// src/weaviate/space-schema.ts
+export const PUBLIC_COLLECTION_NAME = 'Memory_public_v2'; // Changed from 'Memory_public'
+```
+
+### Step 4: Verify and Cleanup
+
+```bash
+# Test the new collection
+# Verify all data migrated correctly
+# Check comment fields exist
+
+# After verification (wait 24-48 hours):
+# Delete old Memory_public collection
+```
+
+---
+
+## Verification
+
+- [ ] `Memory_public_v2` collection created with full schema
+- [ ] All data migrated from `Memory_public`
+- [ ] Comment fields present: `parent_id`, `thread_root_id`, `moderation_flags`
+- [ ] All existing memories have `parent_id: null`, `thread_root_id: null`
+- [ ] `moderation_flags` preserved from original data
+- [ ] Code updated to use `Memory_public_v2`
+- [ ] All tests passing
+- [ ] Can create comments in shared spaces
+- [ ] Can publish memories with comment fields
+- [ ] Old `Memory_public` collection deleted (after verification period)
+
+---
+
+## Rollback Plan
+
+If issues occur:
+
+1. **Immediate Rollback**:
+   ```typescript
+   export const PUBLIC_COLLECTION_NAME = 'Memory_public'; // Revert to old
+   ```
+
+2. **Keep Both Collections**:
+   - Old collection still exists
+   - Can switch back instantly
+   - No data loss
+
+3. **After Verification**:
+   - Only delete old collection after 24-48 hours
+   - Ensure new collection works correctly
+
+---
+
+## Alternative: Manual Schema Update (If Supported)
+
+**Note**: Weaviate typically doesn't support adding properties to existing collections. Check Weaviate documentation for your version to see if schema evolution is supported.
+
+If supported:
+```bash
+# Use Weaviate API to add properties
+# This is version-dependent and may not be available
+```
+
+---
+
+## Production Checklist
+
+- [ ] Backup current `Memory_public` data
+- [ ] Create `Memory_public_v2` with full schema
+- [ ] Migrate all data with comment fields initialized
+- [ ] Test new collection thoroughly
+- [ ] Update `PUBLIC_COLLECTION_NAME` constant
+- [ ] Deploy updated code
+- [ ] Verify in production
+- [ ] Monitor for 24-48 hours
+- [ ] Delete old `Memory_public` collection
+
+---
+
+## Notes
+
+- This migration is required for comment system to work in shared spaces
+- Personal memory collections (`Memory_{user_id}`) don't need migration if created after Task 55
+- Old personal collections may also need migration (separate task)
+- Consider running migration during low-traffic period
+- Document migration in CHANGELOG.md
+
+---
+
+**Status**: Not Started
+**Recommendation**: Execute Option 2 (safe migration) during next deployment window
+**Priority**: High - Blocks comment system in shared spaces

package/dist/server-factory.js

@@ -617,9 +617,18 @@ var ALL_MEMORY_PROPERTIES = [
   "moderation_flags"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
-  return await collection.query.fetchObjectById(memoryId, {
-    returnProperties: ALL_MEMORY_PROPERTIES
-  });
+  try {
+    return await collection.query.fetchObjectById(memoryId, {
+      returnProperties: ALL_MEMORY_PROPERTIES
+    });
+  } catch (error) {
+    logger.warn("Failed to fetch with all properties, falling back to unspecified fetch", {
+      module: "weaviate-client",
+      memoryId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return await collection.query.fetchObjectById(memoryId);
+  }
 }
 
 // src/firestore/init.ts
@@ -1940,7 +1949,7 @@ async function handleUpdateMemory(args, userId) {
     let existingMemory;
     try {
       existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ["user_id", "doc_type", "version", "type", "weight", "base_weight"]
+        returnProperties: ["user_id", "doc_type", "version"]
       });
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);

package/dist/server.js

@@ -663,9 +663,18 @@ var ALL_MEMORY_PROPERTIES = [
   "moderation_flags"
 ];
 async function fetchMemoryWithAllProperties(collection, memoryId) {
-  return await collection.query.fetchObjectById(memoryId, {
-    returnProperties: ALL_MEMORY_PROPERTIES
-  });
+  try {
+    return await collection.query.fetchObjectById(memoryId, {
+      returnProperties: ALL_MEMORY_PROPERTIES
+    });
+  } catch (error) {
+    logger.warn("Failed to fetch with all properties, falling back to unspecified fetch", {
+      module: "weaviate-client",
+      memoryId,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return await collection.query.fetchObjectById(memoryId);
+  }
 }
 
 // src/firestore/init.ts
@@ -2008,7 +2017,7 @@ async function handleUpdateMemory(args, userId) {
     let existingMemory;
     try {
       existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ["user_id", "doc_type", "version", "type", "weight", "base_weight"]
+        returnProperties: ["user_id", "doc_type", "version"]
       });
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);

package/dist/weaviate/client.d.ts

@@ -48,9 +48,14 @@ export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "co
  * This utility ensures all memory properties are fetched consistently
  * across all tools, preventing bugs where properties are missing.
  *
+ * NOTE: Some properties may not exist on all records (e.g., old records
+ * created before schema updates). This function handles that gracefully
+ * by falling back to fetching without property specification if the
+ * full property query fails.
+ *
  * @param collection - Weaviate collection
  * @param memoryId - Memory ID to fetch
- * @returns Memory object with all properties
+ * @returns Memory object with all properties that exist on the record
  */
 export declare function fetchMemoryWithAllProperties(collection: any, memoryId: string): Promise<any>;
 /**

package/package.json

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

package/src/tools/update-memory.ts

@@ -131,10 +131,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)
     let existingMemory;
     try {
       existingMemory = await collection.query.fetchObjectById(args.memory_id, {
-        returnProperties: ['user_id', 'doc_type', 'version', 'type', 'weight', 'base_weight'],
+        returnProperties: ['user_id', 'doc_type', 'version'],
       });
     } catch (fetchError) {
       const fetchErrorMsg = fetchError instanceof Error ? fetchError.message : String(fetchError);

package/src/weaviate/client.ts

@@ -215,17 +215,36 @@ export const ALL_MEMORY_PROPERTIES = [
  * This utility ensures all memory properties are fetched consistently
  * across all tools, preventing bugs where properties are missing.
  *
+ * NOTE: Some properties may not exist on all records (e.g., old records
+ * created before schema updates). This function handles that gracefully
+ * by falling back to fetching without property specification if the
+ * full property query fails.
+ *
  * @param collection - Weaviate collection
  * @param memoryId - Memory ID to fetch
- * @returns Memory object with all properties
+ * @returns Memory object with all properties that exist on the record
  */
 export async function fetchMemoryWithAllProperties(
   collection: any,
   memoryId: string
 ) {
-  return await collection.query.fetchObjectById(memoryId, {
-    returnProperties: ALL_MEMORY_PROPERTIES,
-  });
+  try {
+    // Try to fetch with all properties specified
+    return await collection.query.fetchObjectById(memoryId, {
+      returnProperties: ALL_MEMORY_PROPERTIES,
+    });
+  } catch (error) {
+    // If that fails (e.g., property doesn't exist on this record),
+    // fetch without specifying properties - Weaviate will return
+    // all properties that actually exist on the record
+    logger.warn('Failed to fetch with all properties, falling back to unspecified fetch', {
+      module: 'weaviate-client',
+      memoryId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    
+    return await collection.query.fetchObjectById(memoryId);
+  }
 }
 
 /**