@prmichaelsen/remember-mcp 3.0.0 → 3.13.0

package/src/tools/search-space.ts

@@ -1,25 +1,36 @@
 /**
- * remember_search_space tool
- * 
- * Search shared spaces to discover memories from other users.
- * Similar to remember_search_memory but searches space collections.
+ * remember_search_space tool (Memory Collection Pattern v2)
+ *
+ * Search shared spaces and/or groups to discover memories from other users.
+ * Queries Memory_spaces_public (for space searches) and Memory_groups_{groupId}
+ * (for group searches), then merges and deduplicates results.
  */
 
 import type { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { Filters } from 'weaviate-client';
 import { getWeaviateClient } from '../weaviate/client.js';
-import { ensurePublicCollection, isValidSpaceId } from '../weaviate/space-schema.js';
+import { isValidSpaceId } from '../weaviate/space-schema.js';
 import { SUPPORTED_SPACES } from '../types/space-memory.js';
 import { handleToolError } from '../utils/error-handler.js';
-import type { SearchFilters } from '../types/memory.js';
 import { createDebugLogger } from '../utils/debug.js';
+import { CollectionType, getCollectionName } from '../collections/dot-notation.js';
+import { logger } from '../utils/logger.js';
+import type { AuthContext } from '../types/auth.js';
+import { canModerate, canModerateAny } from '../utils/auth-helpers.js';
 
 /**
  * Tool definition for remember_search_space
  */
 export const searchSpaceTool: Tool = {
   name: 'remember_search_space',
-  description: `Search one or more shared spaces to discover thoughts, ideas, and memories. By default, excludes comments to keep discovery clean. Set include_comments: true to include threaded discussions. Can search multiple spaces in a single query.
+  description: `Search shared spaces and/or groups to discover memories from other users.
+
+Destinations:
+- Spaces: Public shared areas (e.g., "the_void", "dogs") — queries Memory_spaces_public filtered by space_ids
+- Groups: Private group collections — queries Memory_groups_{groupId} for each specified group
+- Neither specified: Searches all public memories across Memory_spaces_public
+
+Results from multiple sources are merged and deduplicated by composite ID, sorted by relevance.
 
 ⚠️ **CRITICAL - CONTENT TYPE FILTERING**: Do NOT add content_type filter unless the user explicitly requests filtering by type.
 - ✅ CORRECT: User says "search The Void for hiking" → { spaces: ["the_void"], query: "hiking" }
@@ -32,7 +43,7 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
     properties: {
       query: {
         type: 'string',
-        description: 'Search query (semantic + keyword hybrid)',
+        description: 'Search query',
       },
       spaces: {
         type: 'array',
@@ -40,9 +51,20 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
           type: 'string',
           enum: SUPPORTED_SPACES,
         },
-        description: 'Spaces to search (e.g., ["the_void", "dogs"]). Can search multiple spaces at once.',
+        description: 'Spaces to search (e.g., ["the_void", "dogs"]). Omit to search all public spaces.',
+        minItems: 1,
+      },
+      groups: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Group IDs to search (e.g., ["group-123"]). Searches Memory_groups_{groupId} for each.',
         minItems: 1,
-        default: ['the_void'],
+      },
+      search_type: {
+        type: 'string',
+        enum: ['hybrid', 'bm25', 'semantic'],
+        description: 'Search algorithm: "hybrid" (default), "bm25" (keyword only), or "semantic" (vector only)',
+        default: 'hybrid',
       },
       content_type: {
         type: 'string',
@@ -73,6 +95,12 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
         type: 'string',
         description: 'Filter memories created before this date (ISO 8601)',
       },
+      moderation_filter: {
+        type: 'string',
+        enum: ['approved', 'pending', 'rejected', 'removed', 'all'],
+        description: 'Filter by moderation status. Default: "approved" (only shows approved/unmoderated). Non-approved filters require moderator permissions.',
+        default: 'approved',
+      },
       include_comments: {
         type: 'boolean',
         description: 'Include comments in search results (default: false)',
@@ -89,30 +117,145 @@ Let the search algorithm find ALL relevant memories regardless of type unless ex
         description: 'Offset for pagination',
       },
     },
-    required: ['query', 'spaces'],
+    required: ['query'],
   },
 };
 
+export type ModerationFilter = 'approved' | 'pending' | 'rejected' | 'removed' | 'all';
+
 interface SearchSpaceArgs {
   query: string;
-  spaces: string[];
+  spaces?: string[];
+  groups?: string[];
+  search_type?: 'hybrid' | 'bm25' | 'semantic';
   content_type?: string;
   tags?: string[];
   min_weight?: number;
   max_weight?: number;
   date_from?: string;
   date_to?: string;
+  moderation_filter?: ModerationFilter;
   include_comments?: boolean;
   limit?: number;
   offset?: number;
 }
 
