@prmichaelsen/remember-mcp 2.8.0 → 3.12.0

package/src/weaviate/client.ts

@@ -104,26 +104,26 @@ export async function testWeaviateConnection(): Promise<boolean> {
 
 /**
  * Sanitize user_id for collection name
- * Weaviate collection names must start with uppercase letter and contain only alphanumeric
+ * @deprecated v2 uses literal userId — no sanitization needed. Kept for migration script only.
  */
 export function sanitizeUserId(userId: string): string {
   // Remove special characters, keep alphanumeric
   let sanitized = userId.replace(/[^a-zA-Z0-9]/g, '_');
-  
+
   // If starts with number, prepend underscore
   if (/^[0-9]/.test(sanitized)) {
     sanitized = '_' + sanitized;
   }
-  
+
   // Ensure starts with uppercase letter
   return sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
 }
 
 /**
- * Get collection name for user's memories
+ * Get collection name for user's memories (v2 format)
  */
 export function getMemoryCollectionName(userId: string): string {
-  return `Memory_${sanitizeUserId(userId)}`;
+  return `Memory_users_${userId}`;
 }
 
 /**
@@ -142,54 +142,67 @@ export function getAuditCollectionName(userId: string): string {
 
 /**
  * List of all memory properties to fetch
- * Centralized to ensure consistency across all tools
- */
-/**
- * List of all memory properties to fetch
- * Matches the actual Weaviate schema properties exactly
+ * Centralized to ensure consistency across all tools.
+ * Includes both v2 canonical names and v1 compat names.
  */
 export const ALL_MEMORY_PROPERTIES = [
   // Core identity
   'user_id',
   'doc_type',
-  
+
   // Memory fields
   'content',
+  'content_type', // v2 canonical
   'title',
   'summary',
-  'type',
-  
+  'type', // v1 compat (v2: content_type)
+
   // Scoring fields
   'weight',
   'base_weight',
-  'trust',
+  'trust_score', // v2 canonical
+  'trust', // v1 compat (v2: trust_score)
   'confidence',
   'computed_weight',
-  
-  // Location fields (flattened)
+
+  // Location fields (v2)
+  'location_name',
+  'location_lat', // v2 canonical
+  'location_lon', // v2 canonical
+  // Location fields (v1 compat)
   'location_gps_lat',
   'location_gps_lng',
   'location_address',
   'location_city',
   'location_country',
   'location_source',
-  
+
   // Locale fields
   'locale_language',
   'locale_timezone',
-  
-  // Context fields (flattened)
+
+  // Context fields
   'context_conversation_id',
   'context_summary',
   'context_timestamp',
-  
-  // Relationships
+  'context_app',
+  'context_url',
+
+  // Relationships (v2)
+  'relationship_ids', // v2 canonical
+  'related_memory_ids', // v2 canonical
+  // Relationships (v1 compat)
   'relationships',
-  
+  'memory_ids',
+  // Common relationship fields
+  'relationship_type',
+  'observation',
+  'strength',
+
   // Access tracking
   'access_count',
   'last_accessed_at',
-  
+
   // Metadata
   'tags',
   'references',
@@ -197,27 +210,34 @@ export const ALL_MEMORY_PROPERTIES = [
   'updated_at',
   'version',
   'template_id',
-  
-  // Relationship-specific fields
-  'memory_ids',
-  'relationship_type',
-  'observation',
-  'strength',
-  
+
+  // Tracking arrays (v2)
+  'space_ids',
+  'group_ids',
+
   // Comment/threading fields
   'parent_id',
   'thread_root_id',
   'moderation_flags',
-  
-  // Space/publishing fields (for Memory_public collection)
-  'spaces',
-  'space_id',
+
+  // Space/publishing fields
+  'spaces', // legacy
+  'space_id', // legacy
   'author_id',
   'ghost_id',
   'attribution',
   'published_at',
   'discovery_count',
-  'space_memory_id',
+  'space_memory_id', // legacy
+  'original_memory_id',
+  'revised_at',
+  'revision_count',
+  'revision_history',
+
+  // Soft delete fields
+  'deleted_at',
+  'deleted_by',
+  'deletion_reason',
 ] as const;
 
 /**

package/src/weaviate/schema.ts

@@ -4,9 +4,10 @@
  */
 
 import weaviate, { WeaviateClient } from 'weaviate-client';
-import { getWeaviateClient, sanitizeUserId } from './client.js';
+import { getWeaviateClient } from './client.js';
 import { config } from '../config.js';
 import { logger } from '../utils/logger.js';
+import { createUserCollectionSchema } from '../schema/v2-collections.js';
 
 /**
  * Create Memory collection schema for a user
@@ -21,7 +22,7 @@ import { logger } from '../utils/logger.js';
  */
 export async function createMemoryCollection(userId: string): Promise<void> {
   const client = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
 
   // Check if collection already exists
   const exists = await client.collections.exists(collectionName);
@@ -38,238 +39,9 @@ export async function createMemoryCollection(userId: string): Promise<void> {
     collectionName,
   });
 
-  // Create collection with schema
-  await client.collections.create({
-    name: collectionName,
-    
-    // Vectorizer configuration
-    vectorizers: weaviate.configure.vectorizer.text2VecOpenAI({
-      model: 'text-embedding-3-small',
-      // Vectorize content, title, summary, and observation for semantic search
-      // Note: title and summary are optional fields
-      sourceProperties: ['content', 'title', 'summary', 'observation'],
-    }),
-
-    properties: [
-      // Discriminator
-      {
-        name: 'doc_type',
-        dataType: 'text' as any,
-        description: 'Document type: "memory" or "relationship"',
-      },
-
-      // Core identity
-      {
-        name: 'user_id',
-        dataType: 'text' as any,
-        description: 'User who owns this document',
-      },
-
-      // Memory fields
-      {
-        name: 'content',
-        dataType: 'text' as any,
-        description: 'Main memory content (vectorized)',
-      },
-      {
-        name: 'title',
-        dataType: 'text' as any,
-        description: 'Optional short title',
-      },
-      {
-        name: 'summary',
-        dataType: 'text' as any,
-        description: 'Optional brief summary',
-      },
-      {
-        name: 'type',
-        dataType: 'text' as any,
-        description: 'Content type (note, event, person, etc.)',
-      },
-
-      // Scoring fields
-      {
-        name: 'weight',
-        dataType: 'number' as any,
-        description: 'Significance/priority (0-1)',
-      },
-      {
-        name: 'trust',
-        dataType: 'number' as any,
-        description: 'Access control level (0-1)',
-      },
-      {
-        name: 'confidence',
-        dataType: 'number' as any,
-        description: 'System confidence in accuracy (0-1)',
-      },
-
-      // Location fields (flattened for Weaviate)
-      {
-        name: 'location_gps_lat',
-        dataType: 'number' as any,
-        description: 'GPS latitude',
-      },
-      {
-        name: 'location_gps_lng',
-        dataType: 'number' as any,
-        description: 'GPS longitude',
-      },
-      {
-        name: 'location_address',
-        dataType: 'text' as any,
-        description: 'Formatted address',
-      },
-      {
-        name: 'location_city',
-        dataType: 'text' as any,
-        description: 'City name',
-      },
-      {
-        name: 'location_country',
-        dataType: 'text' as any,
-        description: 'Country name',
-      },
-      {
-        name: 'location_source',
-        dataType: 'text' as any,
-        description: 'Location source (gps, ip, manual, etc.)',
-      },
-
-      // Locale fields
-      {
-        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)',
-      },
-
-      // Context fields
-      {
-        name: 'context_conversation_id',
-        dataType: 'text' as any,
-        description: 'Conversation ID',
-      },
-      {
-        name: 'context_summary',
-        dataType: 'text' as any,
-        description: 'Brief context summary',
-      },
-      {
-        name: 'context_timestamp',
-        dataType: 'date' as any,
-        description: 'Context timestamp',
-      },
-
-      // Relationships
-      {
-        name: 'relationships',
-        dataType: 'text[]' as any,
-        description: 'Array of relationship IDs',
-      },
-
-      // Access tracking
-      {
-        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
-      {
-        name: 'tags',
-        dataType: 'text[]' as any,
-        description: 'Tags for organization',
-      },
-      {
-        name: 'references',
-        dataType: 'text[]' as any,
-        description: 'Source URLs',
-      },
-      {
-        name: 'created_at',
-        dataType: 'date' as any,
-        description: 'Creation timestamp',
-      },
-      {
-        name: 'updated_at',
-        dataType: 'date' as any,
-        description: 'Last update timestamp',
-      },
-      {
-        name: 'version',
-        dataType: 'number' as any,
-        description: 'Version number',
-      },
-
-      // Template fields
-      {
-        name: 'template_id',
-        dataType: 'text' as any,
-        description: 'Template ID if using template',
-      },
-
-      // Relationship-specific fields
-      {
-        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
-      {
-        name: 'base_weight',
-        dataType: 'number' as any,
-        description: 'User-specified weight',
-      },
-      {
-        name: 'computed_weight',
-        dataType: 'number' as any,
-        description: 'Calculated effective weight',
-      },
-
-      // Comment/threading fields (for threaded discussions in shared spaces)
-      {
-        name: 'parent_id',
-        dataType: 'text' as any,
-        description: 'ID of parent memory or comment (for threading)',
-      },
-      {
-        name: 'thread_root_id',
-        dataType: 'text' as any,
-        description: 'Root memory ID for fetching entire thread',
-      },
-      {
-        name: 'moderation_flags',
-        dataType: 'text[]' as any,
-        description: 'Per-space moderation flags (format: "{space_id}:{flag_type}")',
-      },
-    ],
-  });
+  // Create collection using v2 schema
+  const schema = createUserCollectionSchema(userId);
+  await client.collections.create(schema);
 
   logger.info('Memory collection created successfully', {
     module: 'weaviate-schema',
@@ -282,10 +54,10 @@ export async function createMemoryCollection(userId: string): Promise<void> {
  */
 export async function ensureMemoryCollection(userId: string): Promise<void> {
   const client = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
 
   const exists = await client.collections.exists(collectionName);
-  
+
   if (!exists) {
     await createMemoryCollection(userId);
   }
@@ -296,7 +68,7 @@ export async function ensureMemoryCollection(userId: string): Promise<void> {
  */
 export function getMemoryCollection(userId: string) {
   const client = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
   return client.collections.get(collectionName);
 }
 
@@ -305,10 +77,10 @@ export function getMemoryCollection(userId: string) {
  */
 export async function deleteMemoryCollection(userId: string): Promise<void> {
   const client = getWeaviateClient();
-  const collectionName = `Memory_${sanitizeUserId(userId)}`;
+  const collectionName = `Memory_users_${userId}`;
 
   const exists = await client.collections.exists(collectionName);
-  
+
   if (exists) {
     await client.collections.delete(collectionName);
     logger.info('Memory collection deleted', {

package/src/weaviate/space-schema.spec.ts

@@ -119,22 +119,25 @@ describe('Space Schema Utilities', () => {
       expect(createCall.vectorizers).toBeDefined();
       expect(createCall.properties).toBeDefined();
       expect(createCall.properties.length).toBeGreaterThan(20); // Should have many properties
-      
+
       // Check for space-specific properties
       const propertyNames = createCall.properties.map((p: any) => p.name);
-      expect(propertyNames).toContain('spaces'); // ✅ New array field
-      expect(propertyNames).toContain('space_id');
+      expect(propertyNames).toContain('spaces'); // legacy multi-space array field
       expect(propertyNames).toContain('author_id');
       expect(propertyNames).toContain('ghost_id');
       expect(propertyNames).toContain('published_at');
       expect(propertyNames).toContain('discovery_count');
       expect(propertyNames).toContain('attribution');
+      // Soft delete fields
+      expect(propertyNames).toContain('deleted_at');
+      expect(propertyNames).toContain('deleted_by');
+      expect(propertyNames).toContain('deletion_reason');
     });
   });
 
-  describe('Unified Public Collection', () => {
-    it('should create Memory_public collection', async () => {
-      const mockCollection = { name: 'Memory_public' };
+  describe('Unified Public Collection (v2: Memory_spaces_public)', () => {
+    it('should create Memory_spaces_public collection', async () => {
+      const mockCollection = { name: 'Memory_spaces_public' };
       (mockWeaviateClient.collections.exists as jest.Mock).mockResolvedValue(false);
       (mockWeaviateClient.collections.create as jest.Mock).mockResolvedValue(undefined);
       (mockWeaviateClient.collections.get as jest.Mock).mockReturnValue(mockCollection);
@@ -142,25 +145,25 @@ describe('Space Schema Utilities', () => {
       const result = await ensurePublicCollection(mockWeaviateClient);
 
       expect(result).toBe(mockCollection);
-      expect(mockWeaviateClient.collections.exists).toHaveBeenCalledWith('Memory_public');
+      expect(mockWeaviateClient.collections.exists).toHaveBeenCalledWith('Memory_spaces_public');
       expect(mockWeaviateClient.collections.create).toHaveBeenCalled();
-      expect(mockWeaviateClient.collections.get).toHaveBeenCalledWith('Memory_public');
+      expect(mockWeaviateClient.collections.get).toHaveBeenCalledWith('Memory_spaces_public');
     });
 
-    it('should return existing Memory_public if it exists', async () => {
-      const mockCollection = { name: 'Memory_public' };
+    it('should return existing Memory_spaces_public if it exists', async () => {
+      const mockCollection = { name: 'Memory_spaces_public' };
       (mockWeaviateClient.collections.exists as jest.Mock).mockResolvedValue(true);
       (mockWeaviateClient.collections.get as jest.Mock).mockReturnValue(mockCollection);
 
       const result = await ensurePublicCollection(mockWeaviateClient);
 
       expect(result).toBe(mockCollection);
-      expect(mockWeaviateClient.collections.exists).toHaveBeenCalledWith('Memory_public');
-      expect(mockWeaviateClient.collections.get).toHaveBeenCalledWith('Memory_public');
+      expect(mockWeaviateClient.collections.exists).toHaveBeenCalledWith('Memory_spaces_public');
+      expect(mockWeaviateClient.collections.get).toHaveBeenCalledWith('Memory_spaces_public');
       expect(mockWeaviateClient.collections.create).not.toHaveBeenCalled();
     });
 
-    it('should have spaces array field in schema', async () => {
+    it('should use v2 schema with space_ids array field', async () => {
       (mockWeaviateClient.collections.exists as jest.Mock).mockResolvedValue(false);
       (mockWeaviateClient.collections.create as jest.Mock).mockResolvedValue(undefined);
       (mockWeaviateClient.collections.get as jest.Mock).mockReturnValue({});
@@ -168,19 +171,19 @@ describe('Space Schema Utilities', () => {
       await ensurePublicCollection(mockWeaviateClient);
 
       const createCall = (mockWeaviateClient.collections.create as jest.Mock).mock.calls[0][0];
+      expect(createCall.name).toBe('Memory_spaces_public');
+
       const propertyNames = createCall.properties.map((p: any) => p.name);
-      
-      // Verify spaces array field exists
-      expect(propertyNames).toContain('spaces');
-      
-      // Find spaces property and verify it's an array
-      const spacesProperty = createCall.properties.find((p: any) => p.name === 'spaces');
-      expect(spacesProperty).toBeDefined();
-      expect(spacesProperty.dataType).toBe('text[]');
-    });
-
-    it('should verify PUBLIC_COLLECTION_NAME constant', () => {
-      expect(PUBLIC_COLLECTION_NAME).toBe('Memory_public');
+      // v2 tracking arrays
+      expect(propertyNames).toContain('space_ids');
+      expect(propertyNames).toContain('group_ids');
+      // v2 revision fields
+      expect(propertyNames).toContain('revision_count');
+      expect(propertyNames).toContain('revised_at');
+    });
+
+    it('should verify PUBLIC_COLLECTION_NAME constant is v2 format', () => {
+      expect(PUBLIC_COLLECTION_NAME).toBe('Memory_spaces_public');
     });
   });
 });

package/src/weaviate/space-schema.ts

@@ -9,11 +9,12 @@ import weaviate, { type WeaviateClient, type Collection } from 'weaviate-client'
 import { config } from '../config.js';
 import { SUPPORTED_SPACES, type SpaceId } from '../types/space-memory.js';
 import { logger } from '../utils/logger.js';
+import { createSpaceCollectionSchema } from '../schema/v2-collections.js';
 
 /**
- * Unified public collection name for all public spaces
+ * Unified public collection name for all public spaces (v2)
  */
-export const PUBLIC_COLLECTION_NAME = 'Memory_public';
+export const PUBLIC_COLLECTION_NAME = 'Memory_spaces_public';
 
 /**
  * Get collection name for a space
@@ -102,6 +103,12 @@ async function createSpaceCollection(
       sourceProperties: ['content', 'title', 'summary', 'observation'],
     }),
 
+    // Inverted index configuration
+    // indexNullState: true is required for filtering on null values (e.g., deleted_at IS NULL)
+    invertedIndex: weaviate.configure.invertedIndex({
+      indexNullState: true,
+    }),
+
     properties: [
       // Discriminator
       {
@@ -116,11 +123,6 @@ async function createSpaceCollection(
         dataType: 'text[]' as any,
         description: 'Spaces this memory is published to (e.g., ["the_void", "dogs"])',
       },
-      {
-        name: 'space_id',
-        dataType: 'text' as any,
-        description: 'DEPRECATED: Use spaces array instead. Will be removed in v3.0.0.',
-      },
       {
         name: 'author_id',
         dataType: 'text' as any,
@@ -361,6 +363,23 @@ async function createSpaceCollection(
         dataType: 'text[]' as any,
         description: 'Per-space moderation flags (format: "{space_id}:{flag_type}")',
       },
+
+      // Soft delete fields
+      {
+        name: 'deleted_at',
+        dataType: 'date' as any,
+        description: 'Timestamp when memory was soft-deleted (null = not deleted)',
+      },
+      {
+        name: 'deleted_by',
+        dataType: 'text' as any,
+        description: 'User ID who deleted the memory',
+      },
+      {
+        name: 'deletion_reason',
+        dataType: 'text' as any,
+        description: 'Optional reason for deletion',
+      },
     ],
   });
 
@@ -386,11 +405,16 @@ export async function ensurePublicCollection(
 
   // Check if collection exists
   const exists = await client.collections.exists(collectionName);
-  
+
   if (!exists) {
-    // Create with proper vectorizer configuration
-    // Use 'public' as spaceId to trigger PUBLIC_COLLECTION_NAME
-    await createSpaceCollection(client, 'public');
+    // Create using v2 schema
+    const schema = createSpaceCollectionSchema();
+    await client.collections.create(schema);
+
+    logger.info('Public space collection created', {
+      module: 'weaviate-space-schema',
+      collectionName,
+    });
   }
 
   return client.collections.get(collectionName);