@prmichaelsen/remember-mcp 0.1.0 → 0.2.0

package/src/server.ts

@@ -17,6 +17,15 @@ import { logger } from './utils/logger.js';
 import { createMemoryTool, handleCreateMemory } from './tools/create-memory.js';
 import { searchMemoryTool, handleSearchMemory } from './tools/search-memory.js';
 import { deleteMemoryTool, handleDeleteMemory } from './tools/delete-memory.js';
+import { updateMemoryTool, handleUpdateMemory } from './tools/update-memory.js';
+import { findSimilarTool, handleFindSimilar } from './tools/find-similar.js';
+import { queryMemoryTool, handleQueryMemory } from './tools/query-memory.js';
+
+// Import relationship tools
+import { createRelationshipTool, handleCreateRelationship } from './tools/create-relationship.js';
+import { updateRelationshipTool, handleUpdateRelationship } from './tools/update-relationship.js';
+import { searchRelationshipTool, handleSearchRelationship } from './tools/search-relationship.js';
+import { deleteRelationshipTool, handleDeleteRelationship } from './tools/delete-relationship.js';
 
 /**
  * Initialize remember-mcp server
@@ -78,9 +87,18 @@ function registerHandlers(server: Server): void {
             properties: {},
           },
         },
+        // Memory tools
         createMemoryTool,
         searchMemoryTool,
         deleteMemoryTool,
+        updateMemoryTool,
+        findSimilarTool,
+        queryMemoryTool,
+        // Relationship tools
+        createRelationshipTool,
+        updateRelationshipTool,
+        searchRelationshipTool,
+        deleteRelationshipTool,
       ],
     };
   });
@@ -113,6 +131,34 @@ function registerHandlers(server: Server): void {
           result = await handleDeleteMemory(args as any, userId);
           break;
 
+        case 'remember_update_memory':
+          result = await handleUpdateMemory(args as any, userId);
+          break;
+
+        case 'remember_find_similar':
+          result = await handleFindSimilar(args as any, userId);
+          break;
+
+        case 'remember_query_memory':
+          result = await handleQueryMemory(args as any, userId);
+          break;
+
+        case 'remember_create_relationship':
+          result = await handleCreateRelationship(args as any, userId);
+          break;
+
+        case 'remember_update_relationship':
+          result = await handleUpdateRelationship(args as any, userId);
+          break;
+
+        case 'remember_search_relationship':
+          result = await handleSearchRelationship(args as any, userId);
+          break;
+
+        case 'remember_delete_relationship':
+          result = await handleDeleteRelationship(args as any, userId);
+          break;
+
         default:
           throw new McpError(
             ErrorCode.MethodNotFound,

package/src/tools/create-relationship.ts

@@ -0,0 +1,242 @@
+/**
+ * remember_create_relationship tool
+ * 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';
+
+/**
+ * Tool definition for remember_create_relationship
+ */
+export const createRelationshipTool = {
+  name: 'remember_create_relationship',
+  description: `Create a relationship connecting 2 or more memories.
+  
+  Relationships describe how memories are connected with free-form types.
+  Each relationship has an observation (description), strength, and confidence.
+  Bidirectional: connected memories are automatically updated with the relationship ID.
+  
+  Examples:
+  - "The Yosemite trip inspired my Sequoia planning"
+  - "My tent purchase was caused by the camping trip"
+  - "This recipe contradicts my previous cooking notes"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      memory_ids: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Array of 2 or more memory IDs to connect',
+        minItems: 2,
+      },
+      relationship_type: {
+        type: 'string',
+        description: 'Type of relationship (free-form): "inspired_by", "contradicts", "caused_by", "related_to", etc.',
+      },
+      observation: {
+        type: 'string',
+        description: 'Description of the connection (will be vectorized for semantic search)',
+      },
+      strength: {
+        type: 'number',
+        description: 'Strength of the relationship (0-1, default: 0.5)',
+        minimum: 0,
+        maximum: 1,
+      },
+      confidence: {
+        type: 'number',
+        description: 'Confidence in this relationship (0-1, default: 0.8)',
+        minimum: 0,
+        maximum: 1,
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags for organization',
+      },
+    },
+    required: ['memory_ids', 'relationship_type', 'observation'],
+  },
+};
+
+/**
+ * Create relationship arguments
+ */
+export interface CreateRelationshipArgs {
+  memory_ids: string[];
+  relationship_type: string;
+  observation: string;
+  strength?: number;
+  confidence?: number;
+  tags?: string[];
+}
+
+/**
+ * Create relationship result
+ */
+export interface CreateRelationshipResult {
+  relationship_id: string;
+  memory_ids: string[];
+  relationship_type: string;
+  created_at: string;
+  message: string;
+}
+
+/**
+ * Handle remember_create_relationship tool
+ */
+export async function handleCreateRelationship(
+  args: CreateRelationshipArgs,
+  userId: string,
+  context?: Partial<MemoryContext>
+): Promise<string> {
+  try {
+    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
+    const memoryChecks = await Promise.all(
+      args.memory_ids.map(async (memoryId) => {
+        try {
+          const memory = await collection.query.fetchObjectById(memoryId, {
+            returnProperties: ['user_id', 'doc_type', 'relationships'],
+          });
+          
+          if (!memory) {
+            return { memoryId, error: 'Memory not found' };
+          }
+          
+          if (memory.properties.user_id !== userId) {
+            return { memoryId, error: 'Unauthorized: Memory belongs to another user' };
+          }
+          
+          if (memory.properties.doc_type !== 'memory') {
+            return { memoryId, error: 'Cannot create relationship with non-memory document' };
+          }
+          
+          return { 
+            memoryId, 
+            memory,
+            relationships: (memory.properties.relationships as string[]) || []
+          };
+        } catch (error) {
+          return { memoryId, error: `Failed to fetch memory: ${error}` };
+        }
+      })
+    );
+
+    // Check for errors
+    const errors = memoryChecks.filter(check => check.error);
+    if (errors.length > 0) {
+      const errorMessages = errors.map(e => `${e.memoryId}: ${e.error}`).join('; ');
+      throw new Error(`Memory validation failed: ${errorMessages}`);
+    }
+
+    // Build relationship object
+    const now = new Date().toISOString();
+    const relationship: Omit<Relationship, 'id'> = {
+      // Core identity
+      user_id: userId,
+      doc_type: 'relationship',
+
+      // Connection
+      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
+    const relationshipId = await collection.data.insert(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: {
+              relationships: 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
+    });
+
+    const response: CreateRelationshipResult = {
+      relationship_id: relationshipId,
+      memory_ids: args.memory_ids,
+      relationship_type: args.relationship_type,
+      created_at: now,
+      message: `Relationship created successfully with ID: ${relationshipId}. Connected ${args.memory_ids.length} memories.`,
+    };
+
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    logger.error('Failed to create relationship:', error);
+    throw new Error(`Failed to create relationship: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/delete-relationship.ts

@@ -0,0 +1,160 @@
+/**
+ * remember_delete_relationship tool
+ * Delete a relationship and clean up references in connected memories
+ */
+
+import { getMemoryCollection } from '../weaviate/schema.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Tool definition for remember_delete_relationship
+ */
+export const deleteRelationshipTool = {
+  name: 'remember_delete_relationship',
+  description: `Delete a relationship from your collection.
+  
+  Automatically removes the relationship reference from all connected memories.
+  This action cannot be undone.
+  
+  Examples:
+  - "Delete that inspiration relationship"
+  - "Remove the connection between those memories"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      relationship_id: {
+        type: 'string',
+        description: 'ID of the relationship to delete',
+      },
+    },
+    required: ['relationship_id'],
+  },
+};
+
+/**
+ * Delete relationship arguments
+ */
+export interface DeleteRelationshipArgs {
+  relationship_id: string;
+}
+
+/**
+ * Delete relationship result
+ */
+export interface DeleteRelationshipResult {
+  relationship_id: string;
+  deleted: boolean;
+  memories_updated: number;
+  message: string;
+}
+
+/**
+ * Handle remember_delete_relationship tool
+ */
+export async function handleDeleteRelationship(
+  args: DeleteRelationshipArgs,
+  userId: string
+): Promise<string> {
+  try {
+    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', '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.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: ['relationships', '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.relationships 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: {
+                relationships: 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 result: DeleteRelationshipResult = {
+      relationship_id: args.relationship_id,
+      deleted: true,
+      memories_updated: memoriesUpdated,
+      message: `Relationship deleted successfully${memoriesUpdated > 0 ? ` (${memoriesUpdated} memories updated)` : ''}`,
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error('Failed to delete relationship:', error);
+    throw new Error(`Failed to delete relationship: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/find-similar.ts

@@ -0,0 +1,199 @@
+/**
+ * remember_find_similar tool
+ * Find similar memories using vector similarity search
+ */
+
+import type { Memory } from '../types/memory.js';
+import { getMemoryCollection } from '../weaviate/schema.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Tool definition for remember_find_similar
+ */
+export const findSimilarTool = {
+  name: 'remember_find_similar',
+  description: `Find memories similar to a given memory or text using vector similarity.
+  
+  Uses pure semantic similarity (vector distance) to find related memories.
+  This is different from hybrid search - it finds memories with similar meaning,
+  even if they don't share keywords.
+  
+  Examples:
+  - "Find memories similar to this camping trip note"
+  - "Show me memories related to this recipe"
+  - "What other memories are like this meeting note?"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      memory_id: {
+        type: 'string',
+        description: 'ID of memory to find similar memories for (provide either memory_id or text)',
+      },
+      text: {
+        type: 'string',
+        description: 'Text to find similar memories for (provide either memory_id or text)',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results. Default: 10',
+        minimum: 1,
+        maximum: 100,
+        default: 10,
+      },
+      min_similarity: {
+        type: 'number',
+        description: 'Minimum similarity score (0-1). Default: 0.7',
+        minimum: 0,
+        maximum: 1,
+        default: 0.7,
+      },
+      include_relationships: {
+        type: 'boolean',
+        description: 'Include relationships in results. Default: false',
+        default: false,
+      },
+    },
+  },
+};
+
+/**
+ * Find similar arguments
+ */
+export interface FindSimilarArgs {
+  memory_id?: string;
+  text?: string;
+  limit?: number;
+  min_similarity?: number;
+  include_relationships?: boolean;
+}
+
+/**
+ * Similar memory result
+ */
+export interface SimilarMemory extends Partial<Memory> {
+  similarity: number; // 0-1 similarity score
+}
+
+/**
+ * Find similar result
+ */
+export interface FindSimilarResult {
+  query: {
+    memory_id?: string;
+    text?: string;
+  };
+  similar_memories: SimilarMemory[];
+  total: number;
+  min_similarity: number;
+}
+
+/**
+ * Handle remember_find_similar tool
+ */
+export async function handleFindSimilar(
+  args: FindSimilarArgs,
+  userId: string
+): Promise<string> {
+  try {
+    logger.info('Finding similar memories', { userId, memoryId: args.memory_id, hasText: !!args.text });
+
+    // Validate input
+    if (!args.memory_id && !args.text) {
+      throw new Error('Either memory_id or text must be provided');
+    }
+
+    if (args.memory_id && args.text) {
+      throw new Error('Provide either memory_id or text, not both');
+    }
+
+    const collection = getMemoryCollection(userId);
+    const limit = args.limit ?? 10;
+    const minSimilarity = args.min_similarity ?? 0.7;
+
+    let results: any;
+
+    if (args.memory_id) {
+      // Find similar to existing memory
+      // First get the memory to verify ownership
+      const memory = await collection.query.fetchObjectById(args.memory_id, {
+        returnProperties: ['user_id', 'doc_type', 'content'],
+      });
+
+      if (!memory) {
+        throw new Error(`Memory not found: ${args.memory_id}`);
+      }
+
+      // Verify ownership
+      if (memory.properties.user_id !== userId) {
+        throw new Error('Unauthorized: Cannot access another user\'s memory');
+      }
+
+      // Verify it's a memory
+      if (memory.properties.doc_type !== 'memory') {
+        throw new Error('Can only find similar memories for memory documents, not relationships');
+      }
+
+      // Find similar using nearObject
+      results = await collection.query.nearObject(args.memory_id, {
+        limit: limit + 1, // +1 to exclude the source memory itself
+        distance: 1 - minSimilarity, // Convert similarity to distance
+        returnMetadata: ['distance'],
+      });
+
+      // 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!, {
+        limit: limit,
+        distance: 1 - minSimilarity,
+        returnMetadata: ['distance'],
+      });
+    }
+
+    // Filter to only memories (not relationships) unless requested
+    if (!args.include_relationships) {
+      results.objects = results.objects.filter(
+        (obj: any) => obj.properties.doc_type === 'memory'
+      );
+    }
+
+    // Format results with similarity scores
+    const similarMemories: SimilarMemory[] = results.objects.map((obj: any) => {
+      const similarity = 1 - (obj.metadata?.distance ?? 0); // Convert distance back to similarity
+      return {
+        id: obj.uuid,
+        ...obj.properties,
+        similarity: Math.max(0, Math.min(1, similarity)), // Clamp to [0, 1]
+      };
+    });
+
+    // Sort by similarity (highest first)
+    similarMemories.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+
+    // Limit results
+    const limitedResults = similarMemories.slice(0, limit);
+
+    logger.info('Similar memories found', {
+      userId,
+      query: args.memory_id || args.text,
+      results: limitedResults.length,
+    });
+
+    const result: FindSimilarResult = {
+      query: {
+        memory_id: args.memory_id,
+        text: args.text,
+      },
+      similar_memories: limitedResults,
+      total: limitedResults.length,
+      min_similarity: minSimilarity,
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error('Failed to find similar memories:', error);
+    throw new Error(`Failed to find similar memories: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}