+/**
+ * Build the moderation status filter for a Weaviate collection query.
+ *
+ * - 'approved' (default): matches approved OR null (backward compat for pre-moderation memories)
+ * - 'pending'/'rejected'/'removed': matches that specific status
+ * - 'all': no moderation filter applied
+ */
+export function buildModerationFilter(collection: any, moderationFilter: ModerationFilter = 'approved'): any | null {
+  if (moderationFilter === 'all') {
+    return null;
+  }
+
+  if (moderationFilter === 'approved') {
+    // Approved OR null (backward compat: existing memories without moderation_status are approved)
+    return Filters.or(
+      collection.filter.byProperty('moderation_status').equal('approved'),
+      collection.filter.byProperty('moderation_status').isNull(true)
+    );
+  }
+
+  // Specific non-approved status
+  return collection.filter.byProperty('moderation_status').equal(moderationFilter);
+}
+
+/**
+ * Build base filters applied to all space/group collection queries.
+ * Excludes soft-deleted memories and optionally filters by content type, tags, weight, and date.
+ * Includes moderation status filter (default: approved/null only).
+ */
+export function buildBaseFilters(collection: any, args: SearchSpaceArgs): any[] {
+  const filterList: any[] = [];
+
+  // Exclude soft-deleted memories (requires indexNullState: true on collection)
+  filterList.push(collection.filter.byProperty('deleted_at').isNull(true));
+
+  // Only return memories (not relationships)
+  filterList.push(collection.filter.byProperty('doc_type').equal('memory'));
+
+  // Moderation status filter
+  const moderationFilter = buildModerationFilter(collection, args.moderation_filter);
+  if (moderationFilter) {
+    filterList.push(moderationFilter);
+  }
+
+  // Apply content type filter
+  if (args.content_type) {
+    filterList.push(collection.filter.byProperty('content_type').equal(args.content_type));
+  }
+
+  // Exclude comments and ghost memories by default (unless content_type is explicitly set)
+  if (!args.include_comments && !args.content_type) {
+    filterList.push(collection.filter.byProperty('content_type').notEqual('comment'));
+  }
+  if (!args.content_type) {
+    filterList.push(collection.filter.byProperty('content_type').notEqual('ghost'));
+  }
+
+  // Apply tags filter (AND semantics: memory must have ALL specified tags)
+  if (args.tags && args.tags.length > 0) {
+    args.tags.forEach(tag => {
+      filterList.push(collection.filter.byProperty('tags').containsAny([tag]));
+    });
+  }
+
+  // Apply weight filters
+  if (args.min_weight !== undefined) {
+    filterList.push(collection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
+  }
+  if (args.max_weight !== undefined) {
+    filterList.push(collection.filter.byProperty('weight').lessOrEqual(args.max_weight));
+  }
+
+  // Apply date filters (created_at stored as ISO 8601 text, sorts lexicographically)
+  if (args.date_from) {
+    filterList.push(collection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
+  }
+  if (args.date_to) {
+    filterList.push(collection.filter.byProperty('created_at').lessOrEqual(new Date(args.date_to)));
+  }
+
+  return filterList;
+}
+
+/**
+ * Execute a search against a Weaviate collection using the specified search type.
+ */
+async function executeSearch(
+  collection: any,
+  query: string,
+  searchType: 'hybrid' | 'bm25' | 'semantic',
+  whereFilter: any,
+  limit: number
+): Promise<any[]> {
+  const opts = {
+    limit,
+    ...(whereFilter && { where: whereFilter }),
+  };
+
+  switch (searchType) {
+    case 'bm25':
+      return (await collection.query.bm25(query, opts)).objects;
+    case 'semantic':
+      return (await collection.query.nearText([query], opts)).objects;
+    case 'hybrid':
+    default:
+      return (await collection.query.hybrid(query, opts)).objects;
+  }
+}
+
 /**
  * Handle remember_search_space tool execution
  */
 export async function handleSearchSpace(
   args: SearchSpaceArgs,
-  userId: string  // May be used for private spaces in future
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
   const debug = createDebugLogger({
     tool: 'remember_search_space',
@@ -123,130 +266,210 @@ export async function handleSearchSpace(
   try {
     debug.info('Tool invoked');
     debug.trace('Arguments', { args });
-    
-    // Validate all space IDs
-    debug.debug('Validating space IDs', { spaces: args.spaces });
-    const invalidSpaces = args.spaces.filter(s => !isValidSpaceId(s));
-    if (invalidSpaces.length > 0) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Invalid space IDs',
-          message: `Invalid spaces: ${invalidSpaces.join(', ')}. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
-          context: {
-            invalid_spaces: invalidSpaces,
-            provided_spaces: args.spaces,
-            supported_spaces: SUPPORTED_SPACES,
+
+    const spaces = args.spaces || [];
+    const groups = args.groups || [];
+    const searchType = args.search_type || 'hybrid';
+    const limit = args.limit || 10;
+    const offset = args.offset || 0;
+
+    // Validate space IDs
+    if (spaces.length > 0) {
+      const invalidSpaces = spaces.filter(s => !isValidSpaceId(s));
+      if (invalidSpaces.length > 0) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: 'Invalid space IDs',
+            message: `Invalid spaces: ${invalidSpaces.join(', ')}. Supported spaces: ${SUPPORTED_SPACES.join(', ')}`,
+            context: {
+              invalid_spaces: invalidSpaces,
+              provided_spaces: spaces,
+              supported_spaces: SUPPORTED_SPACES,
+            },
           },
-        },
-        null,
-        2
-      );
+          null,
+          2
+        );
+      }
     }
-    
-    // Validate not empty
-    if (args.spaces.length === 0) {
-      return JSON.stringify(
-        {
-          success: false,
-          error: 'Empty spaces array',
-          message: 'Must specify at least one space to search',
-        },
-        null,
-        2
-      );
+
+    // Validate group IDs
+    if (groups.length > 0) {
+      const invalidGroups = groups.filter(g => !g || g.includes('.') || g.trim() === '');
+      if (invalidGroups.length > 0) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: 'Invalid group IDs',
+            message: 'Group IDs cannot be empty or contain dots',
+            context: { invalid_groups: invalidGroups },
+          },
+          null,
+          2
+        );
+      }
+    }
+
+    // Permission check: non-approved moderation filters require can_moderate
+    const moderationFilter = args.moderation_filter || 'approved';
+    if (moderationFilter !== 'approved') {
+      // For group searches: check can_moderate per group
+      for (const groupId of groups) {
+        if (!canModerate(authContext, groupId)) {
+          return JSON.stringify(
+            {
+              success: false,
+              error: 'Permission denied',
+              message: `Moderator access required to view ${moderationFilter} memories in group ${groupId}`,
+            },
+            null,
+            2
+          );
+        }
+      }
+      // For space searches: check can_moderate on any group
+      if ((spaces.length > 0 || groups.length === 0) && !canModerateAny(authContext)) {
+        return JSON.stringify(
+          {
+            success: false,
+            error: 'Permission denied',
+            message: `Moderator access required to view ${moderationFilter} memories in spaces`,
+          },
+          null,
+          2
+        );
+      }
     }
 
     const weaviateClient = getWeaviateClient();
-    const publicCollection = await ensurePublicCollection(weaviateClient);
+    // Fetch enough results before pagination so we can deduplicate across sources
+    const fetchLimit = (limit + offset) * Math.max(1, groups.length + (spaces.length > 0 || groups.length === 0 ? 1 : 0));
+    const allObjects: any[] = [];
 
-    // Build filters for space search
-    const filterList: any[] = [];
+    logger.info('Starting space/group search', {
+      tool: 'remember_search_space',
+      userId,
+      spaces,
+      groups,
+      searchType,
+      query: args.query,
+    });
 
-    // Filter by spaces array (memory must be in at least one requested space)
-    filterList.push(publicCollection.filter.byProperty('spaces').containsAny(args.spaces));
+    // --- Space collection search ---
+    // Runs when spaces are specified, OR when neither spaces nor groups are specified (all-public)
+    if (spaces.length > 0 || groups.length === 0) {
+      const spacesCollectionName = getCollectionName(CollectionType.SPACES);
+      const spacesCollection = weaviateClient.collections.get(spacesCollectionName);
 
-    // Filter by doc_type (memory) - space_memory concept was removed
-    filterList.push(publicCollection.filter.byProperty('doc_type').equal('memory'));
+      const filterList = buildBaseFilters(spacesCollection, args);
 
-    // Apply content type filter
-    if (args.content_type) {
-      filterList.push(publicCollection.filter.byProperty('type').equal(args.content_type));
-    }
+      // Filter by space_ids array when specific spaces are requested
+      if (spaces.length > 0) {
+        filterList.push(spacesCollection.filter.byProperty('space_ids').containsAny(spaces));
+      }
+      // When spaces.length === 0 and groups.length === 0: no space_ids filter → all-public search
 
-    // Exclude comments by default (unless explicitly included)
-    if (!args.include_comments && !args.content_type) {
-      // Only exclude comments if not filtering by content_type
-      // (if content_type is set, user has explicit control)
-      filterList.push(publicCollection.filter.byProperty('type').notEqual('comment'));
-    }
+      const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
 
-    // Apply tags filter
-    if (args.tags && args.tags.length > 0) {
-      args.tags.forEach(tag => {
-        filterList.push(publicCollection.filter.byProperty('tags').containsAny([tag]));
+      debug.debug('Searching Memory_spaces_public', {
+        filterCount: filterList.length,
+        spaces,
+        allPublic: spaces.length === 0,
+        searchType,
       });
-    }
 
-    // Apply weight filters
-    if (args.min_weight !== undefined) {
-      filterList.push(publicCollection.filter.byProperty('weight').greaterOrEqual(args.min_weight));
-    }
+      const spaceObjects = await debug.time('Space collection search', async () => {
+        return await executeSearch(spacesCollection, args.query, searchType, whereFilter, fetchLimit);
+      });
 
-    if (args.max_weight !== undefined) {
-      filterList.push(publicCollection.filter.byProperty('weight').lessOrEqual(args.max_weight));
-    }
+      allObjects.push(...spaceObjects);
 
-    // Apply date filters (convert ISO strings to Date objects)
-    if (args.date_from) {
-      filterList.push(publicCollection.filter.byProperty('created_at').greaterOrEqual(new Date(args.date_from)));
+      logger.info('Space collection search complete', {
+        tool: 'remember_search_space',
+        collectionName: spacesCollectionName,
+        resultCount: spaceObjects.length,
+      });
     }
 
-    if (args.date_to) {
-      filterList.push(publicCollection.filter.byProperty('created_at').lessOrEqual(new Date(args.date_to)));
-    }
+    // --- Group collection searches ---
+    for (const groupId of groups) {
+      const groupCollectionName = getCollectionName(CollectionType.GROUPS, groupId);
 
-    const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
+      // Skip if the group collection doesn't exist yet
+      const exists = await weaviateClient.collections.exists(groupCollectionName);
+      if (!exists) {
+        debug.warn('Group collection not found, skipping', { groupId, groupCollectionName });
+        continue;
+      }
 
-    debug.debug('Executing hybrid search', {
-      query: args.query,
-      filterCount: filterList.length,
-      limit: args.limit || 10,
-      offset: args.offset || 0,
-    });
+      const groupCollection = weaviateClient.collections.get(groupCollectionName);
+      const filterList = buildBaseFilters(groupCollection, args);
+      const whereFilter = filterList.length > 0 ? Filters.and(...filterList) : undefined;
+
+      debug.debug('Searching group collection', {
+        groupId,
+        groupCollectionName,
+        filterCount: filterList.length,
+        searchType,
+      });
 
-    // Execute hybrid search
-    const searchResults = await debug.time('Hybrid search query', async () => {
-      return await publicCollection.query.hybrid(args.query, {
-        limit: args.limit || 10,
-        offset: args.offset || 0,
-        ...(whereFilter && { where: whereFilter }),
+      const groupObjects = await debug.time(`Group collection search: ${groupId}`, async () => {
+        return await executeSearch(groupCollection, args.query, searchType, whereFilter, fetchLimit);
       });
+
+      allObjects.push(...groupObjects);
+
+      logger.info('Group collection search complete', {
+        tool: 'remember_search_space',
+        groupId,
+        collectionName: groupCollectionName,
+        resultCount: groupObjects.length,
+      });
+    }
+
+    // --- Deduplicate by UUID (composite ID) ---
+    const seen = new Set<string>();
+    const deduplicated = allObjects.filter(obj => {
+      if (seen.has(obj.uuid)) return false;
+      seen.add(obj.uuid);
+      return true;
     });
-    
-    debug.debug('Search completed', {
-      resultCount: searchResults.objects.length,
+
+    // --- Sort by relevance score descending ---
+    deduplicated.sort((a, b) => {
+      const scoreA = a.metadata?.score ?? 0;
+      const scoreB = b.metadata?.score ?? 0;
+      return scoreB - scoreA;
     });
 
+    // --- Apply pagination ---
+    const paginated = deduplicated.slice(offset, offset + limit);
+
     // Format results
-    const memories = searchResults.objects.map((obj) => ({
+    const memories = paginated.map(obj => ({
       id: obj.uuid,
       ...obj.properties,
       _score: obj.metadata?.score,
     }));
 
+    const isAllPublic = spaces.length === 0 && groups.length === 0;
+
     const result = {
-      spaces_searched: args.spaces,
+      spaces_searched: isAllPublic ? 'all_public' : spaces,
+      groups_searched: groups,
       query: args.query,
+      search_type: searchType,
       memories,
       total: memories.length,
-      offset: args.offset || 0,
-      limit: args.limit || 10,
+      offset,
+      limit,
     };
 
     debug.info('Tool completed successfully', {
       resultCount: memories.length,
-      spaces: args.spaces,
+      spaces,
+      groups,
     });
 
     return JSON.stringify(result, null, 2);
@@ -259,6 +482,7 @@ export async function handleSearchSpace(
       toolName: 'remember_search_space',
       operation: 'search spaces',
       spaces: args.spaces,
+      groups: args.groups,
       query: args.query,
     });
   }

package/src/tools/set-preference.ts

@@ -6,11 +6,13 @@
 import { PreferencesDatabaseService } from '../services/preferences-database.service.js';
 import { logger } from '../utils/logger.js';
 import { handleToolError } from '../utils/error-handler.js';
+import { createDebugLogger } from '../utils/debug.js';
 import {
   UserPreferences,
   getPreferenceDescription,
   getPreferencesSchema,
 } from '../types/preferences.js';
+import type { AuthContext } from '../types/auth.js';
 
 /**
  * Tool definition for remember_set_preference
@@ -115,9 +117,15 @@ function formatPreferenceChangeMessage(updates: Partial<UserPreferences>): strin
  */
 export async function handleSetPreference(
   args: SetPreferenceArgs,
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_set_preference', userId, operation: 'set preference' });
+
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
+
     const { preferences } = args;
 
     logger.info('Setting preferences', { userId, updates: Object.keys(preferences) });
@@ -140,6 +148,7 @@ export async function handleSetPreference(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: 'remember_set_preference',
       operation: 'set preference',

package/src/tools/update-memory.ts

@@ -9,6 +9,8 @@ import { fetchMemoryWithAllProperties } from '../weaviate/client.js';
 import { logger } from '../utils/logger.js';
 import { handleToolError, withErrorHandling } from '../utils/error-handler.js';
 import { isValidContentType } from '../constants/content-types.js';
+import { createDebugLogger } from '../utils/debug.js';
+import type { AuthContext } from '../types/auth.js';
 
 /**
  * Tool definition for remember_update_memory
@@ -124,9 +126,13 @@ export interface UpdateMemoryResult {
  */
 export async function handleUpdateMemory(
   args: UpdateMemoryArgs,
-  userId: string
+  userId: string,
+  authContext?: AuthContext
 ): Promise<string> {
+  const debug = createDebugLogger({ tool: 'remember_update_memory', userId, operation: 'update memory' });
   try {
+    debug.info('Tool invoked');
+    debug.trace('Arguments', { args });
     logger.info('Updating memory', { userId, memoryId: args.memory_id });
 
     const collection = getMemoryCollection(userId);
@@ -191,8 +197,8 @@ export async function handleUpdateMemory(
       if (!isValidContentType(args.type)) {
         throw new Error(`Invalid content type: ${args.type}`);
       }
-      updates.type = args.type;
-      updatedFields.push('type');
+      updates.content_type = args.type;
+      updatedFields.push('content_type');
     }
 
     // Update scoring fields
@@ -210,8 +216,8 @@ export async function handleUpdateMemory(
       if (args.trust < 0 || args.trust > 1) {
         throw new Error('Trust must be between 0 and 1');
       }
-      updates.trust = args.trust;
-      updatedFields.push('trust');
+      updates.trust_score = args.trust;
+      updatedFields.push('trust_score');
     }
 
     // Update organization fields
@@ -231,6 +237,10 @@ export async function handleUpdateMemory(
       updatedFields.push('structured_content');
     }
 
+    // NOTE: space_ids and group_ids (publication tracking arrays) are intentionally
+    // NOT exposed in UpdateMemoryArgs — they are managed exclusively by
+    // remember_publish and remember_retract. The spread below preserves them.
+
     // Update comment/threading fields
     if (args.parent_id !== undefined) {
       updates.parent_id = args.parent_id;
@@ -314,6 +324,7 @@ export async function handleUpdateMemory(
 
     return JSON.stringify(result, null, 2);
   } catch (error) {
+    debug.error('Tool failed', { error: error instanceof Error ? error.message : String(error) });
     handleToolError(error, {
       toolName: 'remember_update_memory',
       operation: 'update memory',