@prmichaelsen/remember-mcp 2.8.0 → 3.0.0

package/dist/tools/delete-memory.d.ts

@@ -1,47 +1,22 @@
 /**
  * remember_delete_memory tool
- * Delete a memory from the user's collection
+ * Request to delete a memory (requires confirmation)
  */
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 /**
  * Tool definition for remember_delete_memory
  */
-export declare const deleteMemoryTool: {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: string;
-        properties: {
-            memory_id: {
-                type: string;
-                description: string;
-            };
-            delete_relationships: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-        };
-        required: string[];
-    };
-};
+export declare const deleteMemoryTool: Tool;
 /**
  * Delete memory arguments
  */
 export interface DeleteMemoryArgs {
     memory_id: string;
-    delete_relationships?: boolean;
-}
-/**
- * Delete memory result
- */
-export interface DeleteMemoryResult {
-    memory_id: string;
-    deleted: boolean;
-    relationships_deleted?: number;
-    message: string;
+    reason?: string;
 }
 /**
  * Handle remember_delete_memory tool
+ * Creates confirmation token and returns preview
  */
 export declare function handleDeleteMemory(args: DeleteMemoryArgs, userId: string): Promise<string>;
 //# sourceMappingURL=delete-memory.d.ts.map

package/dist/tools/find-similar.d.ts

@@ -2,7 +2,7 @@
  * remember_find_similar tool
  * Find similar memories using vector similarity search
  */
-import type { Memory } from '../types/memory.js';
+import type { Memory, DeletedFilter } from '../types/memory.js';
 /**
  * Tool definition for remember_find_similar
  */
@@ -39,6 +39,12 @@ export declare const findSimilarTool: {
                 description: string;
                 default: boolean;
             };
+            deleted_filter: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
         };
     };
 };
@@ -51,6 +57,7 @@ export interface FindSimilarArgs {
     limit?: number;
     min_similarity?: number;
     include_relationships?: boolean;
+    deleted_filter?: DeletedFilter;
 }
 /**
  * Similar memory result

package/dist/tools/query-memory.d.ts

@@ -2,7 +2,7 @@
  * remember_query_memory tool
  * RAG (Retrieval-Augmented Generation) queries with natural language
  */
-import type { Memory, SearchFilters } from '../types/memory.js';
+import type { Memory, SearchFilters, DeletedFilter } from '../types/memory.js';
 /**
  * Tool definition for remember_query_memory
  */
@@ -77,6 +77,12 @@ export declare const queryMemoryTool: {
                 enum: string[];
                 default: string;
             };
+            deleted_filter: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -91,6 +97,7 @@ export interface QueryMemoryArgs {
     filters?: SearchFilters;
     include_context?: boolean;
     format?: 'detailed' | 'compact';
+    deleted_filter?: DeletedFilter;
 }
 /**
  * Memory with relevance score

package/dist/tools/search-memory.d.ts

@@ -77,6 +77,12 @@ export declare const searchMemoryTool: {
                 description: string;
                 default: boolean;
             };
+            deleted_filter: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
         };
         required: string[];
     };

package/dist/tools/search-relationship.d.ts

@@ -2,7 +2,7 @@
  * remember_search_relationship tool
  * Search relationships by observation text or type
  */
-import type { Relationship } from '../types/memory.js';
+import type { Relationship, DeletedFilter } from '../types/memory.js';
 /**
  * Tool definition for remember_search_relationship
  */
@@ -53,6 +53,12 @@ export declare const searchRelationshipTool: {
                 description: string;
                 minimum: number;
             };
+            deleted_filter: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -68,6 +74,7 @@ export interface SearchRelationshipArgs {
     tags?: string[];
     limit?: number;
     offset?: number;
+    deleted_filter?: DeletedFilter;
 }
 /**
  * Search relationship result

package/dist/types/memory.d.ts

@@ -114,6 +114,9 @@ export interface Memory {
     parent_id?: string | null;
     thread_root_id?: string | null;
     moderation_flags?: string[];
+    deleted_at?: Date | null;
+    deleted_by?: string;
+    deletion_reason?: string;
 }
 /**
  * Relationship interface
@@ -162,6 +165,10 @@ export interface SearchFilters {
     location_radius_meters?: number;
     has_relationships?: boolean;
 }
+/**
+ * Deleted filter type
+ */
+export type DeletedFilter = 'exclude' | 'include' | 'only';
 /**
  * Search options
  */
