@prmichaelsen/remember-mcp 0.2.5 → 0.2.7

package/dist/services/preferences-database.service.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Preferences Database Service
+ * Handles all Firestore operations for user preferences
+ */
+import { UserPreferences } from '../types/preferences.js';
+export declare class PreferencesDatabaseService {
+    /**
+     * Get user preferences
+     * Returns defaults if preferences don't exist
+     */
+    static getPreferences(userId: string): Promise<UserPreferences>;
+    /**
+     * Update user preferences (partial update with merge)
+     * Creates with defaults if preferences don't exist
+     */
+    static updatePreferences(userId: string, updates: Partial<Omit<UserPreferences, 'user_id' | 'created_at'>>): Promise<UserPreferences>;
+    /**
+     * Create preferences with defaults
+     */
+    static createPreferences(userId: string): Promise<UserPreferences>;
+}
+//# sourceMappingURL=preferences-database.service.d.ts.map

package/dist/tools/get-preferences.d.ts

@@ -0,0 +1,41 @@
+/**
+ * remember_get_preferences tool
+ * Retrieve user preferences with defaults
+ */
+import { UserPreferences, PreferenceCategory } from '../types/preferences.js';
+/**
+ * Tool definition for remember_get_preferences
+ */
+export declare const getPreferencesTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            category: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+    };
+};
+/**
+ * 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 declare function handleGetPreferences(args: GetPreferencesArgs, userId: string): Promise<string>;
+//# sourceMappingURL=get-preferences.d.ts.map

package/dist/tools/search-memory.d.ts

@@ -1,6 +1,6 @@
 /**
  * remember_search_memory tool
- * Search memories using hybrid semantic + keyword search
+ * Search memories AND relationships using hybrid semantic + keyword search
  */
 import type { SearchOptions } from '../types/memory.js';
 /**

package/dist/tools/set-preference.d.ts

@@ -0,0 +1,185 @@
+/**
+ * remember_set_preference tool
+ * Update user preferences through natural conversation
+ */
+import { UserPreferences } from '../types/preferences.js';
+/**
+ * Tool definition for remember_set_preference
+ */
+export declare const setPreferenceTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            preferences: {
+                description: string;
+                type: string;
+                properties: {
+                    templates: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            auto_suggest: {
+                                type: string;
+                            };
+                            suggestion_threshold: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            max_suggestions: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            show_preview: {
+                                type: string;
+                            };
+                            remember_choice: {
+                                type: string;
+                            };
+                            suppressed_categories: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
+                            suppressed_templates: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
+                            always_suggest: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                    search: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            default_limit: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            include_low_trust: {
+                                type: string;
+                            };
+                            weight_by_access: {
+                                type: string;
+                            };
+                            weight_by_recency: {
+                                type: string;
+                            };
+                            default_alpha: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                        };
+                    };
+                    location: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            auto_capture: {
+                                type: string;
+                            };
+                            precision: {
+                                type: string;
+                                enum: string[];
+                            };
+                            share_with_memories: {
+                                type: string;
+                            };
+                        };
+                    };
+                    privacy: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            default_trust_level: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            allow_cross_user_access: {
+                                type: string;
+                            };
+                            auto_approve_requests: {
+                                type: string;
+                            };
+                            audit_logging: {
+                                type: string;
+                            };
+                        };
+                    };
+                    notifications: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            trust_violations: {
+                                type: string;
+                            };
+                            access_requests: {
+                                type: string;
+                            };
+                            memory_reminders: {
+                                type: string;
+                            };
+                            relationship_suggestions: {
+                                type: string;
+                            };
+                        };
+                    };
+                    display: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            date_format: {
+                                type: string;
+                            };
+                            time_format: {
+                                type: string;
+                                enum: string[];
+                            };
+                            timezone: {
+                                type: string;
+                            };
+                            language: {
+                                type: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * 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;
+}
+/**
+ * Handle remember_set_preference tool
+ */
+export declare function handleSetPreference(args: SetPreferenceArgs, userId: string): Promise<string>;
+//# sourceMappingURL=set-preference.d.ts.map

