@prmichaelsen/remember-mcp 0.1.0 → 0.2.1

package/src/server-factory.ts

@@ -11,35 +11,84 @@ import {
   McpError,
 } from '@modelcontextprotocol/sdk/types.js';
 import { logger } from './utils/logger.js';
+import { initWeaviateClient } from './weaviate/client.js';
+import { initFirestore } from './firestore/init.js';
 
 // Import memory tools
 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';
 
 export interface ServerOptions {
   name?: string;
   version?: string;
 }
 
+// Global initialization flag to ensure databases are initialized once
+let databasesInitialized = false;
+let initializationPromise: Promise<void> | null = null;
+
+/**
+ * Initialize databases (called once globally)
+ */
+async function ensureDatabasesInitialized(): Promise<void> {
+  if (databasesInitialized) {
+    return;
+  }
+  
+  // If initialization is in progress, wait for it
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  
+  // Start initialization
+  initializationPromise = (async () => {
+    try {
+      logger.info('Initializing databases...');
+      await initWeaviateClient();
+      initFirestore();
+      databasesInitialized = true;
+      logger.info('Databases initialized successfully');
+    } catch (error) {
+      logger.error('Database initialization failed:', error);
+      throw error;
+    } finally {
+      initializationPromise = null;
+    }
+  })();
+  
+  return initializationPromise;
+}
+
 /**
  * Create a server instance for a specific user/tenant
- * 
+ *
  * This factory function is compatible with mcp-auth wrapping pattern.
  * It creates isolated server instances with no shared state.
- * 
+ *
+ * Note: Databases (Weaviate + Firestore) are initialized once globally on first call.
+ *
  * @param accessToken - User's access token (reserved for future external APIs)
  * @param userId - User identifier for scoping operations
  * @param options - Optional server configuration
  * @returns Configured MCP Server instance (not connected to transport)
- * 
+ *
  * @example
  * ```typescript
  * // Direct usage
  * const server = createServer('token', 'user123');
  * const transport = new StdioServerTransport();
  * await server.connect(transport);
- * 
+ *
  * // With mcp-auth
  * import { wrapServer } from '@prmichaelsen/mcp-auth';
  * const wrapped = wrapServer({
@@ -66,11 +115,18 @@ export function createServer(
   
   logger.debug('Creating server instance', { userId });
   
+  // Ensure databases are initialized (happens once globally)
+  // Note: This is synchronous to match the Server return type
+  // The actual initialization happens on first tool call
+  ensureDatabasesInitialized().catch(error => {
+    logger.error('Failed to initialize databases:', error);
+  });
+  
   // Create MCP server
   const server = new Server(
     {
       name: options.name || 'remember-mcp',
-      version: options.version || '0.1.0',
+      version: options.version || '0.2.0',
     },
     {
       capabilities: {
@@ -101,9 +157,18 @@ function registerHandlers(server: Server, userId: string, accessToken: string):
             properties: {},
           },
         },
+        // Memory tools
         createMemoryTool,
         searchMemoryTool,
         deleteMemoryTool,
+        updateMemoryTool,
+        findSimilarTool,
+        queryMemoryTool,
+        // Relationship tools
+        createRelationshipTool,
+        updateRelationshipTool,
+        searchRelationshipTool,
+        deleteRelationshipTool,
       ],
     };
   });
@@ -132,6 +197,34 @@ function registerHandlers(server: Server, userId: string, accessToken: string):
           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/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)}`);
+  }
+}