@@ -170,6 +177,7 @@ export interface SearchOptions {
     alpha?: number;
     filters?: SearchFilters;
     include_relationships?: boolean;
+    deleted_filter?: DeletedFilter;
     limit?: number;
     offset?: number;
 }

package/dist/types/space-memory.d.ts

@@ -47,6 +47,9 @@ export interface SpaceMemory extends Omit<Memory, 'user_id' | 'doc_type'> {
      * Always 'space_memory' for space memories
      */
     doc_type: 'space_memory';
+    deleted_at?: Date | null;
+    deleted_by?: string;
+    deletion_reason?: string;
 }
 /**
  * Search options for space memories

package/dist/utils/weaviate-filters.d.ts

@@ -5,6 +5,10 @@
  * Replaces old v2 filter format (path/operator/valueText) with v3 collection.filter.byProperty()
  */
 import type { SearchFilters } from '../types/memory.js';
+/**
+ * Deleted filter options
+ */
+export type DeletedFilter = 'exclude' | 'include' | 'only';
 /**
  * Build filters for searching both memories and relationships
  * Uses OR logic: (doc_type=memory AND memory_filters) OR (doc_type=relationship AND relationship_filters)
@@ -30,8 +34,23 @@ export declare function buildMemoryOnlyFilters(collection: any, filters?: Search
  * @returns Combined filter or undefined if no filters
  */
 export declare function buildRelationshipOnlyFilters(collection: any, filters?: SearchFilters): any;
+/**
+ * Combine multiple filters with AND logic
+ *
+ * @param filters - Array of filter objects
+ * @returns Combined filter or undefined
+ */
+export declare function combineFiltersWithAnd(filters: any[]): any;
 /**
  * Helper to check if a filter result is empty
  */
 export declare function hasFilters(filter: any): boolean;
+/**
+ * Build filter for deleted_at field based on deleted_filter parameter
+ *
+ * @param collection - Weaviate collection instance
+ * @param deletedFilter - Filter mode: 'exclude' (default), 'include', or 'only'
+ * @returns Filter for deleted_at field, or null if no filter needed
+ */
+export declare function buildDeletedFilter(collection: any, deletedFilter?: DeletedFilter): any | null;
 //# sourceMappingURL=weaviate-filters.d.ts.map

package/dist/weaviate/client.d.ts

@@ -41,7 +41,7 @@ export declare function getAuditCollectionName(userId: string): string;
  * List of all memory properties to fetch
  * Matches the actual Weaviate schema properties exactly
  */
