Memory Consolidation Patterns

import json
from datetime import datetime, timedelta
from brain_sdk import Brain
from anthropic import Anthropic

brain = Brain(api_key="...")
claude = Anthropic(api_key="...")

async def consolidate_by_topic(
    agent_id: str,
    topic: str,
    lookback_days: int = 7,
) -> dict:
    """
    Consolidate memories matching a topic.
    
    Example: topic="trading_losses"
    Retrieves all loss memories from the last week, summarizes them into one.
    """
    
    # 1. Retrieve all memories matching topic
    cutoff = (datetime.utcnow() - timedelta(days=lookback_days)).isoformat()
    
    memories = await brain.retrieve(
        agentId=agent_id,
        query=topic,
        filters={
            "timestamp": {"$gte": cutoff}
        },
        topK=100,  # Get many
        mode="semantic"
    )
    
    if len(memories) < 2:
        return {"consolidated": False, "reason": "Less than 2 memories"}
    
    # 2. Extract memory texts
    memory_texts = [m["content"] for m in memories]
    
    # 3. Summarize using Claude
    summary = claude.messages.create(
        model="claude-opus-4-1",
        max_tokens=500,
        messages=[
            {
                "role": "user",
                "content": f"""Consolidate these {len(memory_texts)} memories about {topic} into a single summary.
Focus on patterns, key facts, and trends. Preserve specifics.

Memories:
{json.dumps(memory_texts, indent=2)}

Return a single consolidated memory (2-3 sentences max)."""
            }
        ]
    ).content[0].text
    
    # 4. Store consolidated memory
    consolidated_id = await brain.store(
        agentId=agent_id,
        content=summary,
        metadata={
            "type": "consolidation_summary",
            "topic": topic,
            "consolidated_from": len(memories),
            "lookback_days": lookback_days,
            "timestamp": datetime.utcnow().isoformat(),
        }
    )
    
    # 5. Delete original memories
    for memory in memories:
        try:
            await brain.delete(agentId=agent_id, memoryId=memory["id"])
        except Exception as e:
            print(f"Failed to delete {memory['id']}: {e}")
    
    return {
        "consolidated": True,
        "consolidated_id": consolidated_id,
        "memories_merged": len(memories),
        "summary": summary
    }

# Usage
result = await consolidate_by_topic("trader_1", "trading_losses", lookback_days=7)
print(f"Consolidated {result['memories_merged']} losses into 1 summary")

Input (5 trading loss memories):
1. "Sold AAPL too early, lost 1.2% on recovery"
2. "Held MSFT too long, got stopped at -2.5%"
3. "TSLA bad entry, exited at -1.8%"
4. "Missed NVDA dip, entered at peak, -2.1%"
5. "Tech sector rotation caught me unprepared, -3.2% total"

Output (1 consolidated summary):
"Lost 10.8% across 5 trades in tech sector (AAPL, MSFT, TSLA, NVDA).
Errors: premature exit, overholding, bad entry, missed dips.
Pattern: Sector rotation without position rotation."

import { Brain } from "brain-sdk";

const brain = new Brain({ apiKey: process.env.BRAIN_API_KEY });

async function deduplicateMemories(agentId: string): Promise<number> {
  // 1. Get all memories
  const allMemories = await brain.list({
    agentId,
    limit: 10000,
  });

  // 2. Group by embedding similarity (near-duplicates)
  const clusters: Map<number, typeof allMemories> = new Map();
  const processed = new Set<string>();

  for (let i = 0; i < allMemories.length; i++) {
    if (processed.has(allMemories[i].id)) continue;

    const cluster: typeof allMemories = [allMemories[i]];
    processed.add(allMemories[i].id);

    // Find similar memories (cosine similarity)
    for (let j = i + 1; j < allMemories.length; j++) {
      if (processed.has(allMemories[j].id)) continue;

      const similarity = cosineSimilarity(
        allMemories[i].embedding,
        allMemories[j].embedding
      );

      // If similarity > 0.95, it's a duplicate
      if (similarity > 0.95) {
        cluster.push(allMemories[j]);
        processed.add(allMemories[j].id);
      }
    }

    if (cluster.length > 1) {
      clusters.set(i, cluster);
    }
  }

  // 3. For each cluster, keep the best and delete the rest
  let deletedCount = 0;

  for (const cluster of clusters.values()) {
    // Keep the most recent
    cluster.sort(
      (a, b) =>
        new Date(b.metadata?.timestamp || 0).getTime() -
        new Date(a.metadata?.timestamp || 0).getTime()
    );

    const keep = cluster[0];
    const toDelete = cluster.slice(1);

    for (const memory of toDelete) {
      try {
        await brain.delete({ agentId, memoryId: memory.id });
        deletedCount++;
      } catch (e) {
        console.error(`Failed to delete ${memory.id}:`, e);
      }
    }
  }

  return deletedCount;
}

