cleanupMemories

Instructions

Implementation Reference

• src/consciousness-protocol-tools.ts:1225-1312 (handler)

  Primary handler implementation in ConsciousnessProtocolProcessor class. Queries episodic, semantic, and procedural memories, identifies truncated (short content ending with '...') and duplicate memories (by content prefix), collects them for removal but currently only analyzes without deleting (notes need for deleteMemory method).

  async cleanupMemories(args: z.infer<typeof cleanupMemoriesSchema>) {
    const { removeTruncated, deduplicateByContent } = args;
  
    try {
      const stats = {
        truncatedRemoved: 0,
        duplicatesRemoved: 0,
        errors: [] as string[],
      };
  
      // For now, we'll use a simpler approach - get all memories and identify issues
      const episodicMemories = await this.memoryManager.queryMemories({
        memoryTypes: [MemoryEntityType.EPISODIC_MEMORY],
        limit: 1000,
      });
  
      const semanticMemories = await this.memoryManager.queryMemories({
        memoryTypes: [MemoryEntityType.SEMANTIC_MEMORY],
        limit: 1000,
      });
  
      const proceduralMemories = await this.memoryManager.queryMemories({
        memoryTypes: [MemoryEntityType.PROCEDURAL_MEMORY],
        limit: 1000,
      });
  
      const allMemories = [...episodicMemories, ...semanticMemories, ...proceduralMemories];
      const toRemove: string[] = [];
  
      if (removeTruncated) {
        // Identify truncated memories
        for (const memory of allMemories) {
          const obs = memory.observations[0];
          const content = obs?.content || obs?.definition || '';
          if (
            content &&
            content.length <= 50 &&
            (content.endsWith('...') || content.endsWith('...'))
          ) {
            toRemove.push(memory.name);
            stats.truncatedRemoved++;
          }
        }
      }
  
      if (deduplicateByContent) {
        // Sort by content length descending to keep longest versions
        const sortedMemories = allMemories.sort((a, b) => {
          const aContent = (a.observations[0]?.content || a.observations[0]?.definition || '')
            .length;
          const bContent = (b.observations[0]?.content || b.observations[0]?.definition || '')
            .length;
          return bContent - aContent;
        });
  
        const seenContent = new Set<string>();
        for (const memory of sortedMemories) {
          const obs = memory.observations[0];
          const content = obs?.content || obs?.definition || '';
          const contentKey = content.substring(0, 50).toLowerCase().trim();
  
          if (contentKey && seenContent.has(contentKey)) {
            if (!toRemove.includes(memory.name)) {
              toRemove.push(memory.name);
              stats.duplicatesRemoved++;
            }
          } else if (contentKey) {
            seenContent.add(contentKey);
          }
        }
      }
  
      // Note: Actual deletion would require adding a deleteMemory method to ConsciousnessMemoryManager
      // For now, we just identify what would be removed
  
      return {
        success: true,
        message: `Memory cleanup analysis completed. Found ${toRemove.length} memories to remove.`,
        stats,
        identified: toRemove.slice(0, 10), // Show first 10 for review
      };
    } catch (error) {
      return {
        success: false,
        error: `Cleanup failed: ${error}`,
      };
    }
  }

• src/consciousness-protocol-tools.ts:1420-1431 (schema)

  Zod schema defining input parameters for cleanupMemories tool: removeTruncated and deduplicateByContent booleans.

  export const cleanupMemoriesSchema = z.object({
    removeTruncated: z
      .boolean()
      .optional()
      .default(true)
      .describe('Remove memories that appear truncated'),
    deduplicateByContent: z
      .boolean()
      .optional()
      .default(true)
      .describe('Remove duplicate memories keeping longest'),
  });

• src/consciousness-rag-server-clean.ts:91-92 (registration)

  Registration in the main server's CallToolRequestSchema handler switch statement, parses args with schema and calls the cleanupMemories method.

  case 'cleanupMemories':
    return await this.cleanupMemories(cleanupMemoriesSchema.parse(args));

• src/consciousness-rag-server-clean.ts:340-362 (handler)

  Delegate handler in ConsciousnessRAGServer class that ensures initialization, calls the protocolProcessor's cleanupMemories, and formats result as MCP content.

  private async cleanupMemories(args: any) {
    const init = await this.ensureInitialized();
    if (!init.success) {
      return {
        content: [
          {
            type: 'text',
            text: init.message!,
          },
        ],
      };
    }
  
    const result = await this.protocolProcessor!.cleanupMemories(args);
  
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(result, null, 2),
        },
      ],
    };

• src/consciousness-protocol-tools.ts:1667-1683 (registration)

  MCP tool registration in consciousnessProtocolTools object used for listTools response, includes description and inputSchema.

  cleanupMemories: {
    description: 'Clean up duplicate or truncated memories in the database',
    inputSchema: {
      type: 'object',
      properties: {
        removeTruncated: {
          type: 'boolean',
          default: true,
          description: 'Remove memories that appear truncated',
        },
        deduplicateByContent: {
          type: 'boolean',
          default: true,
          description: 'Remove duplicate memories keeping longest',
        },
      },
    },