-export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "content", "title", "summary", "type", "weight", "base_weight", "trust", "confidence", "computed_weight", "location_gps_lat", "location_gps_lng", "location_address", "location_city", "location_country", "location_source", "locale_language", "locale_timezone", "context_conversation_id", "context_summary", "context_timestamp", "relationships", "access_count", "last_accessed_at", "tags", "references", "created_at", "updated_at", "version", "template_id", "memory_ids", "relationship_type", "observation", "strength", "parent_id", "thread_root_id", "moderation_flags", "spaces", "space_id", "author_id", "ghost_id", "attribution", "published_at", "discovery_count", "space_memory_id"];
+export declare const ALL_MEMORY_PROPERTIES: readonly ["user_id", "doc_type", "content", "title", "summary", "type", "weight", "base_weight", "trust", "confidence", "computed_weight", "location_gps_lat", "location_gps_lng", "location_address", "location_city", "location_country", "location_source", "locale_language", "locale_timezone", "context_conversation_id", "context_summary", "context_timestamp", "relationships", "access_count", "last_accessed_at", "tags", "references", "created_at", "updated_at", "version", "template_id", "memory_ids", "relationship_type", "observation", "strength", "parent_id", "thread_root_id", "moderation_flags", "spaces", "space_id", "author_id", "ghost_id", "attribution", "published_at", "discovery_count", "space_memory_id", "deleted_at", "deleted_by", "deletion_reason"];
 /**
  * Fetch a memory object by ID with all properties
  *

package/package.json

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

package/src/tools/confirm.ts

@@ -7,7 +7,7 @@
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { confirmationTokenService, type ConfirmationRequest } from '../services/confirmation-token.service.js';
-import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties } from '../weaviate/client.js';
+import { getWeaviateClient, getMemoryCollectionName, fetchMemoryWithAllProperties, sanitizeUserId } from '../weaviate/client.js';
 import { ensurePublicCollection } from '../weaviate/space-schema.js';
 import { handleToolError } from '../utils/error-handler.js';
 import { logger } from '../utils/logger.js';
@@ -120,6 +120,11 @@ export async function handleConfirm(
       return await executePublishMemory(request, userId);
     }
 
+    // Handle delete_memory action
+    if (request.action === 'delete_memory') {
+      return await executeDeleteMemory(request, userId);
+    }
+
     // Add other action types here as needed
     // if (request.action === 'retract_memory') {
     //   return await executeRetractMemory(request, userId);
@@ -380,3 +385,62 @@ async function executePublishMemory(
     });
   }
 }
+
+/**
+ * Execute delete memory action
+ */
+async function executeDeleteMemory(
+  request: ConfirmationRequest & { request_id: string },
+  userId: string
+): Promise<string> {
+  try {
+    logger.info('Executing delete memory action', {
+      function: 'executeDeleteMemory',
+      userId,
+      memoryId: request.payload.memory_id,
+      hasReason: !!request.payload.reason,
+    });
+
+    const { memory_id, reason } = request.payload;
+
+    // Soft delete the memory
+    const client = getWeaviateClient();
+    const collectionName = `Memory_${sanitizeUserId(userId)}`;
+    const collection = client.collections.get(collectionName);
+
+    await collection.data.update({
+      id: memory_id,
+      properties: {
+        deleted_at: new Date().toISOString(),
+        deleted_by: userId,
+        deletion_reason: reason || null,
+      },
+    });
+
+    logger.info('Memory soft-deleted successfully', {
+      function: 'executeDeleteMemory',
+      userId,
+      memoryId: memory_id,
+      deletedAt: new Date().toISOString(),
+    });
+
+    return JSON.stringify(
+      {
+        success: true,
+        memory_id,
+        message: 'Memory deleted successfully',
+      },
+      null,
+      2
+    );
+  } catch (error) {
+    logger.error('Failed to execute delete memory', {
+      function: 'executeDeleteMemory',
+      userId,
+      memoryId: request.payload.memory_id,
+      error: error instanceof Error ? error.message : String(error),
+      stack: error instanceof Error ? error.stack : undefined,
+    });
+    throw error;
+  }
+}

package/src/tools/create-relationship.ts

