@prmichaelsen/remember-mcp 2.6.11 → 2.6.13

package/CHANGELOG.md

@@ -5,6 +5,42 @@ 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.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
+
+- **CRITICAL: Memory_public Schema Mismatch**: Fixed property names to match user memory schema
+  - Changed `location_gps_latitude` → `location_gps_lat`
+  - Changed `location_gps_longitude` → `location_gps_lng`
+  - Changed `location_address_formatted` → `location_address`
+  - Changed `location_address_city` → `location_city`
+  - Changed `location_address_country` → `location_country`
+  - Added missing `location_source` field
+  - Changed `context_platform` → `context_summary` and `context_timestamp`
+  - Added missing `locale_language` and `locale_timezone` fields
+  - Changed `related_memory_ids` → `relationships`
+  - Added missing fields: `references`, `template_id`, `access_count`, `last_accessed_at`
+  - Added relationship fields: `memory_ids`, `relationship_type`, `observation`, `strength`
+  - Added computed fields: `base_weight`, `computed_weight`
+  - Added `user_id` field for backwards compatibility
+  - Schema now matches user memory schema exactly, allowing spread operator to work
+  - Fixes issue where Weaviate rejected all properties due to name mismatches
+  - Published memories now store all content correctly
+
+---
+
 ## [2.6.11] - 2026-02-17
 
 ### Changed

package/dist/server-factory.js

@@ -2034,11 +2034,23 @@ async function handleUpdateMemory(args, userId) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     updates.updated_at = now;
     updates.version = existingMemory.properties.version + 1;
