@prmichaelsen/remember-mcp 0.2.5 → 0.2.7

package/dist/server.js

@@ -1336,22 +1336,125 @@ async function handleCreateMemory(args, userId, context) {
   }
 }
 
+// src/utils/weaviate-filters.ts
+function buildCombinedSearchFilters(collection, filters) {
+  const memoryFilters = buildDocTypeFilters(collection, "memory", filters);
+  const relationshipFilters = buildDocTypeFilters(collection, "relationship", filters);
+  if (memoryFilters && relationshipFilters) {
+    return combineFiltersWithOr([memoryFilters, relationshipFilters]);
+  } else if (memoryFilters) {
+    return memoryFilters;
+  } else if (relationshipFilters) {
+    return relationshipFilters;
+  }
+  return void 0;
+}
+function buildDocTypeFilters(collection, docType, filters) {
+  const filterList = [];
+  filterList.push(
+    collection.filter.byProperty("doc_type").equal(docType)
+  );
+  if (docType === "memory" && filters?.types && filters.types.length > 0) {
+    if (filters.types.length === 1) {
+      filterList.push(
+        collection.filter.byProperty("type").equal(filters.types[0])
+      );
+    } else {
+      filterList.push(
+        collection.filter.byProperty("type").containsAny(filters.types)
+      );
+    }
+  }
+  if (filters?.weight_min !== void 0) {
+    filterList.push(
+      collection.filter.byProperty("weight").greaterThanOrEqual(filters.weight_min)
+    );
+  }
+  if (filters?.weight_max !== void 0) {
+    filterList.push(
+      collection.filter.byProperty("weight").lessThanOrEqual(filters.weight_max)
+    );
+  }
+  if (filters?.trust_min !== void 0) {
+    filterList.push(
+      collection.filter.byProperty("trust").greaterThanOrEqual(filters.trust_min)
+    );
+  }
+  if (filters?.trust_max !== void 0) {
+    filterList.push(
+      collection.filter.byProperty("trust").lessThanOrEqual(filters.trust_max)
+    );
+  }
+  if (filters?.date_from) {
+    filterList.push(
+      collection.filter.byProperty("created_at").greaterThanOrEqual(new Date(filters.date_from))
+    );
+  }
+  if (filters?.date_to) {
+    filterList.push(
+      collection.filter.byProperty("created_at").lessThanOrEqual(new Date(filters.date_to))
+    );
+  }
+  if (filters?.tags && filters.tags.length > 0) {
+    if (filters.tags.length === 1) {
+      filterList.push(
+        collection.filter.byProperty("tags").containsAny([filters.tags[0]])
+      );
+    } else {
+      filterList.push(
+        collection.filter.byProperty("tags").containsAny(filters.tags)
+      );
+    }
+  }
+  return combineFiltersWithAnd(filterList);
+}
+function buildMemoryOnlyFilters(collection, filters) {
+  return buildDocTypeFilters(collection, "memory", filters);
+}
+function combineFiltersWithAnd(filters) {
+  if (filters.length === 0) {
+    return void 0;
+  }
+  if (filters.length === 1) {
+    return filters[0];
+  }
+  return {
+    operator: "And",
+    operands: filters
+  };
+}
+function combineFiltersWithOr(filters) {
+  if (filters.length === 0) {
+    return void 0;
+  }
+  if (filters.length === 1) {
+    return filters[0];
+  }
+  return {
+    operator: "Or",
+    operands: filters
+  };
+}
+
 // src/tools/search-memory.ts
 var 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" \u2192 returns memories + relationships about camping
