@prmichaelsen/remember-mcp 3.12.0 → 3.14.0

package/src/tools/create-memory.ts

@@ -4,12 +4,11 @@
  */
 
 import type { Memory, ContentType, Location, MemoryContext } from '../types/memory.js';
-import { ensureMemoryCollection, getMemoryCollection } from '../weaviate/schema.js';
-import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
-import { DEFAULT_CONTENT_TYPE, getContentTypeDescription, isValidContentType } from '../constants/content-types.js';
+import { DEFAULT_CONTENT_TYPE, getContentTypeDescription } from '@prmichaelsen/remember-core';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_create_memory
@@ -143,78 +142,28 @@ export async function handleCreateMemory(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    logger.info('Creating memory', { userId, type: args.type });
 
-    // Ensure collection exists
-    await ensureMemoryCollection(userId);
-    const collection = getMemoryCollection(userId);
-
-    // Build memory object using v2 property names
-    const now = new Date().toISOString();
-    const memory: Record<string, any> = {
-      // Core identity
-      user_id: userId,
-      doc_type: 'memory',
-
-      // Content
+    const { memory } = createCoreServices(userId);
+    const result = await memory.create({
       content: args.content,
       title: args.title,
-      summary: args.title, // Use title as summary for now
-      content_type: (args.type && isValidContentType(args.type) ? args.type : DEFAULT_CONTENT_TYPE),
-
-      // Scoring
-      weight: args.weight ?? 0.5,
-      trust_score: args.trust ?? 0.25,
-      confidence: 1.0,
-
-      // Context
+      type: args.type,
+      weight: args.weight,
+      trust: args.trust,
+      tags: args.tags,
+      references: args.references,
+      template_id: args.template_id,
+      parent_id: args.parent_id,
+      thread_root_id: args.thread_root_id,
+      moderation_flags: args.moderation_flags,
       context_summary: context?.summary || 'Memory created via MCP',
       context_conversation_id: context?.conversation_id,
-
-      // Relationships
-      relationship_ids: [],
-
-      // Access tracking
-      access_count: 0,
-      last_accessed_at: now,
-
-      // Metadata
-      created_at: now,
-      updated_at: now,
-      version: 1,
-      tags: args.tags || [],
-      references: args.references || [],
-
-      // Template
-      template_id: args.template_id,
-
-      // Computed weight
-      base_weight: args.weight ?? 0.5,
-      computed_weight: args.weight ?? 0.5,
-
-      // Comment/threading fields (initialize to defaults)
-      parent_id: args.parent_id ?? null,
-      thread_root_id: args.thread_root_id ?? null,
-      moderation_flags: args.moderation_flags ?? [],
-
-      // Publication tracking arrays (Memory Collection Pattern v2)
-      // Managed by remember_publish / remember_retract — always start empty
-      space_ids: [],
-      group_ids: [],
-    };
-
-    // Insert into Weaviate v3 API
-    // v3 expects: { properties: {...} }
-    const result = await collection.data.insert({
-      properties: memory as any,
     });
 
-    logger.info('Memory created successfully', { memoryId: result, userId });
-
     const response: CreateMemoryResult = {
-      memory_id: result,
-      created_at: now,
-      message: `Memory created successfully with ID: ${result}`,
+      memory_id: result.memory_id,
+      created_at: result.created_at,
+      message: `Memory created successfully with ID: ${result.memory_id}`,
     };
 
     return JSON.stringify(response, null, 2);

package/src/tools/create-relationship.ts

@@ -3,12 +3,11 @@
  * Create a relationship connecting 2...N memories
  */
 
-import type { Relationship, MemoryContext } from '../types/memory.js';
-import { ensureMemoryCollection, getMemoryCollection } from '../weaviate/schema.js';
-import { logger } from '../utils/logger.js';
+import type { MemoryContext } from '../types/memory.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_create_relationship
@@ -103,189 +102,22 @@ export async function handleCreateRelationship(
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
 
-    logger.info('Creating relationship', {
-      userId,
-      type: args.relationship_type,
-      memoryCount: args.memory_ids.length
-    });
-
-    // Validate memory_ids count
-    if (args.memory_ids.length < 2) {
-      throw new Error('At least 2 memory IDs are required to create a relationship');
-    }
-
-    // Ensure collection exists
-    await ensureMemoryCollection(userId);
-    const collection = getMemoryCollection(userId);
-
-    // Verify all memories exist and belong to user
-    logger.info('Validating memories', { userId, memoryIds: args.memory_ids });
-    
-    const memoryChecks = await Promise.all(
-      args.memory_ids.map(async (memoryId) => {
-        try {
-          const memory = await collection.query.fetchObjectById(memoryId, {
-            returnProperties: ['user_id', 'doc_type', 'relationship_ids', 'deleted_at'],
-          });
-          
-          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' };
-          }
-          
-          // Check if memory is deleted
-          if (memory.properties.deleted_at) {
-            const deletedAt = typeof memory.properties.deleted_at === 'string'
-              ? memory.properties.deleted_at
-              : new Date(memory.properties.deleted_at as any).toISOString();
-            logger.warn('Attempt to create relationship with deleted memory', {
-              userId,
-              memoryId,
-              deletedAt
-            });
-            return { memoryId, error: `Memory is deleted (deleted on ${deletedAt})` };
-          }
-          
-          return {
-            memoryId,
-            memory,
-            relationships: (memory.properties.relationship_ids as string[]) || []
-          };
-        } catch (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}` };
-        }
-      })
-    );
-
-    // Check for errors
-    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
-    });
-
-    // Build relationship object
-    const now = new Date().toISOString();
-    const relationship: Record<string, any> = {
-      // Core identity
-      user_id: userId,
-      doc_type: 'relationship',
-
-      // Connection
-      related_memory_ids: args.memory_ids,
+    const { relationship } = createCoreServices(userId);
+    const result = await relationship.create({
+      memory_ids: args.memory_ids,
       relationship_type: args.relationship_type,
-
-      // Observation
       observation: args.observation,
-      strength: args.strength ?? 0.5,
-      confidence: args.confidence ?? 0.8,
-
-      // Context
-      context: {
-        timestamp: now,
-        source: {
-          type: 'api',
-          platform: 'mcp',
-        },
-        summary: context?.summary || 'Relationship created via MCP',
-        conversation_id: context?.conversation_id,
-        ...context,
-      },
-
-      // Metadata
-      created_at: now,
-      updated_at: now,
-      version: 1,
-      tags: args.tags || [],
-    };
-
-    // Insert relationship into Weaviate v3 API
-    // v3 expects: { properties: {...} }
-    const relationshipId = await collection.data.insert({
-      properties: relationship as any,
-    });
-
-    logger.info('Relationship created, updating connected memories', { 
-      relationshipId, 
-      userId 
-    });
-
-    // Update all connected memories with bidirectional reference
-    const updatePromises = memoryChecks
-      .filter(check => !check.error && check.memory)
-      .map(async (check) => {
-        try {
-          const existingRelationships = check.relationships || [];
-          const updatedRelationships = [...existingRelationships, relationshipId];
-          
-          await collection.data.update({
-            id: check.memoryId,
-            properties: {
-              relationship_ids: updatedRelationships,
-              updated_at: now,
-            },
-          });
-          
-          return { memoryId: check.memoryId, success: true };
-        } catch (error) {
-          logger.warn(`Failed to update memory ${check.memoryId} with relationship:`, error);
-          return { memoryId: check.memoryId, success: false, error };
-        }
-      });
-
-    const updateResults = await Promise.all(updatePromises);
-    const failedUpdates = updateResults.filter(r => !r.success);
-    
-    if (failedUpdates.length > 0) {
-      logger.warn('Some memory updates failed', { failedUpdates });
-    }
-
-    logger.info('Relationship created successfully', { 
-      relationshipId, 
-      userId,
-      updatedMemories: updateResults.filter(r => r.success).length
+      strength: args.strength,
+      confidence: args.confidence,
+      tags: args.tags,
     });
 
     const response: CreateRelationshipResult = {
-      relationship_id: relationshipId,
-      memory_ids: args.memory_ids,
+      relationship_id: result.relationship_id,
+      memory_ids: result.memory_ids,
       relationship_type: args.relationship_type,
-      created_at: now,
-      message: `Relationship created successfully with ID: ${relationshipId}. Connected ${args.memory_ids.length} memories.`,
+      created_at: result.created_at,
+      message: `Relationship created successfully with ID: ${result.relationship_id}. Connected ${args.memory_ids.length} memories.`,
     };
 
     return JSON.stringify(response, null, 2);
@@ -298,7 +130,7 @@ export async function handleCreateRelationship(
       memoryIds: args.memory_ids.join(', '),
       memoryCount: args.memory_ids.length,
       relationshipType: args.relationship_type,
-      observation: args.observation?.substring(0, 100), // First 100 chars
+      observation: args.observation?.substring(0, 100),
     });
   }
 }

package/src/tools/delete-memory.ts

@@ -4,13 +4,10 @@
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { Filters } from 'weaviate-client';
-import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties } from '../weaviate/client.js';
-import { confirmationTokenService } from '../services/confirmation-token.service.js';
-import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_delete_memory
@@ -66,90 +63,28 @@ export async function handleDeleteMemory(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    logger.info('Requesting memory deletion', {
-      userId, 
-      memoryId: args.memory_id,
-      hasReason: !!args.reason,
-    });
-
-    const { memory_id, reason } = args;
-    const client = getWeaviateClient();
-    const collectionName = getMemoryCollectionName(userId);
-    const collection = client.collections.get(collectionName);
-
-    // Fetch memory to verify ownership and get preview
-    const memory = await fetchMemoryWithAllProperties(collection, memory_id);
-
-    if (!memory) {
-      throw new Error(`Memory not found: ${memory_id}`);
-    }
-
-    // Verify ownership
-    if (memory.properties.user_id !== userId) {
-      throw new Error(`Cannot delete memory: not owned by user ${userId}`);
-    }
-
-    // Verify it's a memory (not a relationship)
-    if (memory.properties.doc_type !== 'memory') {
-      throw new Error('Cannot delete relationships using this tool. Use remember_delete_relationship instead.');
-    }
-
-    // Check if already deleted
-    if (memory.properties.deleted_at) {
-      throw new Error(`Memory ${memory_id} is already deleted`);
-    }
 
-    // Find relationships that will be orphaned
-    const relationshipsResult = await collection.query.fetchObjects({
-      filters: Filters.and(
-        collection.filter.byProperty('doc_type').equal('relationship'),
-        collection.filter.byProperty('related_memory_ids').containsAny([memory_id])
-      ),
-      limit: 100,
-    });
-
-    const orphanedRelationships = relationshipsResult.objects.map(r => r.uuid);
-
-    logger.info('Found relationships to orphan', {
-      userId,
-      memoryId: memory_id,
-      relationshipCount: orphanedRelationships.length,
-    });
+    const { token: tokenService } = createCoreServices(userId);
 
-    // Create confirmation token
-    const { requestId, token } = await confirmationTokenService.createRequest(
+    // Create confirmation token via core service
+    const { token } = await tokenService.createRequest(
       userId,
       'delete_memory',
       {
-        memory_id,
-        reason: reason || null,
+        memory_id: args.memory_id,
+        reason: args.reason || null,
       }
     );
 
     // Calculate expiry time (5 minutes from now)
     const expiresAt = new Date(Date.now() + 5 * 60 * 1000);
 
-    logger.info('Delete confirmation token created', {
-      userId,
-      memoryId: memory_id,
-      requestId,
-      token,
-      expiresAt: expiresAt.toISOString(),
-    });
-
-    // Return token and preview
     return JSON.stringify(
       {
         success: true,
         token,
         expires_at: expiresAt.toISOString(),
-        preview: {
-          memory_id,
-          content: memory.properties.content?.substring(0, 200) + (memory.properties.content?.length > 200 ? '...' : ''),
-          content_type: memory.properties.content_type,
-          relationships_count: orphanedRelationships.length,
-          will_orphan: orphanedRelationships,
-        },
+        memory_id: args.memory_id,
         message: `Deletion requested. Use remember_confirm with token to complete deletion. Token expires in 5 minutes.`,
       },
       null,

package/src/tools/delete-relationship.ts

@@ -3,11 +3,10 @@
  * Delete a relationship and clean up references in connected memories
  */
 
-import { getMemoryCollection } from '../weaviate/schema.js';
-import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_delete_relationship
@@ -66,99 +65,16 @@ export async function handleDeleteRelationship(
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
 
-    logger.info('Deleting relationship', { userId, relationshipId: args.relationship_id });
-
-    const collection = getMemoryCollection(userId);
-
-    // Get relationship to verify ownership and get connected memory IDs
-    const relationship = await collection.query.fetchObjectById(args.relationship_id, {
-      returnProperties: ['user_id', 'doc_type', 'related_memory_ids', 'relationship_type'],
-    });
-
-    if (!relationship) {
-      throw new Error(`Relationship not found: ${args.relationship_id}`);
-    }
-
-    // Verify ownership
-    if (relationship.properties.user_id !== userId) {
-      throw new Error('Unauthorized: Cannot delete another user\'s relationship');
-    }
-
-    // Verify it's a relationship (not a memory)
-    if (relationship.properties.doc_type !== 'relationship') {
-      throw new Error('Cannot delete memories using this tool. Use remember_delete_memory instead.');
-    }
-
-    const memoryIds = (relationship.properties.related_memory_ids as string[]) || [];
-    let memoriesUpdated = 0;
-
-    // Remove relationship reference from all connected memories
-    if (memoryIds.length > 0) {
-      logger.info('Cleaning up relationship references from connected memories', {
-        relationshipId: args.relationship_id,
-        memoryCount: memoryIds.length,
-      });
-
-      const updatePromises = memoryIds.map(async (memoryId) => {
-        try {
-          // Get current memory to read relationships array
-          const memory = await collection.query.fetchObjectById(memoryId, {
-            returnProperties: ['relationship_ids', 'doc_type'],
-          });
-
-          if (!memory || memory.properties.doc_type !== 'memory') {
-            logger.warn(`Memory ${memoryId} not found or not a memory, skipping cleanup`);
-            return { memoryId, success: false };
-          }
-
-          const currentRelationships = (memory.properties.relationship_ids as string[]) || [];
-          const updatedRelationships = currentRelationships.filter(
-            (relId) => relId !== args.relationship_id
-          );
-
-          // Only update if there was a change
-          if (updatedRelationships.length !== currentRelationships.length) {
-            await collection.data.update({
-              id: memoryId,
-              properties: {
-                relationship_ids: updatedRelationships,
-                updated_at: new Date().toISOString(),
-              },
-            });
-            return { memoryId, success: true };
-          }
-
-          return { memoryId, success: false };
-        } catch (error) {
-          logger.warn(`Failed to update memory ${memoryId}:`, error);
-          return { memoryId, success: false, error };
-        }
-      });
-
-      const updateResults = await Promise.all(updatePromises);
-      memoriesUpdated = updateResults.filter((r) => r.success).length;
-
-      logger.info('Memory cleanup completed', {
-        relationshipId: args.relationship_id,
-        memoriesUpdated,
-        totalMemories: memoryIds.length,
-      });
-    }
-
-    // Delete the relationship
-    await collection.data.deleteById(args.relationship_id);
-
-    logger.info('Relationship deleted successfully', {
-      userId,
-      relationshipId: args.relationship_id,
-      memoriesUpdated,
+    const { relationship } = createCoreServices(userId);
+    const coreResult = await relationship.delete({
+      relationship_id: args.relationship_id,
     });
 
     const result: DeleteRelationshipResult = {
-      relationship_id: args.relationship_id,
+      relationship_id: coreResult.relationship_id,
       deleted: true,
-      memories_updated: memoriesUpdated,
-      message: `Relationship deleted successfully${memoriesUpdated > 0 ? ` (${memoriesUpdated} memories updated)` : ''}`,
+      memories_updated: coreResult.memories_updated,
+      message: `Relationship deleted successfully${coreResult.memories_updated > 0 ? ` (${coreResult.memories_updated} memories updated)` : ''}`,
     };
 
     return JSON.stringify(result, null, 2);

package/src/tools/deny.ts

@@ -5,10 +5,10 @@
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { confirmationTokenService } from '../services/confirmation-token.service.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { createDebugLogger } from '../utils/debug.js';
 import type { AuthContext } from '../types/auth.js';
+import { createCoreServices } from '../core-services.js';
 
 /**
  * Tool definition for remember_deny
@@ -66,23 +66,13 @@ export async function handleDeny(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    const success = await confirmationTokenService.denyRequest(userId, args.token);
 
-    if (!success) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Invalid token',
-          message: 'Token not found or already used',
-        },
-        null,
-        2
-      );
-    }
+    const { space } = createCoreServices(userId);
+    const result = await space.deny({ token: args.token });
 
     return JSON.stringify(
       {
-        success: true,
+        success: result.success,
       },
       null,
       2