+    logger.info("Calling Weaviate update", {
+      userId,
+      memoryId: args.memory_id,
+      updateFields: Object.keys(updates),
+      updateValues: updates,
+      collectionName: `Memory_${userId}`
+    });
     try {
       await collection.data.update({
         id: args.memory_id,
         properties: updates
       });
+      logger.info("Weaviate update 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:", {
@@ -3774,53 +3786,134 @@ async function createSpaceCollection(client2, spaceId) {
         dataType: "number",
         description: "System confidence in accuracy (0-1)"
       },
-      // Location fields (flattened)
+      // Location fields (flattened) - MUST match user memory schema exactly
       {
-        name: "location_gps_latitude",
+        name: "location_gps_lat",
         dataType: "number",
         description: "GPS latitude"
       },
       {
-        name: "location_gps_longitude",
+        name: "location_gps_lng",
         dataType: "number",
         description: "GPS longitude"
       },
       {
-        name: "location_address_formatted",
+        name: "location_address",
         dataType: "text",
         description: "Formatted address"
       },
       {
-        name: "location_address_city",
+        name: "location_city",
+        dataType: "text",
+        description: "City name"
+      },
+      {
+        name: "location_country",
         dataType: "text",
-        description: "City"
+        description: "Country name"
       },
       {
-        name: "location_address_country",
+        name: "location_source",
         dataType: "text",
-        description: "Country"
+        description: "Location source (gps, ip, manual, etc.)"
       },
-      // Context fields (flattened)
+      // Context fields (flattened) - MUST match user memory schema exactly
       {
         name: "context_conversation_id",
         dataType: "text",
         description: "Conversation ID"
       },
       {
-        name: "context_platform",
+        name: "context_summary",
         dataType: "text",
-        description: "Platform where created"
+        description: "Brief context summary"
+      },
+      {
+        name: "context_timestamp",
+        dataType: "date",
+        description: "Context timestamp"
+      },
+      // Locale fields - MUST match user memory schema exactly
+      {
+        name: "locale_language",
+        dataType: "text",
+        description: "Language code (e.g., en, es, fr)"
+      },
+      {
+        name: "locale_timezone",
+        dataType: "text",
+        description: "Timezone (e.g., America/Los_Angeles)"
+      },
+      // Relationships - MUST match user memory schema exactly
+      {
+        name: "relationships",
+        dataType: "text[]",
+        description: "Array of relationship IDs"
+      },
+      // Access tracking - MUST match user memory schema exactly
+      {
+        name: "access_count",
+        dataType: "number",
+        description: "Total times accessed"
+      },
+      {
+        name: "last_accessed_at",
+        dataType: "date",
+        description: "Most recent access timestamp"
       },
-      // Tags and relationships
+      // Metadata - MUST match user memory schema exactly
       {
         name: "tags",
         dataType: "text[]",
-        description: "Tags for categorization"
+        description: "Tags for organization"
+      },
+      {
+        name: "references",
+        dataType: "text[]",
+        description: "Source URLs"
+      },
+      {
+        name: "template_id",
+        dataType: "text",
+        description: "Template ID if using template"
       },
+      // Relationship-specific fields (for relationships in public space)
       {
-        name: "related_memory_ids",
+        name: "memory_ids",
         dataType: "text[]",
-        description: "IDs of related memories"
+        description: "Connected memory IDs (for relationships)"
+      },
+      {
+        name: "relationship_type",
+        dataType: "text",
+        description: "Relationship type (for relationships)"
+      },
+      {
+        name: "observation",
+        dataType: "text",
+        description: "Relationship observation (vectorized)"
+      },
+      {
+        name: "strength",
+        dataType: "number",
+        description: "Relationship strength (0-1)"
+      },
+      // Computed fields - MUST match user memory schema exactly
+      {
+        name: "base_weight",
+        dataType: "number",
+        description: "User-specified weight"
+      },
+      {
+        name: "computed_weight",
+        dataType: "number",
+        description: "Calculated effective weight"
+      },
+      // User ID field (for backwards compatibility with spread operator)
+      {
+        name: "user_id",
+        dataType: "text",
+        description: "User ID (copied from original memory, same as author_id)"
       },
       // Timestamps
       {
@@ -4215,23 +4308,23 @@ async function executePublishMemory(request, userId) {
     });
     const originalTags = Array.isArray(originalMemory.properties.tags) ? originalMemory.properties.tags : [];
     const additionalTags = Array.isArray(request.payload.additional_tags) ? request.payload.additional_tags : [];
+    if (!request.payload.spaces || !Array.isArray(request.payload.spaces) || request.payload.spaces.length === 0) {
+      throw new Error("Payload missing required field: spaces");
+    }
     const publishedMemory = {
       ...originalMemory.properties,
-      // Add space-specific fields
-      spaces: request.payload.spaces || ["the_void"],
-      // ✅ Array of spaces!
+      // Add space-specific fields (don't overwrite existing properties)
+      spaces: request.payload.spaces,
+      // Required field (validated above)
       author_id: userId,
       // Track original author
       published_at: (/* @__PURE__ */ new Date()).toISOString(),
       discovery_count: 0,
-      doc_type: "space_memory",
       attribution: "user",
-      // Merge additional tags
-      tags: [...originalTags, ...additionalTags],
-      // Update timestamps
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      version: 1
+      // Merge additional tags with original tags
+      tags: [...originalTags, ...additionalTags]
+      // Keep doc_type as 'memory' (don't change to 'space_memory')
+      // Keep original created_at, updated_at, version (don't overwrite)
     };
     logger.info("Inserting memory into Memory_public", {
       function: "executePublishMemory",

package/dist/server.js

@@ -2102,11 +2102,23 @@ async function handleUpdateMemory(args, userId) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     updates.updated_at = now;
     updates.version = existingMemory.properties.version + 1;
+    logger.info("Calling Weaviate update", {
+      userId,
+      memoryId: args.memory_id,
+      updateFields: Object.keys(updates),
+      updateValues: updates,
+      collectionName: `Memory_${userId}`
+    });
     try {
       await collection.data.update({
         id: args.memory_id,
         properties: updates
       });
+      logger.info("Weaviate update 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:", {
@@ -3842,53 +3854,134 @@ async function createSpaceCollection(client2, spaceId) {
         dataType: "number",
         description: "System confidence in accuracy (0-1)"
       },
-      // Location fields (flattened)
+      // Location fields (flattened) - MUST match user memory schema exactly
       {
-        name: "location_gps_latitude",
+        name: "location_gps_lat",
         dataType: "number",
         description: "GPS latitude"
       },
       {
-        name: "location_gps_longitude",
+        name: "location_gps_lng",
         dataType: "number",
         description: "GPS longitude"
       },
       {
-        name: "location_address_formatted",
+        name: "location_address",
         dataType: "text",
         description: "Formatted address"
       },
       {
-        name: "location_address_city",
+        name: "location_city",
+        dataType: "text",
+        description: "City name"
+      },
+      {
+        name: "location_country",
         dataType: "text",
-        description: "City"
+        description: "Country name"
       },
       {
-        name: "location_address_country",
+        name: "location_source",
         dataType: "text",
-        description: "Country"
+        description: "Location source (gps, ip, manual, etc.)"
       },
-      // Context fields (flattened)
+      // Context fields (flattened) - MUST match user memory schema exactly
       {
         name: "context_conversation_id",
         dataType: "text",
         description: "Conversation ID"
       },
       {
-        name: "context_platform",
+        name: "context_summary",
         dataType: "text",
-        description: "Platform where created"
+        description: "Brief context summary"
+      },
+      {
+        name: "context_timestamp",
+        dataType: "date",
+        description: "Context timestamp"
+      },
+      // Locale fields - MUST match user memory schema exactly
+      {
+        name: "locale_language",
+        dataType: "text",
+        description: "Language code (e.g., en, es, fr)"
+      },
+      {
+        name: "locale_timezone",
+        dataType: "text",
+        description: "Timezone (e.g., America/Los_Angeles)"
+      },
+      // Relationships - MUST match user memory schema exactly
+      {
+        name: "relationships",
+        dataType: "text[]",
+        description: "Array of relationship IDs"
+      },
+      // Access tracking - MUST match user memory schema exactly
+      {
+        name: "access_count",
+        dataType: "number",
+        description: "Total times accessed"
+      },
+      {
+        name: "last_accessed_at",
+        dataType: "date",
+        description: "Most recent access timestamp"
       },
-      // Tags and relationships
+      // Metadata - MUST match user memory schema exactly
       {
         name: "tags",
         dataType: "text[]",
-        description: "Tags for categorization"
+        description: "Tags for organization"
+      },
+      {
+        name: "references",
+        dataType: "text[]",
+        description: "Source URLs"
+      },
+      {
+        name: "template_id",
+        dataType: "text",
+        description: "Template ID if using template"
       },
+      // Relationship-specific fields (for relationships in public space)
       {
-        name: "related_memory_ids",
+        name: "memory_ids",
         dataType: "text[]",
-        description: "IDs of related memories"
+        description: "Connected memory IDs (for relationships)"
+      },
+      {
+        name: "relationship_type",
+        dataType: "text",
+        description: "Relationship type (for relationships)"
+      },
+      {
+        name: "observation",
+        dataType: "text",
+        description: "Relationship observation (vectorized)"
+      },
+      {
+        name: "strength",
+        dataType: "number",
+        description: "Relationship strength (0-1)"
+      },
+      // Computed fields - MUST match user memory schema exactly
+      {
+        name: "base_weight",
+        dataType: "number",
+        description: "User-specified weight"
+      },
+      {
+        name: "computed_weight",
+        dataType: "number",
+        description: "Calculated effective weight"
+      },
+      // User ID field (for backwards compatibility with spread operator)
+      {
+        name: "user_id",
+        dataType: "text",
+        description: "User ID (copied from original memory, same as author_id)"
       },
       // Timestamps
       {
@@ -4283,23 +4376,23 @@ async function executePublishMemory(request, userId) {
     });
     const originalTags = Array.isArray(originalMemory.properties.tags) ? originalMemory.properties.tags : [];
     const additionalTags = Array.isArray(request.payload.additional_tags) ? request.payload.additional_tags : [];
+    if (!request.payload.spaces || !Array.isArray(request.payload.spaces) || request.payload.spaces.length === 0) {
+      throw new Error("Payload missing required field: spaces");
+    }
     const publishedMemory = {
       ...originalMemory.properties,
-      // Add space-specific fields
-      spaces: request.payload.spaces || ["the_void"],
-      // ✅ Array of spaces!
+      // Add space-specific fields (don't overwrite existing properties)
+      spaces: request.payload.spaces,
+      // Required field (validated above)
       author_id: userId,
       // Track original author
       published_at: (/* @__PURE__ */ new Date()).toISOString(),
       discovery_count: 0,
-      doc_type: "space_memory",
       attribution: "user",
-      // Merge additional tags
-      tags: [...originalTags, ...additionalTags],
-      // Update timestamps
-      created_at: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      version: 1
+      // Merge additional tags with original tags
+      tags: [...originalTags, ...additionalTags]
+      // Keep doc_type as 'memory' (don't change to 'space_memory')
+      // Keep original created_at, updated_at, version (don't overwrite)
     };
     logger.info("Inserting memory into Memory_public", {
       function: "executePublishMemory",

package/package.json

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

package/src/tools/confirm.ts

@@ -227,22 +227,24 @@ async function executePublishMemory(
       ? request.payload.additional_tags
       : [];
 
-    // Create published memory with space-specific fields
+    // Validate payload has required fields
+    if (!request.payload.spaces || !Array.isArray(request.payload.spaces) || request.payload.spaces.length === 0) {
+      throw new Error('Payload missing required field: spaces');
+    }
+    
+    // Create published memory - preserve ALL original properties
     const publishedMemory = {
       ...originalMemory.properties,
-      // Add space-specific fields
-      spaces: request.payload.spaces || ['the_void'],  // ✅ Array of spaces!
+      // Add space-specific fields (don't overwrite existing properties)
+      spaces: request.payload.spaces,  // Required field (validated above)
       author_id: userId, // Track original author
       published_at: new Date().toISOString(),
       discovery_count: 0,
-      doc_type: 'space_memory',
       attribution: 'user' as const,
-      // Merge additional tags
+      // Merge additional tags with original tags
       tags: [...originalTags, ...additionalTags],
-      // Update timestamps
-      created_at: new Date().toISOString(),
-      updated_at: new Date().toISOString(),
-      version: 1,
+      // Keep doc_type as 'memory' (don't change to 'space_memory')
+      // Keep original created_at, updated_at, version (don't overwrite)
     };
 
     logger.info('Inserting memory into Memory_public', {

package/src/tools/update-memory.ts

@@ -250,11 +250,25 @@ export async function handleUpdateMemory(
     updates.version = (existingMemory.properties.version as number) + 1;
 
     // Perform update in Weaviate
+    logger.info('Calling Weaviate update', {
+      userId,
+      memoryId: args.memory_id,
+      updateFields: Object.keys(updates),
+      updateValues: updates,
+      collectionName: `Memory_${userId}`,
+    });
+    
     try {
       await collection.data.update({
         id: args.memory_id,
         properties: updates,
       });
+      
+      logger.info('Weaviate update 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:', {

package/src/weaviate/space-schema.ts

@@ -187,55 +187,142 @@ async function createSpaceCollection(
         description: 'System confidence in accuracy (0-1)',
       },
 
-      // Location fields (flattened)
+      // Location fields (flattened) - MUST match user memory schema exactly
       {
-        name: 'location_gps_latitude',
+        name: 'location_gps_lat',
         dataType: 'number' as any,
         description: 'GPS latitude',
       },
       {
-        name: 'location_gps_longitude',
+        name: 'location_gps_lng',
         dataType: 'number' as any,
         description: 'GPS longitude',
       },
       {
-        name: 'location_address_formatted',
+        name: 'location_address',
         dataType: 'text' as any,
         description: 'Formatted address',
       },
       {
-        name: 'location_address_city',
+        name: 'location_city',
         dataType: 'text' as any,
-        description: 'City',
+        description: 'City name',
       },
       {
-        name: 'location_address_country',
+        name: 'location_country',
         dataType: 'text' as any,
-        description: 'Country',
+        description: 'Country name',
+      },
+      {
+        name: 'location_source',
+        dataType: 'text' as any,
+        description: 'Location source (gps, ip, manual, etc.)',
       },
 
-      // Context fields (flattened)
+      // Context fields (flattened) - MUST match user memory schema exactly
       {
         name: 'context_conversation_id',
         dataType: 'text' as any,
         description: 'Conversation ID',
       },
       {
-        name: 'context_platform',
+        name: 'context_summary',
         dataType: 'text' as any,
-        description: 'Platform where created',
+        description: 'Brief context summary',
+      },
+      {
+        name: 'context_timestamp',
+        dataType: 'date' as any,
+        description: 'Context timestamp',
       },
 
-      // Tags and relationships
+      // Locale fields - MUST match user memory schema exactly
+      {
+        name: 'locale_language',
+        dataType: 'text' as any,
+        description: 'Language code (e.g., en, es, fr)',
+      },
+      {
+        name: 'locale_timezone',
+        dataType: 'text' as any,
+        description: 'Timezone (e.g., America/Los_Angeles)',
+      },
+
+      // Relationships - MUST match user memory schema exactly
+      {
+        name: 'relationships',
+        dataType: 'text[]' as any,
+        description: 'Array of relationship IDs',
+      },
+
+      // Access tracking - MUST match user memory schema exactly
+      {
+        name: 'access_count',
+        dataType: 'number' as any,
+        description: 'Total times accessed',
+      },
+      {
+        name: 'last_accessed_at',
+        dataType: 'date' as any,
+        description: 'Most recent access timestamp',
+      },
+
+      // Metadata - MUST match user memory schema exactly
       {
         name: 'tags',
         dataType: 'text[]' as any,
-        description: 'Tags for categorization',
+        description: 'Tags for organization',
       },
       {
-        name: 'related_memory_ids',
+        name: 'references',
         dataType: 'text[]' as any,
-        description: 'IDs of related memories',
+        description: 'Source URLs',
+      },
+      {
+        name: 'template_id',
+        dataType: 'text' as any,
+        description: 'Template ID if using template',
+      },
+
+      // Relationship-specific fields (for relationships in public space)
+      {
+        name: 'memory_ids',
+        dataType: 'text[]' as any,
+        description: 'Connected memory IDs (for relationships)',
+      },
+      {
+        name: 'relationship_type',
+        dataType: 'text' as any,
+        description: 'Relationship type (for relationships)',
+      },
+      {
+        name: 'observation',
+        dataType: 'text' as any,
+        description: 'Relationship observation (vectorized)',
+      },
+      {
+        name: 'strength',
+        dataType: 'number' as any,
+        description: 'Relationship strength (0-1)',
+      },
+
+      // Computed fields - MUST match user memory schema exactly
+      {
+        name: 'base_weight',
+        dataType: 'number' as any,
+        description: 'User-specified weight',
+      },
+      {
+        name: 'computed_weight',
+        dataType: 'number' as any,
+        description: 'Calculated effective weight',
+      },
+
+      // User ID field (for backwards compatibility with spread operator)
+      {
+        name: 'user_id',
+        dataType: 'text' as any,
+        description: 'User ID (copied from original memory, same as author_id)',
       },
 
       // Timestamps