@prmichaelsen/remember-mcp 0.1.0

package/src/tools/create-memory.ts

@@ -0,0 +1,198 @@
+/**
+ * remember_create_memory tool
+ * Creates a new memory in the user's collection
+ */
+
+import type { Memory, ContentType, Location, MemoryContext } from '../types/memory.js';
+import { ensureMemoryCollection, getMemoryCollection } from '../weaviate/schema.js';
+import { logger } from '../utils/logger.js';
+import { DEFAULT_CONTENT_TYPE, getContentTypeDescription, isValidContentType } from '../constants/content-types.js';
+
+/**
+ * Tool definition for remember_create_memory
+ */
+export const createMemoryTool = {
+  name: 'remember_create_memory',
+  description: `Create a new memory with optional template.
+  
+  Memories can store any type of information: notes, events, people, recipes, etc.
+  Each memory has a weight (significance 0-1) and trust level (access control 0-1).
+  Location and context are automatically captured from the request.
+  
+  Examples:
+  - "Remember that I met Sarah at the conference"
+  - "Save this recipe for chocolate chip cookies"
+  - "Note that my tent is stored in garage bin A4"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'Memory content (main text)',
+      },
+      title: {
+        type: 'string',
+        description: 'Optional short title',
+      },
+      type: {
+        type: 'string',
+        description: getContentTypeDescription(),
+        default: DEFAULT_CONTENT_TYPE,
+      },
+      weight: {
+        type: 'number',
+        description: 'Significance/priority (0-1, default: 0.5)',
+        minimum: 0,
+        maximum: 1,
+      },
+      trust: {
+        type: 'number',
+        description: 'Access control level (0-1, default: 0.5)',
+        minimum: 0,
+        maximum: 1,
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Tags for organization',
+      },
+      references: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Source URLs',
+      },
+      template_id: {
+        type: 'string',
+        description: 'Template ID to use (optional)',
+      },
+      skip_template_suggestion: {
+        type: 'boolean',
+        description: 'Skip automatic template suggestion',
+        default: false,
+      },
+    },
+    required: ['content'],
+  },
+};
+
+/**
+ * Create memory arguments
+ */
+export interface CreateMemoryArgs {
+  content: string;
+  title?: string;
+  type?: ContentType;
+  weight?: number;
+  trust?: number;
+  tags?: string[];
+  references?: string[];
+  template_id?: string;
+  skip_template_suggestion?: boolean;
+  structured_content?: Record<string, any>;
+}
+
+/**
+ * Create memory result
+ */
+export interface CreateMemoryResult {
+  memory_id: string;
+  created_at: string;
+  message: string;
+}
+
+/**
+ * Handle remember_create_memory tool
+ */
+export async function handleCreateMemory(
+  args: CreateMemoryArgs,
+  userId: string,
+  context?: Partial<MemoryContext>
+): Promise<string> {
+  try {
+    logger.info('Creating memory', { userId, type: args.type });
+
+    // Ensure collection exists
+    await ensureMemoryCollection(userId);
+    const collection = getMemoryCollection(userId);
+
+    // Build memory object
+    const now = new Date().toISOString();
+    const memory: Omit<Memory, 'id'> = {
+      // Core identity
+      user_id: userId,
+      doc_type: 'memory',
+
+      // Content
+      content: args.content,
+      title: args.title,
+      summary: args.title, // Use title as summary for now
+      type: (args.type && isValidContentType(args.type) ? args.type : DEFAULT_CONTENT_TYPE) as ContentType,
+
+      // Scoring
+      weight: args.weight ?? 0.5,
+      trust: args.trust ?? 0.5,
+      confidence: 1.0,
+
+      // Location (from context or default)
+      location: {
+        gps: null,
+        address: null,
+        source: 'unavailable',
+        confidence: 0,
+        is_approximate: true,
+      },
+
+      // Context
+      context: {
+        timestamp: now,
+        source: {
+          type: 'api',
+          platform: 'mcp',
+        },
+        summary: context?.summary || 'Memory created via MCP',
+        conversation_id: context?.conversation_id,
+        ...context,
+      },
+
+      // Relationships
+      relationships: [],
+
+      // Access tracking
+      access_count: 0,
+      last_accessed_at: now,
+      access_frequency: 0,
+
+      // Metadata
+      created_at: now,
+      updated_at: now,
+      version: 1,
+      tags: args.tags || [],
+      references: args.references || [],
+
+      // Template
+      template_id: args.template_id,
+      structured_content: args.structured_content,
+
+      // Computed weight
+      base_weight: args.weight ?? 0.5,
+      computed_weight: args.weight ?? 0.5,
+    };
+
+    // Insert into Weaviate
+    const result = await collection.data.insert(memory as any);
+
+    logger.info('Memory created successfully', { memoryId: result, userId });
+
+    const response: CreateMemoryResult = {
+      memory_id: result,
+      created_at: now,
+      message: `Memory created successfully with ID: ${result}`,
+    };
+
+    return JSON.stringify(response, null, 2);
+  } catch (error) {
+    logger.error('Failed to create memory:', error);
+    throw new Error(`Failed to create memory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/delete-memory.ts

@@ -0,0 +1,126 @@
+/**
+ * remember_delete_memory tool
+ * Delete a memory from the user's collection
+ */
+
+import { getMemoryCollection } from '../weaviate/schema.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Tool definition for remember_delete_memory
+ */
+export const deleteMemoryTool = {
+  name: 'remember_delete_memory',
+  description: `Delete a memory from your collection.
+  
+  Optionally delete connected relationships as well.
+  This action cannot be undone.
+  
+  Examples:
+  - "Delete that old camping note"
+  - "Remove the recipe I saved yesterday"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      memory_id: {
+        type: 'string',
+        description: 'ID of the memory to delete',
+      },
+      delete_relationships: {
+        type: 'boolean',
+        description: 'Also delete connected relationships. Default: false',
+        default: false,
+      },
+    },
+    required: ['memory_id'],
+  },
+};
+
+/**
+ * Delete memory arguments
+ */
+export interface DeleteMemoryArgs {
+  memory_id: string;
+  delete_relationships?: boolean;
+}
+
+/**
+ * Delete memory result
+ */
+export interface DeleteMemoryResult {
+  memory_id: string;
+  deleted: boolean;
+  relationships_deleted?: number;
+  message: string;
+}
+
+/**
+ * Handle remember_delete_memory tool
+ */
+export async function handleDeleteMemory(
+  args: DeleteMemoryArgs,
+  userId: string
+): Promise<string> {
+  try {
+    logger.info('Deleting memory', { userId, memoryId: args.memory_id });
+
+    const collection = getMemoryCollection(userId);
+
+    // Get memory to verify ownership and get relationships
+    const memory = await collection.query.fetchObjectById(args.memory_id, {
+      returnProperties: ['user_id', 'doc_type', 'relationships'],
+    });
+
+    if (!memory) {
+      throw new Error(`Memory not found: ${args.memory_id}`);
+    }
+
+    // Verify ownership
+    if (memory.properties.user_id !== userId) {
+      throw new Error('Unauthorized: Cannot delete another user\'s memory');
+    }
+
+    // Verify it's a memory (not a relationship)
+    if (memory.properties.doc_type !== 'memory') {
+      throw new Error('Cannot delete relationships using this tool. Use remember_delete_relationship instead.');
+    }
+
+    let relationshipsDeleted = 0;
+
+    // Delete connected relationships if requested
+    if (args.delete_relationships && memory.properties.relationships) {
+      const relationshipIds = memory.properties.relationships as string[];
+      
+      for (const relId of relationshipIds) {
+        try {
+          await collection.data.deleteById(relId);
+          relationshipsDeleted++;
+        } catch (error) {
+          logger.warn(`Failed to delete relationship ${relId}:`, error);
+        }
+      }
+    }
+
+    // Delete the memory
+    await collection.data.deleteById(args.memory_id);
+
+    logger.info('Memory deleted successfully', { 
+      userId, 
+      memoryId: args.memory_id,
+      relationshipsDeleted 
+    });
+
+    const result: DeleteMemoryResult = {
+      memory_id: args.memory_id,
+      deleted: true,
+      relationships_deleted: relationshipsDeleted,
+      message: `Memory deleted successfully${relationshipsDeleted > 0 ? ` (${relationshipsDeleted} relationships also deleted)` : ''}`,
+    };
+
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    logger.error('Failed to delete memory:', error);
+    throw new Error(`Failed to delete memory: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tools/search-memory.ts

@@ -0,0 +1,216 @@
+/**
+ * remember_search_memory tool
+ * Search memories using hybrid semantic + keyword search
+ */
+
+import type { Memory, SearchOptions, SearchResult, SearchFilters } from '../types/memory.js';
+import { getMemoryCollection } from '../weaviate/schema.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Tool definition for remember_search_memory
+ */
+export const searchMemoryTool = {
+  name: 'remember_search_memory',
+  description: `Search memories using hybrid semantic and keyword search.
+  
+  Supports:
+  - Semantic search (meaning-based)
+  - Keyword search (exact matches)
+  - Hybrid search (balanced with alpha parameter)
+  - Filtering by type, tags, weight, trust, date range
+  - Location-based search
+  
+  Examples:
+  - "Find memories about camping trips"
+  - "Search for recipes I saved"
+  - "Show me notes from last week"
+  `,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'Search query',
+      },
+      alpha: {
+        type: 'number',
+        description: 'Balance between semantic (1.0) and keyword (0.0) search. Default: 0.7',
+        minimum: 0,
+        maximum: 1,
+        default: 0.7,
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of results. Default: 10',
+        minimum: 1,
+        maximum: 100,
+        default: 10,
+      },
+      offset: {
+        type: 'number',
+        description: 'Pagination offset. Default: 0',
+        minimum: 0,
+        default: 0,
+      },
+      filters: {
+        type: 'object',
+        description: 'Optional filters',
+        properties: {
+          types: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Filter by content types',
+          },
+          tags: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Filter by tags',
+          },
+          weight_min: {
+            type: 'number',
+            description: 'Minimum weight (0-1)',
+          },
+          trust_min: {
+            type: 'number',
+            description: 'Minimum trust level (0-1)',
+          },
+          date_from: {
+            type: 'string',
+            description: 'Start date (ISO 8601)',
+          },
+          date_to: {
+            type: 'string',
+            description: 'End date (ISO 8601)',
+          },
+        },
+      },
+      include_relationships: {
+        type: 'boolean',
+        description: 'Include relationships in results. Default: false',
+        default: false,
+      },
+    },
+    required: ['query'],
+  },
+};
+
+/**
+ * Handle remember_search_memory tool
+ */
+export async function handleSearchMemory(
+  args: SearchOptions,
+  userId: string
+): Promise<string> {
+  try {
+    logger.info('Searching memories', { userId, query: args.query });
+
+    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 search options
+    const searchOptions: any = {
+      alpha: alpha,
+      limit: limit + offset, // Get extra for offset
+    };
+
+    // Add filters if present
+    if (whereFilters.length > 0) {
+      searchOptions.filters = whereFilters.length > 1 ? {
+        operator: 'And' as const,
+        operands: whereFilters,
+      } : whereFilters[0];
+    }
+
+    // Perform hybrid search with Weaviate v3 API
+    const results = await collection.query.hybrid(args.query, searchOptions);
+
+    // Apply offset
+    const paginatedResults = results.objects.slice(offset);
+
+    // Format memories
+    const memories: Partial<Memory>[] = paginatedResults.map((obj: any) => ({
+      id: obj.uuid,
+      ...obj.properties,
+    }));
+
+    // Build result
+    const searchResult: SearchResult = {
+      memories: memories as Memory[],
+      total: memories.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 
+    });
+
+    return JSON.stringify(searchResult, null, 2);
+  } catch (error) {
+    logger.error('Failed to search memories:', error);
+    throw new Error(`Failed to search memories: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}