@prmichaelsen/remember-mcp 0.2.5 → 0.2.7

package/src/services/preferences-database.service.ts

@@ -0,0 +1,120 @@
+/**
+ * Preferences Database Service
+ * Handles all Firestore operations for user preferences
+ */
+
+import { getDocument, setDocument } from '../firestore/init.js';
+import { getUserPreferencesPath } from '../firestore/paths.js';
+import { logger } from '../utils/logger.js';
+import {
+  UserPreferences,
+  DEFAULT_PREFERENCES,
+} from '../types/preferences.js';
+
+export class PreferencesDatabaseService {
+  /**
+   * Get user preferences
+   * Returns defaults if preferences don't exist
+   */
+  static async getPreferences(userId: string): Promise<UserPreferences> {
+    try {
+      const pathParts = getUserPreferencesPath(userId).split('/');
+      const docId = pathParts.pop()!;
+      const collectionPath = pathParts.join('/');
+
+      const doc = await getDocument(collectionPath, docId);
+
+      if (!doc) {
+        // Return defaults with user_id
+        const now = new Date().toISOString();
+        return {
+          user_id: userId,
+          ...DEFAULT_PREFERENCES,
+          created_at: now,
+          updated_at: now,
+        };
+      }
+
+      return doc as UserPreferences;
+    } catch (error) {
+      logger.error('Failed to get preferences:', error);
+      throw new Error(`Failed to get preferences: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Update user preferences (partial update with merge)
+   * Creates with defaults if preferences don't exist
+   */
+  static async updatePreferences(
+    userId: string,
+    updates: Partial<Omit<UserPreferences, 'user_id' | 'created_at'>>
+  ): Promise<UserPreferences> {
+    try {
+      const pathParts = getUserPreferencesPath(userId).split('/');
+      const docId = pathParts.pop()!;
+      const collectionPath = pathParts.join('/');
+
+      const now = new Date().toISOString();
+      const doc = await getDocument(collectionPath, docId);
+
+      if (!doc) {
+        // Create with defaults + updates
+        const newPrefs: UserPreferences = {
+          user_id: userId,
+          ...DEFAULT_PREFERENCES,
+          ...updates,
+          created_at: now,
+          updated_at: now,
+        };
+
+        await setDocument(collectionPath, docId, newPrefs);
+        logger.info('Preferences created with defaults', { userId });
+        return newPrefs;
+      }
+
+      // Update existing preferences with merge
+      const updateData = {
+        ...updates,
+        updated_at: now,
+      };
+
+      await setDocument(collectionPath, docId, updateData, { merge: true });
+      logger.info('Preferences updated', { userId });
+
+      // Return updated preferences
+      const updatedDoc = await getDocument(collectionPath, docId);
+      return updatedDoc as UserPreferences;
+    } catch (error) {
+      logger.error('Failed to update preferences:', error);
+      throw new Error(`Failed to update preferences: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  /**
+   * Create preferences with defaults
+   */
+  static async createPreferences(userId: string): Promise<UserPreferences> {
+    try {
+      const pathParts = getUserPreferencesPath(userId).split('/');
+      const docId = pathParts.pop()!;
+      const collectionPath = pathParts.join('/');
+
+      const now = new Date().toISOString();
+      const preferences: UserPreferences = {
+        user_id: userId,
+        ...DEFAULT_PREFERENCES,
+        created_at: now,
+        updated_at: now,
+      };
+
+      await setDocument(collectionPath, docId, preferences);
+      logger.info('Preferences created', { userId });
+
+      return preferences;
+    } catch (error) {
+      logger.error('Failed to create preferences:', error);
+      throw new Error(`Failed to create preferences: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}

package/src/tools/create-memory.ts

@@ -38,6 +38,7 @@ export const createMemoryTool = {
       type: {
         type: 'string',
         description: getContentTypeDescription(),
+        
         default: DEFAULT_CONTENT_TYPE,
       },
       weight: {

package/src/tools/get-preferences.ts

@@ -0,0 +1,111 @@
+/**
+ * remember_get_preferences tool
+ * Retrieve user preferences with defaults
+ */
+
+import { PreferencesDatabaseService } from '../services/preferences-database.service.js';
+import { logger } from '../utils/logger.js';
+import {
+  UserPreferences,
+  PreferenceCategory,
+  PREFERENCE_CATEGORIES,
+  getPreferenceDescription,
+} from '../types/preferences.js';
+
+/**
+ * Tool definition for remember_get_preferences
+ */
+export const getPreferencesTool = {
+  name: 'remember_get_preferences',
+  description: `Get current user preferences.
+
+Use this to understand user's current settings before suggesting changes
+or to explain why system is behaving a certain way.
+
+Returns the complete preferences object or filtered by category.
+If preferences don't exist, returns defaults.
+
+${getPreferenceDescription()}
+`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        enum: ['templates', 'search', 'location', 'privacy', 'notifications', 'display'],
+        description: 'Optional category to filter preferences',
+      },
+    },
+  },
+};
+
+/**
+ * Get preferences arguments
+ */
+export interface GetPreferencesArgs {
+  category?: PreferenceCategory;
+}
+
+/**
+ * Get preferences result
+ */
+export interface GetPreferencesResult {
+  preferences: UserPreferences | Partial<UserPreferences>;
+  is_default: boolean;
+  message: string;
+}
+
+/**
+ * Handle remember_get_preferences tool
+ */
+export async function handleGetPreferences(
+  args: GetPreferencesArgs,
+  userId: string
+): Promise<string> {
+  try {
+    const { category } = args;
+
+    logger.info('Getting preferences', { userId, category });
+
+    // Get preferences using service layer
+    const preferences = await PreferencesDatabaseService.getPreferences(userId);
+
+    // Check if these are defaults (no created_at means they were just generated)
+    const isDefault = !preferences.created_at || preferences.created_at === preferences.updated_at;
+
+    // Filter by category if requested
+    let result: UserPreferences | Partial<UserPreferences>;
+    let message: string;
+
+    if (category) {
+      if (!PREFERENCE_CATEGORIES.includes(category)) {
+        throw new Error(`Invalid category: ${category}. Valid categories: ${PREFERENCE_CATEGORIES.join(', ')}`);
+      }
+
+      result = {
+        [category]: preferences[category],
+      };
+      message = isDefault
+        ? `Showing default ${category} preferences (user has not customized preferences yet).`
+        : `Showing current ${category} preferences.`;
+    } else {
+      result = preferences;
+      message = isDefault
+        ? 'Showing default preferences (user has not customized preferences yet).'
+        : 'Showing current user preferences.';
+    }
+
+    const response: GetPreferencesResult = {
+      preferences: result,
+      is_default: isDefault,
+      message,
+    };
+
+    logger.info('Preferences retrieved successfully', { userId, category, isDefault });
+
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    logger.error('Failed to get preferences:', error);
+    throw new Error(`Failed to get preferences: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/query-memory.ts

@@ -6,6 +6,7 @@
 import type { Memory, SearchFilters } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { buildCombinedSearchFilters } from '../utils/weaviate-filters.js';
 
 /**
  * Tool definition for remember_query_memory
@@ -144,58 +145,8 @@ export async function handleQueryMemory(
     const includeContext = args.include_context ?? true;
     const format = args.format ?? 'detailed';
 
-    // Build where filter for memories only
-    const whereFilters: any[] = [
-      {
-        path: 'doc_type',
-        operator: 'Equal',
-        valueText: 'memory',
-      },
-    ];
-
-    // Add type filter
-    if (args.filters?.types && args.filters.types.length > 0) {
-      whereFilters.push({
-        path: 'type',
-        operator: 'ContainsAny',
-        valueTextArray: args.filters.types,
-      });
-    }
-
-    // Add weight filter
-    if (args.filters?.weight_min !== undefined) {
-      whereFilters.push({
-        path: 'weight',
-        operator: 'GreaterThanEqual',
-        valueNumber: args.filters.weight_min,
-      });
-    }
-
-    // Add trust filter
-    if (args.filters?.trust_min !== undefined) {
-      whereFilters.push({
-        path: 'trust',
-        operator: 'GreaterThanEqual',
-        valueNumber: args.filters.trust_min,
-      });
-    }
-
-    // Add date range filters
-    if (args.filters?.date_from) {
-      whereFilters.push({
-        path: 'created_at',
-        operator: 'GreaterThanEqual',
-        valueDate: new Date(args.filters.date_from),
-      });
-    }
-
-    if (args.filters?.date_to) {
-      whereFilters.push({
-        path: 'created_at',
-        operator: 'LessThanEqual',
-        valueDate: new Date(args.filters.date_to),
-      });
-    }
+    // Build filters using v3 API - search both memories and relationships
+    const filters = buildCombinedSearchFilters(collection, args.filters);
 
     // Build search options
     const searchOptions: any = {
@@ -205,11 +156,8 @@ export async function handleQueryMemory(
     };
 
     // Add filters if present
-    if (whereFilters.length > 0) {
-      searchOptions.filters = whereFilters.length > 1 ? {
-        operator: 'And' as const,
-        operands: whereFilters,
-      } : whereFilters[0];
+    if (filters) {
+      searchOptions.filters = filters;
     }
 
     // Perform semantic search using nearText

package/src/tools/search-memory.ts

@@ -1,30 +1,34 @@
 /**
  * remember_search_memory tool
- * Search memories using hybrid semantic + keyword search
+ * Search memories AND relationships using hybrid semantic + keyword search
  */
 
-import type { Memory, SearchOptions, SearchResult, SearchFilters } from '../types/memory.js';
+import type { Memory, Relationship, SearchOptions, SearchResult, SearchFilters } from '../types/memory.js';
 import { getMemoryCollection } from '../weaviate/schema.js';
 import { logger } from '../utils/logger.js';
+import { buildCombinedSearchFilters, buildMemoryOnlyFilters } from '../utils/weaviate-filters.js';
 
 /**
  * Tool definition for remember_search_memory
  */
 export const searchMemoryTool = {
   name: 'remember_search_memory',
-  description: `Search memories using hybrid semantic and keyword search.
+  description: `Search memories AND relationships using hybrid semantic and keyword search.
+  
+  By default, searches BOTH memories and relationships to provide comprehensive results.
+  Relationships contain valuable context in their observations.
   
   Supports:
-  - Semantic search (meaning-based)
+  - Semantic search (meaning-based) across memory content and relationship observations
   - Keyword search (exact matches)
   - Hybrid search (balanced with alpha parameter)
   - Filtering by type, tags, weight, trust, date range
-  - Location-based search
+  - Returns both memories and relationships in separate arrays
   
   Examples:
-  - "Find memories about camping trips"
-  - "Search for recipes I saved"
-  - "Show me notes from last week"
+  - "Find memories about camping trips" → returns memories + relationships about camping
+  - "Search for recipes I saved" → returns recipe memories + related relationships
+  - "Show me notes from last week" → returns notes + any relationships created that week
   `,
   inputSchema: {
     type: 'object',
@@ -87,8 +91,8 @@ export const searchMemoryTool = {
       },
       include_relationships: {
         type: 'boolean',
-        description: 'Include relationships in results. Default: false',
-        default: false,
+        description: 'Include relationships in results. Default: true (searches both memories and relationships)',
+        default: true,
       },
     },
     required: ['query'],
@@ -103,65 +107,24 @@ export async function handleSearchMemory(
   userId: string
 ): Promise<string> {
   try {
-    logger.info('Searching memories', { userId, query: args.query });
+    const includeRelationships = args.include_relationships !== false; // Default true
+    
+    logger.info('Searching memories and relationships', {
+      userId,
+      query: args.query,
+      includeRelationships
+    });
 
     const collection = getMemoryCollection(userId);
     const alpha = args.alpha ?? 0.7;
     const limit = args.limit ?? 10;
     const offset = args.offset ?? 0;
 
-    // Build where filter
-    const whereFilters: any[] = [
-      {
-        path: 'doc_type',
-        operator: 'Equal',
-        valueText: 'memory',
-      },
-    ];
-
-    // Add type filter
-    if (args.filters?.types && args.filters.types.length > 0) {
-      whereFilters.push({
-        path: 'type',
-        operator: 'ContainsAny',
-        valueTextArray: args.filters.types,
-      });
-    }
-
-    // Add weight filter
-    if (args.filters?.weight_min !== undefined) {
-      whereFilters.push({
-        path: 'weight',
-        operator: 'GreaterThanEqual',
-        valueNumber: args.filters.weight_min,
-      });
-    }
-
-    // Add trust filter
-    if (args.filters?.trust_min !== undefined) {
-      whereFilters.push({
-        path: 'trust',
-        operator: 'GreaterThanEqual',
-        valueNumber: args.filters.trust_min,
-      });
-    }
-
-    // Add date range filters
-    if (args.filters?.date_from) {
-      whereFilters.push({
-        path: 'created_at',
-        operator: 'GreaterThanEqual',
-        valueDate: new Date(args.filters.date_from),
-      });
-    }
-
-    if (args.filters?.date_to) {
-      whereFilters.push({
-        path: 'created_at',
-        operator: 'LessThanEqual',
-        valueDate: new Date(args.filters.date_to),
-      });
-    }
+    // Build filters using v3 API
+    // Use OR logic to search both memories and relationships
+    const filters = includeRelationships
+      ? buildCombinedSearchFilters(collection, args.filters)
+      : buildMemoryOnlyFilters(collection, args.filters);
 
     // Build search options
     const searchOptions: any = {
@@ -170,11 +133,8 @@ export async function handleSearchMemory(
     };
 
     // Add filters if present
-    if (whereFilters.length > 0) {
-      searchOptions.filters = whereFilters.length > 1 ? {
-        operator: 'And' as const,
-        operands: whereFilters,
-      } : whereFilters[0];
+    if (filters) {
+      searchOptions.filters = filters;
     }
 
     // Perform hybrid search with Weaviate v3 API
@@ -183,29 +143,38 @@ export async function handleSearchMemory(
     // Apply offset
     const paginatedResults = results.objects.slice(offset);
 
-    // Format memories
-    const memories: Partial<Memory>[] = paginatedResults.map((obj: any) => ({
-      id: obj.uuid,
-      ...obj.properties,
-    }));
+    // Separate memories and relationships
+    const memories: Partial<Memory>[] = [];
+    const relationships: Partial<Relationship>[] = [];
+
+    for (const obj of paginatedResults) {
+      const doc: any = {
+        id: obj.uuid,
+        ...obj.properties,
+      };
+
+      if (doc.doc_type === 'memory') {
+        memories.push(doc as Memory);
+      } else if (doc.doc_type === 'relationship') {
+        relationships.push(doc as Relationship);
+      }
+    }
 
     // Build result
     const searchResult: SearchResult = {
       memories: memories as Memory[],
-      total: memories.length,
+      relationships: includeRelationships ? (relationships as Relationship[]) : undefined,
+      total: memories.length + relationships.length,
       offset: offset,
       limit: limit,
     };
 
-    // TODO: Include relationships if requested
-    if (args.include_relationships) {
-      searchResult.relationships = [];
-    }
-
-    logger.info('Search completed', { 
-      userId, 
-      query: args.query, 
-      results: memories.length 
+    logger.info('Search completed', {
+      userId,
+      query: args.query,
+      memoriesFound: memories.length,
+      relationshipsFound: relationships.length,
+      total: searchResult.total
     });
 
     return JSON.stringify(searchResult, null, 2);

package/src/tools/set-preference.ts

@@ -0,0 +1,145 @@
+/**
+ * remember_set_preference tool
+ * Update user preferences through natural conversation
+ */
+
+import { PreferencesDatabaseService } from '../services/preferences-database.service.js';
+import { logger } from '../utils/logger.js';
+import {
+  UserPreferences,
+  getPreferenceDescription,
+  getPreferencesSchema,
+} from '../types/preferences.js';
+
+/**
+ * Tool definition for remember_set_preference
+ */
+export const setPreferenceTool = {
+  name: 'remember_set_preference',
+  description: `Update user preferences for system behavior through natural conversation.
+
+This tool allows bulk updates to user preferences. Provide a partial preferences object
+with only the fields you want to update. All updates are merged with existing preferences.
+
+${getPreferenceDescription()}
+
+Common examples:
+- Disable template suggestions: { templates: { auto_suggest: false } }
+- Change search defaults: { search: { default_limit: 20, default_alpha: 0.8 } }
+- Update privacy: { privacy: { default_trust_level: 0.8 } }
+- Suppress categories: { templates: { suppressed_categories: ["work", "personal"] } }
+`,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      preferences: {
+        ...getPreferencesSchema(),
+        description: 'Partial preferences object with fields to update',
+      },
+    },
+    required: ['preferences'],
+  },
+};
+
+/**
+ * Set preference arguments
+ */
+export interface SetPreferenceArgs {
+  preferences: Partial<Omit<UserPreferences, 'user_id' | 'created_at' | 'updated_at'>>;
+}
+
+/**
+ * Set preference result
+ */
+export interface SetPreferenceResult {
+  success: boolean;
+  updated_preferences: UserPreferences;
+  message: string;
+  error?: string;
+}
+
+/**
+ * Format a user-friendly message about the preference changes
+ */
+function formatPreferenceChangeMessage(updates: Partial<UserPreferences>): string {
+  const changes: string[] = [];
+
+  if (updates.templates) {
+    if (updates.templates.auto_suggest !== undefined) {
+      changes.push(
+        updates.templates.auto_suggest
+          ? 'Template suggestions enabled'
+          : 'Template suggestions disabled'
+      );
+    }
+    if (updates.templates.suppressed_categories) {
+      changes.push(`Suppressed categories: ${updates.templates.suppressed_categories.join(', ')}`);
+    }
+  }
+
+  if (updates.search) {
+    if (updates.search.default_limit !== undefined) {
+      changes.push(`Search limit set to ${updates.search.default_limit}`);
+    }
+    if (updates.search.default_alpha !== undefined) {
+      changes.push(`Search alpha set to ${updates.search.default_alpha}`);
+    }
+  }
+
+  if (updates.privacy) {
+    if (updates.privacy.default_trust_level !== undefined) {
+      changes.push(`Default trust level set to ${updates.privacy.default_trust_level}`);
+    }
+  }
+
+  if (updates.location) {
+    if (updates.location.auto_capture !== undefined) {
+      changes.push(
+        updates.location.auto_capture
+          ? 'Location auto-capture enabled'
+          : 'Location auto-capture disabled'
+      );
+    }
+  }
+
+  if (changes.length === 0) {
+    return 'Preferences updated successfully';
+  }
+
+  return `Preferences updated: ${changes.join(', ')}`;
+}
+
+/**
+ * Handle remember_set_preference tool
+ */
+export async function handleSetPreference(
+  args: SetPreferenceArgs,
+  userId: string
+): Promise<string> {
+  try {
+    const { preferences } = args;
+
+    logger.info('Setting preferences', { userId, updates: Object.keys(preferences) });
+
+    // Update preferences using service layer
+    const updatedPreferences = await PreferencesDatabaseService.updatePreferences(
+      userId,
+      preferences
+    );
+
+    const message = formatPreferenceChangeMessage(preferences);
+
+    const result: SetPreferenceResult = {
+      success: true,
+      updated_preferences: updatedPreferences,
+      message,
+    };
+
+    logger.info('Preferences set successfully', { userId });
+
+    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)}`);
+  }
+}