consolidate_working_memory

Combine multiple working memories into a single semantic memory to maintain long-term continuity for AI systems.

Instructions

Consolidate multiple working memories into a single semantic memory

Input Schema

TableJSON Schema

Name	Required	Description
`working_memory_ids`	Yes	Array of working memory UUIDs to consolidate
`consolidated_content`	Yes	Content for the consolidated memory
`consolidated_embedding`	Yes	Embedding for the consolidated memory

Implementation Reference

mcp.js:626-632 (handler)

MCP tool handler that receives tool requests and calls memoryManager.consolidateWorkingMemory() with the provided arguments (working_memory_ids, consolidated_content, consolidated_embedding)

case "consolidate_working_memory":
  const consolidatedMemory = await memoryManager.consolidateWorkingMemory(
    args.working_memory_ids,
    args.consolidated_content,
    args.consolidated_embedding
  );
  return { content: [{ type: "text", text: JSON.stringify(consolidatedMemory, null, 2) }] };

src/memory-manager.js:726-774 (handler)

Core implementation of consolidateWorkingMemory that creates a new semantic memory, establishes consolidation relationships to source working memories, marks them as consolidated, and records the event

async consolidateWorkingMemory(workingMemoryIds, consolidatedContent, consolidatedEmbedding) {
  try {
    const result = await this.db.transaction(async (tx) => {
      // Create consolidated memory
      const [consolidatedMemory] = await tx
        .insert(schema.memories)
        .values({
          type: 'semantic',
          content: consolidatedContent,
          embedding: consolidatedEmbedding,
          importance: 0.8,
          status: 'active'
        })
        .returning();

      const consolidatedId = consolidatedMemory.id;

      // Create relationships from working memories to consolidated memory
      for (const workingId of workingMemoryIds) {
        await tx.insert(schema.memoryRelationships).values({
          fromMemoryId: workingId,
          toMemoryId: consolidatedId,
          relationshipType: 'consolidation',
          strength: 1.0
        });

        // Mark working memory as consolidated
        await tx
          .update(schema.memories)
          .set({ status: 'consolidated' })
          .where(eq(schema.memories.id, workingId));
      }

      // Record consolidation event
      await tx.insert(schema.memoryChanges).values({
        memoryId: consolidatedId,
        changeType: 'consolidation',
        newValue: { source_memories: workingMemoryIds }
      });

      return consolidatedMemory;
    });

    return result;
  } catch (error) {
    console.warn('Memory consolidation failed:', error.message);
    throw error;
  }
}

src/tools/memory-tools.js:271-293 (schema)

Tool schema definition that defines the input parameters: working_memory_ids (array of UUIDs), consolidated_content (string), and consolidated_embedding (number array)

  name: "consolidate_working_memory",
  description: "Consolidate multiple working memories into a single semantic memory",
  inputSchema: {
    type: "object",
    properties: {
      working_memory_ids: {
        type: "array",
        items: { type: "string" },
        description: "Array of working memory UUIDs to consolidate"
      },
      consolidated_content: {
        type: "string",
        description: "Content for the consolidated memory"
      },
      consolidated_embedding: {
        type: "array",
        items: { type: "number" },
        description: "Embedding for the consolidated memory"
      }
    },
    required: ["working_memory_ids", "consolidated_content", "consolidated_embedding"]
  }
},

AGI MCP Server