@prmichaelsen/remember-mcp 2.0.2 → 2.0.4

package/src/tools/search-relationship.ts

@@ -3,9 +3,11 @@
  * Search relationships by observation text or type
  */
 
+import { Filters } from 'weaviate-client';
 import type { Relationship } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 
 /**
  * Tool definition for remember_search_relationship
@@ -100,84 +102,74 @@ export async function handleSearchRelationship(
   userId: string
 ): Promise<string> {
   try {
-    logger.info('Searching relationships', { 
-      userId, 
+    logger.info('Searching relationships', {
+      userId,
       query: args.query,
-      types: args.relationship_types 
+      types: args.relationship_types
     });
 
     const collection = getMemoryCollection(userId);
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
 
-    // Build where filter for doc_type and other filters
-    const whereFilters: any[] = [
-      {
-        path: 'doc_type',
-        operator: 'Equal',
-        valueText: 'relationship',
-      },
-    ];
+    // Build filters using Weaviate v3 API
+    const filterList: any[] = [];
+
+    // Always filter by doc_type = 'relationship'
+    filterList.push(
+      collection.filter.byProperty('doc_type').equal('relationship')
+    );
 
     // Add relationship type filter
     if (args.relationship_types && args.relationship_types.length > 0) {
       if (args.relationship_types.length === 1) {
-        whereFilters.push({
-          path: 'relationship_type',
-          operator: 'Equal',
-          valueText: args.relationship_types[0],
-        });
+        filterList.push(
+          collection.filter.byProperty('relationship_type').equal(args.relationship_types[0])
+        );
       } else {
-        whereFilters.push({
-          operator: 'Or',
-          operands: args.relationship_types.map(type => ({
-            path: 'relationship_type',
-            operator: 'Equal',
-            valueText: type,
-          })),
-        });
+        // Multiple types: use OR logic
+        const typeFilters = args.relationship_types.map(type =>
+          collection.filter.byProperty('relationship_type').equal(type)
+        );
+        filterList.push(Filters.or(...typeFilters));
       }
     }
 
     // Add strength filter
     if (args.strength_min !== undefined) {
-      whereFilters.push({
-        path: 'strength',
-        operator: 'GreaterThanEqual',
-        valueNumber: args.strength_min,
-      });
+      filterList.push(
+        collection.filter.byProperty('strength').greaterOrEqual(args.strength_min)
+      );
     }
 
     // Add confidence filter
     if (args.confidence_min !== undefined) {
-      whereFilters.push({
-        path: 'confidence',
-        operator: 'GreaterThanEqual',
-        valueNumber: args.confidence_min,
-      });
+      filterList.push(
+        collection.filter.byProperty('confidence').greaterOrEqual(args.confidence_min)
+      );
     }
 
     // Add tags filter
     if (args.tags && args.tags.length > 0) {
-      whereFilters.push({
-        path: 'tags',
-        operator: 'ContainsAny',
-        valueTextArray: args.tags,
-      });
+      filterList.push(
+        collection.filter.byProperty('tags').containsAny(args.tags)
+      );
     }
 
+    // Combine all filters with AND logic
+    const combinedFilters = filterList.length > 1
+      ? Filters.and(...filterList)
+      : filterList[0];
+
     // Build search options
     const searchOptions: any = {
       alpha: 1.0, // Pure semantic search for relationships
       limit: limit + offset, // Get extra for offset
     };
 
-    // Add filters if present
-    if (whereFilters.length > 0) {
-      searchOptions.filters = whereFilters.length > 1 ? {
-        operator: 'And' as const,
-        operands: whereFilters,
-      } : whereFilters[0];
+    // Add filters
+    if (combinedFilters) {
+      searchOptions.filters = combinedFilters;
     }
 
     // Perform hybrid search (semantic search on observation field)
@@ -222,7 +214,12 @@ export async function handleSearchRelationship(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to search relationships:', error);
-    throw new Error(`Failed to search relationships: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_search_relationship',
+      operation: 'search relationships',
+      userId,
+      query: args.query,
+      limit: args.limit,
+    });
   }
 }

package/src/tools/set-preference.ts

@@ -5,6 +5,7 @@
 
 import { PreferencesDatabaseService } from '../services/preferences-database.service.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 import {
   UserPreferences,
   getPreferenceDescription,
@@ -139,7 +140,11 @@ export async function handleSetPreference(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to set preferences:', error);
-    throw new Error(`Failed to set preferences: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_set_preference',
+      operation: 'set preference',
+      userId,
+      preferencesProvided: Object.keys(args.preferences || {}).length,
+    });
   }
 }

package/src/tools/update-memory.ts

@@ -249,22 +249,13 @@ export async function handleUpdateMemory(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    const errorStack = error instanceof Error ? error.stack : undefined;
-    
-    logger.error('Failed to update memory:', {
-      error: errorMessage,
-      stack: errorStack,
+    handleToolError(error, {
+      toolName: 'remember_update_memory',
+      operation: 'update memory',
       userId,
       memoryId: args.memory_id,
-      providedFields: Object.keys(args).filter(k => k !== 'memory_id'),
+      providedFields: Object.keys(args).filter(k => k !== 'memory_id').join(', '),
+      updateCount: Object.keys(args).filter(k => k !== 'memory_id').length,
     });
-    
-    // Include detailed error information for debugging
-    throw new Error(
-      `Failed to update memory: ${errorMessage}` +
-      (errorStack ? `\n\nStack trace:\n${errorStack}` : '') +
-      `\n\nContext: userId=${userId}, memoryId=${args.memory_id}`
-    );
   }
 }

package/src/tools/update-relationship.ts

@@ -6,6 +6,7 @@
 import type { RelationshipUpdate } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { handleToolError } from '../utils/error-handler.js';
 
 /**
  * Tool definition for remember_update_relationship
@@ -183,7 +184,12 @@ export async function handleUpdateRelationship(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
-    logger.error('Failed to update relationship:', error);
-    throw new Error(`Failed to update relationship: ${error instanceof Error ? error.message : String(error)}`);
+    handleToolError(error, {
+      toolName: 'remember_update_relationship',
+      operation: 'update relationship',
+      userId,
+      relationshipId: args.relationship_id,
+      updatedFields: Object.keys(args).filter(k => k !== 'relationship_id'),
+    });
   }
 }