function cosineSimilarity(a: number[], b: number[]): number {
  const dotProduct = a.reduce((sum, val, i) => sum + val * b[i], 0);
  const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
  const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
  return dotProduct / (magnitudeA * magnitudeB);
}

// Usage
const deleted = await deduplicateMemories("agent_1");
console.log(`Deleted ${deleted} duplicate memories`);

from datetime import datetime, timedelta
from brain_sdk import Brain
import json
import boto3

brain = Brain(api_key="...")
s3_client = boto3.client("s3")
S3_BUCKET = "agent_memory_archive"

async def archive_cold_memories(
    agent_id: str,
    hot_days: int = 30,
    cold_days: int = 365,
) -> dict:
    """
    Move old, rarely-retrieved memories to S3 cold storage.
    Keep recent memories in hot Brain storage.
    
    hot_days: Keep memories newer than this (active in Brain)
    cold_days: Archive memories older than this (to S3)
    """
    
    # 1. Find cold memories (older than cold_days, not accessed recently)
    cutoff_date = (datetime.utcnow() - timedelta(days=cold_days)).isoformat()
    
    cold_memories = await brain.list(
        agentId=agent_id,
        filters={
            "timestamp": {"$lt": cutoff_date},
            "last_accessed": {"$lt": cutoff_date}  # Not accessed in cold_days
        },
        limit=10000
    )
    
    if not cold_memories:
        return {"archived": 0, "reason": "No cold memories"}
    
    # 2. Create archive file
    archive = {
        "agent_id": agent_id,
        "archived_at": datetime.utcnow().isoformat(),
        "count": len(cold_memories),
        "memories": [
            {
                "id": m["id"],
                "content": m["content"],
                "metadata": m.get("metadata", {}),
                "timestamp": m["metadata"].get("timestamp")
            }
            for m in cold_memories
        ]
    }
    
    # 3. Upload to S3
    archive_key = f"archives/{agent_id}/{datetime.utcnow().strftime('%Y-%m-%d')}.json"
    
    s3_client.put_object(
        Bucket=S3_BUCKET,
        Key=archive_key,
        Body=json.dumps(archive),
        ContentType="application/json"
    )
    
    # 4. Delete from Brain
    deleted_count = 0
    for memory in cold_memories:
        try:
            await brain.delete(agentId=agent_id, memoryId=memory["id"])
            deleted_count += 1
        except Exception as e:
            print(f"Failed to delete {memory['id']}: {e}")
    
    return {
        "archived": len(cold_memories),
        "archive_key": archive_key,
        "deleted_from_brain": deleted_count
    }

async def retrieve_from_archive(agent_id: str, date: str) -> list:
    """Retrieve archived memories if needed"""
    archive_key = f"archives/{agent_id}/{date}.json"
    
    obj = s3_client.get_object(Bucket=S3_BUCKET, Key=archive_key)
    archive = json.loads(obj["Body"].read())
    
    return archive["memories"]

import { Brain } from "brain-sdk";

const brain = new Brain({ apiKey: process.env.BRAIN_API_KEY });

async function monitorMemorySize(agentId: string) {
  const allMemories = await brain.list({ agentId });
  const size = allMemories.length;

  if (size > 1000) {
    console.log(`${agentId} has ${size} memories. Triggering consolidation...`);
    await consolidateByTopic(agentId, "observed_pattern", lookback_days = 7);
  }
}

// Run every hour
setInterval(() => {
  monitorMemorySize("agent_1");
}, 1000 * 60 * 60);