+  - "Search for recipes I saved" \u2192 returns recipe memories + related relationships
+  - "Show me notes from last week" \u2192 returns notes + any relationships created that week
   `,
   inputSchema: {
     type: "object",
@@ -1414,8 +1517,8 @@ var 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"]
@@ -1423,83 +1526,53 @@ var searchMemoryTool = {
 };
 async function handleSearchMemory(args, userId) {
   try {
-    logger.info("Searching memories", { userId, query: args.query });
+    const includeRelationships = args.include_relationships !== false;
+    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;
-    const whereFilters = [
-      {
-        path: "doc_type",
-        operator: "Equal",
-        valueText: "memory"
-      }
-    ];
-    if (args.filters?.types && args.filters.types.length > 0) {
-      whereFilters.push({
-        path: "type",
-        operator: "ContainsAny",
-        valueTextArray: args.filters.types
-      });
-    }
-    if (args.filters?.weight_min !== void 0) {
-      whereFilters.push({
-        path: "weight",
-        operator: "GreaterThanEqual",
-        valueNumber: args.filters.weight_min
-      });
-    }
-    if (args.filters?.trust_min !== void 0) {
-      whereFilters.push({
-        path: "trust",
-        operator: "GreaterThanEqual",
-        valueNumber: args.filters.trust_min
-      });
-    }
-    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)
-      });
-    }
+    const filters = includeRelationships ? buildCombinedSearchFilters(collection, args.filters) : buildMemoryOnlyFilters(collection, args.filters);
     const searchOptions = {
       alpha,
       limit: limit + offset
       // Get extra for offset
     };
-    if (whereFilters.length > 0) {
-      searchOptions.filters = whereFilters.length > 1 ? {
-        operator: "And",
-        operands: whereFilters
-      } : whereFilters[0];
+    if (filters) {
+      searchOptions.filters = filters;
     }
     const results = await collection.query.hybrid(args.query, searchOptions);
     const paginatedResults = results.objects.slice(offset);
-    const memories = paginatedResults.map((obj) => ({
-      id: obj.uuid,
-      ...obj.properties
-    }));
+    const memories = [];
+    const relationships = [];
+    for (const obj of paginatedResults) {
+      const doc = {
+        id: obj.uuid,
+        ...obj.properties
+      };
+      if (doc.doc_type === "memory") {
+        memories.push(doc);
+      } else if (doc.doc_type === "relationship") {
+        relationships.push(doc);
+      }
+    }
     const searchResult = {
       memories,
-      total: memories.length,
+      relationships: includeRelationships ? relationships : void 0,
+      total: memories.length + relationships.length,
       offset,
       limit
     };
-    if (args.include_relationships) {
-      searchResult.relationships = [];
-    }
     logger.info("Search completed", {
       userId,
       query: args.query,
-      results: memories.length
+      memoriesFound: memories.length,
+      relationshipsFound: relationships.length,
+      total: searchResult.total
     });
     return JSON.stringify(searchResult, null, 2);
   } catch (error) {
@@ -1959,59 +2032,15 @@ async function handleQueryMemory(args, userId) {
     const minRelevance = args.min_relevance ?? 0.6;
     const includeContext = args.include_context ?? true;
     const format = args.format ?? "detailed";
-    const whereFilters = [
-      {
-        path: "doc_type",
-        operator: "Equal",
-        valueText: "memory"
-      }
-    ];
-    if (args.filters?.types && args.filters.types.length > 0) {
-      whereFilters.push({
-        path: "type",
-        operator: "ContainsAny",
-        valueTextArray: args.filters.types
-      });
-    }
-    if (args.filters?.weight_min !== void 0) {
-      whereFilters.push({
-        path: "weight",
-        operator: "GreaterThanEqual",
-        valueNumber: args.filters.weight_min
-      });
-    }
-    if (args.filters?.trust_min !== void 0) {
-      whereFilters.push({
-        path: "trust",
-        operator: "GreaterThanEqual",
-        valueNumber: args.filters.trust_min
-      });
-    }
-    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)
-      });
-    }
+    const filters = buildCombinedSearchFilters(collection, args.filters);
     const searchOptions = {
       limit,
       distance: 1 - minRelevance,
       // Convert relevance to distance
       returnMetadata: ["distance"]
     };
-    if (whereFilters.length > 0) {
-      searchOptions.filters = whereFilters.length > 1 ? {
-        operator: "And",
-        operands: whereFilters
-      } : whereFilters[0];
+    if (filters) {
+      searchOptions.filters = filters;
     }
     const results = await collection.query.nearText(args.query, searchOptions);
     const relevantMemories = results.objects.map((obj) => {
@@ -2627,6 +2656,434 @@ async function handleDeleteRelationship(args, userId) {
   }
 }
 
+// src/firestore/paths.ts
+var APP_NAME = "remember-mcp";
+function getBasePrefix() {
+  const environment = process.env.ENVIRONMENT;
+  if (environment && environment !== "production" && environment !== "prod") {
+    return `${environment}.${APP_NAME}`;
+  }
+  const isDevelopment = process.env.NODE_ENV === "development";
+  if (isDevelopment) {
+    const customPrefix = process.env.DB_PREFIX;
+    if (customPrefix) {
+      return customPrefix;
+    }
+    return `e0.${APP_NAME}`;
+  }
+  return APP_NAME;
+}
+var BASE = getBasePrefix();
+function getUserPreferencesPath(userId) {
+  return `${BASE}.users/${userId}/preferences`;
+}
+
+// src/types/preferences.ts
+var DEFAULT_PREFERENCES = {
+  templates: {
+    auto_suggest: true,
+    suggestion_threshold: 0.6,
+    max_suggestions: 3,
+    show_preview: true,
+    remember_choice: true,
+    suppressed_categories: [],
+    suppressed_templates: [],
+    always_suggest: []
+  },
+  search: {
+    default_limit: 10,
+    include_low_trust: false,
+    weight_by_access: true,
+    weight_by_recency: true,
+    default_alpha: 0.7
+  },
+  location: {
+    auto_capture: true,
+    precision: "approximate",
+    share_with_memories: true
+  },
+  privacy: {
+    default_trust_level: 0.5,
+    allow_cross_user_access: false,
+    auto_approve_requests: false,
+    audit_logging: true
+  },
+  notifications: {
+    trust_violations: true,
+    access_requests: true,
+    memory_reminders: false,
+    relationship_suggestions: true
+  },
+  display: {
+    date_format: "MM/DD/YYYY",
+    time_format: "12h",
+    timezone: "America/Los_Angeles",
+    language: "en"
+  }
+};
+var PREFERENCE_CATEGORIES = [
+  "templates",
+  "search",
+  "location",
+  "privacy",
+  "notifications",
+  "display"
+];
+var PREFERENCE_DESCRIPTIONS = {
+  templates: {
+    auto_suggest: "Automatically suggest templates when creating memories (default: true)",
+    suggestion_threshold: "Minimum confidence to show template suggestion, 0-1 (default: 0.6)",
+    max_suggestions: "Maximum number of templates to suggest, 1-5 (default: 3)",
+    show_preview: "Show template preview in suggestion (default: true)",
+    remember_choice: `Remember "don't suggest for this type" choices (default: true)`,
+    suppressed_categories: "Categories to never suggest templates for (default: [])",
+    suppressed_templates: "Specific templates to never suggest (default: [])",
+    always_suggest: "Templates to always suggest regardless of confidence (default: [])"
+  },
+  search: {
+    default_limit: "Default number of search results to return, 1-100 (default: 10)",
+    include_low_trust: "Include low-trust memories in search results (default: false)",
+    weight_by_access: "Use access count in search ranking (default: true)",
+    weight_by_recency: "Use recency in search ranking (default: true)",
+    default_alpha: "Default hybrid search alpha (0=keyword, 1=semantic, default: 0.7)"
+  },
+  location: {
+    auto_capture: "Automatically capture location for memories (default: true)",
+    precision: "Location precision level: exact, approximate, city, none (default: approximate)",
+    share_with_memories: "Include location data in memories (default: true)"
+  },
+  privacy: {
+    default_trust_level: "Default trust level for new memories, 0-1 (default: 0.5)",
+    allow_cross_user_access: "Allow other users to request access to memories (default: false)",
+    auto_approve_requests: "Automatically approve access requests (default: false)",
+    audit_logging: "Enable audit logging for preference changes (default: true)"
+  },
+  notifications: {
+    trust_violations: "Notify on trust violations (default: true)",
+    access_requests: "Notify on access requests from other users (default: true)",
+    memory_reminders: "Send reminders about important memories (default: false)",
+    relationship_suggestions: "Suggest new relationships between memories (default: true)"
+  },
+  display: {
+    date_format: "Date format string (default: MM/DD/YYYY)",
+    time_format: "Time format: 12h or 24h (default: 12h)",
+    timezone: "Timezone identifier (default: America/Los_Angeles)",
+    language: "Language code (default: en)"
+  }
+};
+function getPreferenceDescription() {
+  const categories = Object.entries(PREFERENCE_DESCRIPTIONS).map(([category, fields]) => {
+    const fieldList = Object.entries(fields).map(([field, desc]) => `  - ${field}: ${desc}`).join("\n");
+    return `${category}:
+${fieldList}`;
+  }).join("\n\n");
+  return `User preferences control system behavior. Available preference categories and fields:
+
+${categories}`;
+}
+function getPreferencesSchema() {
+  return {
+    type: "object",
+    properties: {
+      templates: {
+        type: "object",
+        description: "Template suggestion preferences",
+        properties: {
+          auto_suggest: { type: "boolean" },
+          suggestion_threshold: { type: "number", minimum: 0, maximum: 1 },
+          max_suggestions: { type: "number", minimum: 1, maximum: 5 },
+          show_preview: { type: "boolean" },
+          remember_choice: { type: "boolean" },
+          suppressed_categories: { type: "array", items: { type: "string" } },
+          suppressed_templates: { type: "array", items: { type: "string" } },
+          always_suggest: { type: "array", items: { type: "string" } }
+        }
+      },
+      search: {
+        type: "object",
+        description: "Search behavior preferences",
+        properties: {
+          default_limit: { type: "number", minimum: 1, maximum: 100 },
+          include_low_trust: { type: "boolean" },
+          weight_by_access: { type: "boolean" },
+          weight_by_recency: { type: "boolean" },
+          default_alpha: { type: "number", minimum: 0, maximum: 1 }
+        }
+      },
+      location: {
+        type: "object",
+        description: "Location capture preferences",
+        properties: {
+          auto_capture: { type: "boolean" },
+          precision: { type: "string", enum: ["exact", "approximate", "city", "none"] },
+          share_with_memories: { type: "boolean" }
+        }
+      },
+      privacy: {
+        type: "object",
+        description: "Privacy and trust preferences",
+        properties: {
+          default_trust_level: { type: "number", minimum: 0, maximum: 1 },
+          allow_cross_user_access: { type: "boolean" },
+          auto_approve_requests: { type: "boolean" },
+          audit_logging: { type: "boolean" }
+        }
+      },
+      notifications: {
+        type: "object",
+        description: "Notification preferences",
+        properties: {
+          trust_violations: { type: "boolean" },
+          access_requests: { type: "boolean" },
+          memory_reminders: { type: "boolean" },
+          relationship_suggestions: { type: "boolean" }
+        }
+      },
+      display: {
+        type: "object",
+        description: "Display format preferences",
+        properties: {
+          date_format: { type: "string" },
+          time_format: { type: "string", enum: ["12h", "24h"] },
+          timezone: { type: "string" },
+          language: { type: "string" }
+        }
+      }
+    }
+  };
+}
+
+// src/services/preferences-database.service.ts
+var PreferencesDatabaseService = class {
+  /**
+   * Get user preferences
+   * Returns defaults if preferences don't exist
+   */
+  static async getPreferences(userId) {
+    try {
+      const pathParts = getUserPreferencesPath(userId).split("/");
+      const docId = pathParts.pop();
+      const collectionPath = pathParts.join("/");
+      const doc = await getDocument(collectionPath, docId);
+      if (!doc) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        return {
+          user_id: userId,
+          ...DEFAULT_PREFERENCES,
+          created_at: now,
+          updated_at: now
+        };
+      }
+      return doc;
+    } 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, updates) {
+    try {
+      const pathParts = getUserPreferencesPath(userId).split("/");
+      const docId = pathParts.pop();
+      const collectionPath = pathParts.join("/");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const doc = await getDocument(collectionPath, docId);
+      if (!doc) {
+        const newPrefs = {
+          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;
+      }
+      const updateData = {
+        ...updates,
+        updated_at: now
+      };
+      await setDocument(collectionPath, docId, updateData, { merge: true });
+      logger.info("Preferences updated", { userId });
+      const updatedDoc = await getDocument(collectionPath, docId);
+      return updatedDoc;
+    } 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) {
+    try {
+      const pathParts = getUserPreferencesPath(userId).split("/");
+      const docId = pathParts.pop();
+      const collectionPath = pathParts.join("/");
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const preferences = {
+        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)}`);
+    }
+  }
+};
+
+// src/tools/set-preference.ts
+var 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"]
+  }
+};
+function formatPreferenceChangeMessage(updates) {
+  const changes = [];
+  if (updates.templates) {
+    if (updates.templates.auto_suggest !== void 0) {
+      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 !== void 0) {
+      changes.push(`Search limit set to ${updates.search.default_limit}`);
+    }
+    if (updates.search.default_alpha !== void 0) {
+      changes.push(`Search alpha set to ${updates.search.default_alpha}`);
+    }
+  }
+  if (updates.privacy) {
+    if (updates.privacy.default_trust_level !== void 0) {
+      changes.push(`Default trust level set to ${updates.privacy.default_trust_level}`);
+    }
+  }
+  if (updates.location) {
+    if (updates.location.auto_capture !== void 0) {
+      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(", ")}`;
+}
+async function handleSetPreference(args, userId) {
+  try {
+    const { preferences } = args;
+    logger.info("Setting preferences", { userId, updates: Object.keys(preferences) });
+    const updatedPreferences = await PreferencesDatabaseService.updatePreferences(
+      userId,
+      preferences
+    );
+    const message = formatPreferenceChangeMessage(preferences);
+    const result = {
+      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)}`);
+  }
+}
+
+// src/tools/get-preferences.ts
+var 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"
+      }
+    }
+  }
+};
+async function handleGetPreferences(args, userId) {
+  try {
+    const { category } = args;
+    logger.info("Getting preferences", { userId, category });
+    const preferences = await PreferencesDatabaseService.getPreferences(userId);
+    const isDefault = !preferences.created_at || preferences.created_at === preferences.updated_at;
+    let result;
+    let message;
+    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 = {
+      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)}`);
+  }
+}
+
 // src/server.ts
 async function initServer() {
   logger.info("Initializing remember-mcp server...");
@@ -2670,7 +3127,10 @@ function registerHandlers(server) {
         createRelationshipTool,
         updateRelationshipTool,
         searchRelationshipTool,
-        deleteRelationshipTool
+        deleteRelationshipTool,
+        // Preference tools
+        setPreferenceTool,
+        getPreferencesTool
       ]
     };
   });
@@ -2710,6 +3170,12 @@ function registerHandlers(server) {
         case "remember_delete_relationship":
           result = await handleDeleteRelationship(args, userId);
           break;
+        case "remember_set_preference":
+          result = await handleSetPreference(args, userId);
+          break;
+        case "remember_get_preferences":
+          result = await handleGetPreferences(args, userId);
+          break;
         default:
           throw new McpError(
             ErrorCode.MethodNotFound,