package/dist/types/preferences.d.ts

@@ -0,0 +1,284 @@
+/**
+ * User preferences types
+ * Stored in Firestore at users/{userId}/preferences
+ */
+/**
+ * Template preferences
+ */
+export interface TemplatePreferences {
+    auto_suggest: boolean;
+    suggestion_threshold: number;
+    max_suggestions: number;
+    show_preview: boolean;
+    remember_choice: boolean;
+    suppressed_categories?: string[];
+    suppressed_templates?: string[];
+    always_suggest?: string[];
+}
+/**
+ * Search preferences
+ */
+export interface SearchPreferences {
+    default_limit: number;
+    include_low_trust: boolean;
+    weight_by_access: boolean;
+    weight_by_recency: boolean;
+    default_alpha: number;
+}
+/**
+ * Location preferences
+ */
+export interface LocationPreferences {
+    auto_capture: boolean;
+    precision: 'exact' | 'approximate' | 'city' | 'none';
+    share_with_memories: boolean;
+}
+/**
+ * Privacy preferences
+ */
+export interface PrivacyPreferences {
+    default_trust_level: number;
+    allow_cross_user_access: boolean;
+    auto_approve_requests: boolean;
+    audit_logging: boolean;
+}
+/**
+ * Notification preferences
+ */
+export interface NotificationPreferences {
+    trust_violations: boolean;
+    access_requests: boolean;
+    memory_reminders: boolean;
+    relationship_suggestions: boolean;
+}
+/**
+ * Display preferences
+ */
+export interface DisplayPreferences {
+    date_format: string;
+    time_format: string;
+    timezone: string;
+    language: string;
+}
+/**
+ * Complete user preferences
+ */
+export interface UserPreferences {
+    user_id: string;
+    templates: TemplatePreferences;
+    search: SearchPreferences;
+    location: LocationPreferences;
+    privacy: PrivacyPreferences;
+    notifications: NotificationPreferences;
+    display: DisplayPreferences;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Default preferences
+ */
+export declare const DEFAULT_PREFERENCES: Omit<UserPreferences, 'user_id' | 'created_at' | 'updated_at'>;
+/**
+ * Valid preference categories
+ */
+export declare const PREFERENCE_CATEGORIES: readonly ["templates", "search", "location", "privacy", "notifications", "display"];
+export type PreferenceCategory = typeof PREFERENCE_CATEGORIES[number];
+/**
+ * Preference field descriptions for dynamic tool schema generation
+ */
+export declare const PREFERENCE_DESCRIPTIONS: {
+    readonly templates: {
+        readonly auto_suggest: "Automatically suggest templates when creating memories (default: true)";
+        readonly suggestion_threshold: "Minimum confidence to show template suggestion, 0-1 (default: 0.6)";
+        readonly max_suggestions: "Maximum number of templates to suggest, 1-5 (default: 3)";
+        readonly show_preview: "Show template preview in suggestion (default: true)";
+        readonly remember_choice: "Remember \"don't suggest for this type\" choices (default: true)";
+        readonly suppressed_categories: "Categories to never suggest templates for (default: [])";
+        readonly suppressed_templates: "Specific templates to never suggest (default: [])";
+        readonly always_suggest: "Templates to always suggest regardless of confidence (default: [])";
+    };
+    readonly search: {
+        readonly default_limit: "Default number of search results to return, 1-100 (default: 10)";
+        readonly include_low_trust: "Include low-trust memories in search results (default: false)";
+        readonly weight_by_access: "Use access count in search ranking (default: true)";
+        readonly weight_by_recency: "Use recency in search ranking (default: true)";
+        readonly default_alpha: "Default hybrid search alpha (0=keyword, 1=semantic, default: 0.7)";
+    };
+    readonly location: {
+        readonly auto_capture: "Automatically capture location for memories (default: true)";
+        readonly precision: "Location precision level: exact, approximate, city, none (default: approximate)";
+        readonly share_with_memories: "Include location data in memories (default: true)";
+    };
+    readonly privacy: {
+        readonly default_trust_level: "Default trust level for new memories, 0-1 (default: 0.5)";
+        readonly allow_cross_user_access: "Allow other users to request access to memories (default: false)";
+        readonly auto_approve_requests: "Automatically approve access requests (default: false)";
+        readonly audit_logging: "Enable audit logging for preference changes (default: true)";
+    };
+    readonly notifications: {
+        readonly trust_violations: "Notify on trust violations (default: true)";
+        readonly access_requests: "Notify on access requests from other users (default: true)";
+        readonly memory_reminders: "Send reminders about important memories (default: false)";
+        readonly relationship_suggestions: "Suggest new relationships between memories (default: true)";
+    };
+    readonly display: {
+        readonly date_format: "Date format string (default: MM/DD/YYYY)";
+        readonly time_format: "Time format: 12h or 24h (default: 12h)";
+        readonly timezone: "Timezone identifier (default: America/Los_Angeles)";
+        readonly language: "Language code (default: en)";
+    };
+};
+/**
+ * Generate dynamic preference description for tool schema
+ */
+export declare function getPreferenceDescription(): string;
+/**
+ * Generate JSON schema for preferences
+ */
+export declare function getPreferencesSchema(): {
+    type: string;
+    properties: {
+        templates: {
+            type: string;
+            description: string;
+            properties: {
+                auto_suggest: {
+                    type: string;
+                };
+                suggestion_threshold: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                max_suggestions: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                show_preview: {
+                    type: string;
+                };
+                remember_choice: {
+                    type: string;
+                };
+                suppressed_categories: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                suppressed_templates: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                always_suggest: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+            };
+        };
+        search: {
+            type: string;
+            description: string;
+            properties: {
+                default_limit: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                include_low_trust: {
+                    type: string;
+                };
+                weight_by_access: {
+                    type: string;
+                };
+                weight_by_recency: {
+                    type: string;
+                };
+                default_alpha: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+            };
+        };
+        location: {
+            type: string;
+            description: string;
+            properties: {
+                auto_capture: {
+                    type: string;
+                };
+                precision: {
+                    type: string;
+                    enum: string[];
+                };
+                share_with_memories: {
+                    type: string;
+                };
+            };
+        };
+        privacy: {
+            type: string;
+            description: string;
+            properties: {
+                default_trust_level: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                };
+                allow_cross_user_access: {
+                    type: string;
+                };
+                auto_approve_requests: {
+                    type: string;
+                };
+                audit_logging: {
+                    type: string;
+                };
+            };
+        };
+        notifications: {
+            type: string;
+            description: string;
+            properties: {
+                trust_violations: {
+                    type: string;
+                };
+                access_requests: {
+                    type: string;
+                };
+                memory_reminders: {
+                    type: string;
+                };
+                relationship_suggestions: {
+                    type: string;
+                };
+            };
+        };
+        display: {
+            type: string;
+            description: string;
+            properties: {
+                date_format: {
+                    type: string;
+                };
+                time_format: {
+                    type: string;
+                    enum: string[];
+                };
+                timezone: {
+                    type: string;
+                };
+                language: {
+                    type: string;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=preferences.d.ts.map

package/dist/utils/weaviate-filters.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Weaviate v3 Filter Builder Utilities
+ *
+ * Provides helper functions to build Weaviate v3 filters using the fluent API.
+ * Replaces old v2 filter format (path/operator/valueText) with v3 collection.filter.byProperty()
+ */
+import type { SearchFilters } from '../types/memory.js';
+/**
+ * Build filters for searching both memories and relationships
+ * Uses OR logic: (doc_type=memory AND memory_filters) OR (doc_type=relationship AND relationship_filters)
+ *
+ * @param collection - Weaviate collection instance
+ * @param filters - Optional search filters
+ * @returns Combined filter or undefined if no filters
+ */
+export declare function buildCombinedSearchFilters(collection: any, filters?: SearchFilters): any;
+/**
+ * Build filters for memory-only search (backward compatibility)
+ *
+ * @param collection - Weaviate collection instance
+ * @param filters - Optional search filters
+ * @returns Combined filter or undefined if no filters
+ */
+export declare function buildMemoryOnlyFilters(collection: any, filters?: SearchFilters): any;
+/**
+ * Build filters specifically for relationship-only search
+ *
+ * @param collection - Weaviate collection instance
+ * @param filters - Optional search filters
+ * @returns Combined filter or undefined if no filters
+ */
+export declare function buildRelationshipOnlyFilters(collection: any, filters?: SearchFilters): any;
+/**
+ * Helper to check if a filter result is empty
+ */
+export declare function hasFilters(filter: any): boolean;
+//# sourceMappingURL=weaviate-filters.d.ts.map

package/dist/utils/weaviate-filters.spec.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for Weaviate v3 filter builders
+ */
+export {};
+//# sourceMappingURL=weaviate-filters.spec.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/remember-mcp",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Multi-tenant memory system MCP server with vector search and relationships",
   "main": "dist/server.js",
   "type": "module",

package/src/server-factory.ts

@@ -28,6 +28,10 @@ import { updateRelationshipTool, handleUpdateRelationship } from './tools/update
 import { searchRelationshipTool, handleSearchRelationship } from './tools/search-relationship.js';
 import { deleteRelationshipTool, handleDeleteRelationship } from './tools/delete-relationship.js';
 
+// Import preference tools
+import { setPreferenceTool, handleSetPreference } from './tools/set-preference.js';
+import { getPreferencesTool, handleGetPreferences } from './tools/get-preferences.js';
+
 export interface ServerOptions {
   name?: string;
   version?: string;
@@ -177,6 +181,9 @@ function registerHandlers(server: Server, userId: string, accessToken: string):
         updateRelationshipTool,
         searchRelationshipTool,
         deleteRelationshipTool,
+        // Preference tools
+        setPreferenceTool,
+        getPreferencesTool,
       ],
     };
   });
@@ -233,6 +240,14 @@ function registerHandlers(server: Server, userId: string, accessToken: string):
           result = await handleDeleteRelationship(args as any, userId);
           break;
 
+        case 'remember_set_preference':
+          result = await handleSetPreference(args as any, userId);
+          break;
+
+        case 'remember_get_preferences':
+          result = await handleGetPreferences(args as any, userId);
+          break;
+
         default:
           throw new McpError(
             ErrorCode.MethodNotFound,

package/src/server.ts

@@ -27,6 +27,10 @@ import { updateRelationshipTool, handleUpdateRelationship } from './tools/update
 import { searchRelationshipTool, handleSearchRelationship } from './tools/search-relationship.js';
 import { deleteRelationshipTool, handleDeleteRelationship } from './tools/delete-relationship.js';
 
+// Import preference tools
+import { setPreferenceTool, handleSetPreference } from './tools/set-preference.js';
+import { getPreferencesTool, handleGetPreferences } from './tools/get-preferences.js';
+
 /**
  * Initialize remember-mcp server
  */
@@ -91,6 +95,9 @@ function registerHandlers(server: Server): void {
         updateRelationshipTool,
         searchRelationshipTool,
         deleteRelationshipTool,
+        // Preference tools
+        setPreferenceTool,
+        getPreferencesTool,
       ],
     };
   });
@@ -147,6 +154,14 @@ function registerHandlers(server: Server): void {
           result = await handleDeleteRelationship(args as any, userId);
           break;
 
+        case 'remember_set_preference':
+          result = await handleSetPreference(args as any, userId);
+          break;
+
+        case 'remember_get_preferences':
+          result = await handleGetPreferences(args as any, userId);
+          break;
+
         default:
           throw new McpError(
             ErrorCode.MethodNotFound,