@@ -117,7 +117,7 @@ export async function handleCreateRelationship(
       args.memory_ids.map(async (memoryId) => {
         try {
           const memory = await collection.query.fetchObjectById(memoryId, {
-            returnProperties: ['user_id', 'doc_type', 'relationships'],
+            returnProperties: ['user_id', 'doc_type', 'relationships', 'deleted_at'],
           });
           
           if (!memory) {
@@ -143,6 +143,19 @@ export async function handleCreateRelationship(
             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,

package/src/tools/delete-memory.ts

@@ -1,26 +1,32 @@
 /**
  * remember_delete_memory tool
- * Delete a memory from the user's collection
+ * Request to delete a memory (requires confirmation)
  */
 
-import { getMemoryCollection } from '../weaviate/schema.js';
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { Filters } from 'weaviate-client';
+import { getWeaviateClient, sanitizeUserId, 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';
 
 /**
  * Tool definition for remember_delete_memory
  */
-export const deleteMemoryTool = {
+export const deleteMemoryTool: Tool = {
   name: 'remember_delete_memory',
-  description: `Delete a memory from your collection.
+  description: `Request to delete a memory. Requires confirmation via remember_confirm.
   
-  Optionally delete connected relationships as well.
-  This action cannot be undone.
-  
-  Examples:
-  - "Delete that old camping note"
-  - "Remove the recipe I saved yesterday"
-  `,
+⚠️ **IMPORTANT**: This is a two-step process:
+1. Call remember_delete_memory to request deletion (returns token)
+2. User must confirm via remember_confirm with the token
+
+The memory will be soft-deleted (marked as deleted but not removed from database).
+
+Examples:
+- "Delete that old camping note"
+- "Remove the recipe I saved yesterday"
+`,
   inputSchema: {
     type: 'object',
     properties: {
@@ -28,10 +34,9 @@ export const deleteMemoryTool = {
         type: 'string',
         description: 'ID of the memory to delete',
       },
-      delete_relationships: {
-        type: 'boolean',
-        description: 'Also delete connected relationships. Default: false',
-        default: false,
+      reason: {
+        type: 'string',
+        description: 'Optional reason for deletion',
       },
     },
     required: ['memory_id'],
@@ -43,43 +48,39 @@ export const deleteMemoryTool = {
  */
 export interface DeleteMemoryArgs {
   memory_id: string;
-  delete_relationships?: boolean;
-}
-
-/**
- * Delete memory result
- */
-export interface DeleteMemoryResult {
-  memory_id: string;
-  deleted: boolean;
-  relationships_deleted?: number;
-  message: string;
+  reason?: string;
 }
 
 /**
  * Handle remember_delete_memory tool
+ * Creates confirmation token and returns preview
  */
 export async function handleDeleteMemory(
   args: DeleteMemoryArgs,
   userId: string
 ): Promise<string> {
   try {
-    logger.info('Deleting memory', { userId, memoryId: args.memory_id });
+    logger.info('Requesting memory deletion', { 
+      userId, 
+      memoryId: args.memory_id,
+      hasReason: !!args.reason,
+    });
 
-    const collection = getMemoryCollection(userId);
+    const { memory_id, reason } = args;
+    const client = getWeaviateClient();
+    const collectionName = `Memory_${sanitizeUserId(userId)}`;
+    const collection = client.collections.get(collectionName);
 
-    // Get memory to verify ownership and get relationships
-    const memory = await collection.query.fetchObjectById(args.memory_id, {
-      returnProperties: ['user_id', 'doc_type', 'relationships'],
-    });
+    // Fetch memory to verify ownership and get preview
+    const memory = await fetchMemoryWithAllProperties(collection, memory_id);
 
     if (!memory) {
-      throw new Error(`Memory not found: ${args.memory_id}`);
+      throw new Error(`Memory not found: ${memory_id}`);
     }
 
     // Verify ownership
     if (memory.properties.user_id !== userId) {
-      throw new Error('Unauthorized: Cannot delete another user\'s memory');
+      throw new Error(`Cannot delete memory: not owned by user ${userId}`);
     }
 
     // Verify it's a memory (not a relationship)
@@ -87,46 +88,73 @@ export async function handleDeleteMemory(
       throw new Error('Cannot delete relationships using this tool. Use remember_delete_relationship instead.');
     }
 
-    let relationshipsDeleted = 0;
-
-    // Delete connected relationships if requested
-    if (args.delete_relationships && memory.properties.relationships) {
-      const relationshipIds = memory.properties.relationships as string[];
-      
-      for (const relId of relationshipIds) {
-        try {
-          await collection.data.deleteById(relId);
-          relationshipsDeleted++;
-        } catch (error) {
-          logger.warn(`Failed to delete relationship ${relId}:`, error);
-        }
-      }
+    // Check if already deleted
+    if (memory.properties.deleted_at) {
+      throw new Error(`Memory ${memory_id} is already deleted`);
     }
 
-    // Delete the memory
-    await collection.data.deleteById(args.memory_id);
+    // 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('memory_ids').containsAny([memory_id])
+      ),
+      limit: 100,
+    });
 
-    logger.info('Memory deleted successfully', { 
-      userId, 
-      memoryId: args.memory_id,
-      relationshipsDeleted 
+    const orphanedRelationships = relationshipsResult.objects.map(r => r.uuid);
+
+    logger.info('Found relationships to orphan', {
+      userId,
+      memoryId: memory_id,
+      relationshipCount: orphanedRelationships.length,
     });
 
-    const result: DeleteMemoryResult = {
-      memory_id: args.memory_id,
-      deleted: true,
-      relationships_deleted: relationshipsDeleted,
-      message: `Memory deleted successfully${relationshipsDeleted > 0 ? ` (${relationshipsDeleted} relationships also deleted)` : ''}`,
-    };
+    // Create confirmation token
+    const { requestId, token } = await confirmationTokenService.createRequest(
+      userId,
+      'delete_memory',
+      {
+        memory_id,
+        reason: 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 JSON.stringify(result, null, 2);
+    // 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 ? '...' : ''),
+          type: memory.properties.type,
+          relationships_count: orphanedRelationships.length,
+          will_orphan: orphanedRelationships,
+        },
+        message: `Deletion requested. Use remember_confirm with token to complete deletion. Token expires in 5 minutes.`,
+      },
+      null,
+      2
+    );
   } catch (error) {
     handleToolError(error, {
       toolName: 'remember_delete_memory',
-      operation: 'delete memory',
       userId,
+      operation: 'request delete',
       memoryId: args.memory_id,
-      deleteRelationships: args.delete_relationships,
     });
   }
 }

package/src/tools/find-similar.ts

@@ -3,10 +3,11 @@
  * Find similar memories using vector similarity search
  */
 
-import type { Memory } from '../types/memory.js';
+import type { Memory, DeletedFilter } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
+import { buildDeletedFilter } from '../utils/weaviate-filters.js';
 
 /**
  * Tool definition for remember_find_similar
@@ -54,6 +55,12 @@ export const findSimilarTool = {
         description: 'Include relationships in results. Default: false',
         default: false,
       },
+      deleted_filter: {
+        type: 'string',
+        enum: ['exclude', 'include', 'only'],
+        default: 'exclude',
+        description: 'Filter deleted memories: "exclude" (default, hide deleted), "include" (show all), "only" (show only deleted)',
+      },
     },
   },
 };
@@ -67,6 +74,7 @@ export interface FindSimilarArgs {
   limit?: number;
   min_similarity?: number;
   include_relationships?: boolean;
+  deleted_filter?: DeletedFilter;
 }
 
 /**
@@ -112,6 +120,9 @@ export async function handleFindSimilar(
     const limit = args.limit ?? 10;
     const minSimilarity = args.min_similarity ?? 0.7;
 
+    // Build deleted filter
+    const deletedFilter = buildDeletedFilter(collection, args.deleted_filter || 'exclude');
+
     let results: any;
 
     if (args.memory_id) {
@@ -136,21 +147,35 @@ export async function handleFindSimilar(
       }
 
       // Find similar using nearObject
-      results = await collection.query.nearObject(args.memory_id, {
+      const searchOptions: any = {
         limit: limit + 1, // +1 to exclude the source memory itself
         distance: 1 - minSimilarity, // Convert similarity to distance
         returnMetadata: ['distance'],
-      });
+      };
+
+      // Add deleted filter if present
+      if (deletedFilter) {
+        searchOptions.filters = deletedFilter;
+      }
+
+      results = await collection.query.nearObject(args.memory_id, searchOptions);
 
       // Filter out the source memory
       results.objects = results.objects.filter((obj: any) => obj.uuid !== args.memory_id);
     } else {
       // Find similar to text
-      results = await collection.query.nearText(args.text!, {
+      const searchOptions: any = {
         limit: limit,
         distance: 1 - minSimilarity,
         returnMetadata: ['distance'],
-      });
+      };
+
+      // Add deleted filter if present
+      if (deletedFilter) {
+        searchOptions.filters = deletedFilter;
+      }
+
+      results = await collection.query.nearText(args.text!, searchOptions);
     }
 
     // Filter to only memories (not relationships) unless requested