Memory Compression

from dakera import DakeraClient, BatchRecallRequest, BatchMemoryFilter
import openai
import re
import uuid
from collections import defaultdict
from datetime import datetime, timedelta, timezone

client = DakeraClient(base_url="http://localhost:3000", api_key="dk-...")
oai = openai.OpenAI()
AGENT = "analytics-bot"

def cluster_by_metric(memories):
    """Group data points by metric: the content starts with "DAU:", "Revenue:", ..."""
    clusters = defaultdict(list)
    for m in memories:
        metric = m.content.split(":", 1)[0].strip().lower()
        clusters[metric].append(m)
    return clusters

def summarize_cluster(cluster):
    """LLM summarization of a memory cluster."""
    contents = "\n".join([f"- {m.content}" for m in cluster])
    resp = oai.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": "Summarize these analytics data points into a single dense paragraph. Preserve all quantitative values, dates, and trends. Highlight anomalies."
        }, {
            "role": "user",
            "content": f"Data points:\n{contents}"
        }]
    )
    return resp.choices[0].message.content

def numbers_are_grounded(summary: str, cluster) -> bool:
    """Every number in the summary must appear in at least one input memory."""
    source = " ".join(m.content for m in cluster)
    return all(n in source for n in re.findall(r"\d[\d,.]*\d|\d", summary))

def compress_window(start: datetime, end: datetime, min_cluster_size: int = 3, hard_delete: bool = True):
    """Compress one time window of raw analytics memories."""
    candidates = client.batch_recall(BatchRecallRequest(
        agent_id=AGENT,
        filter=BatchMemoryFilter(
            tags=["daily", "weekly"],            # raw data points; summaries are not tagged daily
            max_importance=0.8,                  # summaries (0.85-0.92) are excluded
            created_after=int(start.timestamp()),
            created_before=int(end.timestamp()),
        ),
        limit=1000,
    ))

    clusters = cluster_by_metric(candidates.memories)
    print(f"Found {len(clusters)} clusters from {len(candidates.memories)} memories")

    for metric, cluster in clusters.items():
        if len(cluster) < min_cluster_size:
            continue  # Skip tiny clusters: not worth compressing

        summary = summarize_cluster(cluster)
        if not summary or not numbers_are_grounded(summary, cluster):
            continue  # Skip empty summaries and summaries with invented numbers

        cluster_id = str(uuid.uuid4())[:8]
        client.store_memory(
            agent_id=AGENT,
            content=summary,
            importance=0.90,
            memory_type="semantic",
            tags=["compressed", f"cluster-{cluster_id}", f"range-{start:%b%d}-{end:%b%d}".lower(), metric]
        )

        ids = [m.id for m in cluster]
        if hard_delete:
            for memory_id in ids:  # analytics: no audit needed
                client.forget(agent_id=AGENT, memory_id=memory_id)
        else:
            client.update_importance(agent_id=AGENT, memory_ids=ids, importance=0.08)
        print(f"Cluster {cluster_id} ({metric}): {len(cluster)} memories -> 1 summary")

# Run monthly: compress the 4-week window that ended 30 days ago
now = datetime.now(timezone.utc)
compress_window(start=now - timedelta(days=58), end=now - timedelta(days=30))

import { DakeraClient } from '@dakera-ai/dakera';
import OpenAI from 'openai';
import { randomUUID } from 'crypto';

const client = new DakeraClient({ baseUrl: 'http://localhost:3000', apiKey: 'dk-...' });
const oai = new OpenAI();
const AGENT = 'analytics-bot';

// Group data points by metric: the content starts with "DAU:", "Revenue:", ...
function clusterByMetric<T extends { content: string }>(memories: T[]): Map<string, T[]> {
  const clusters = new Map<string, T[]>();
  for (const m of memories) {
    const metric = m.content.split(':')[0].trim().toLowerCase();
    clusters.set(metric, [...(clusters.get(metric) ?? []), m]);
  }
  return clusters;
}

async function summarizeCluster(cluster: { content: string }[]): Promise<string> {
  const contents = cluster.map(m => `- ${m.content}`).join('\n');
  const res = await oai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'Summarize these analytics data points into a single dense paragraph. Preserve all quantitative values, dates, and anomalies.' },
      { role: 'user', content: `Data:\n${contents}` },
    ],
  });
  return res.choices[0].message.content ?? '';
}

// Every number in the summary must appear in at least one input memory
function numbersAreGrounded(summary: string, cluster: { content: string }[]): boolean {
  const source = cluster.map(m => m.content).join(' ');
  return (summary.match(/\d[\d,.]*\d|\d/g) ?? []).every(n => source.includes(n));
}

async function compressWindow(start: Date, end: Date, minClusterSize = 3) {
  const { memories } = await client.batchRecall({
    agent_id: AGENT,
    filter: {
      tags: ['daily', 'weekly'],
      max_importance: 0.8,
      created_after: Math.floor(start.getTime() / 1000),
      created_before: Math.floor(end.getTime() / 1000),
    },
    limit: 1000,
  });

  const clusters = clusterByMetric(memories);
  console.log(`Found ${clusters.size} clusters from ${memories.length} memories`);

  for (const [metric, cluster] of clusters) {
    if (cluster.length < minClusterSize) continue;
    const summary = await summarizeCluster(cluster);
    if (!summary || !numbersAreGrounded(summary, cluster)) continue;

    const clusterId = randomUUID().slice(0, 8);
    await client.storeMemory(AGENT, {
      content: summary,
      importance: 0.90,
      memory_type: 'semantic',
      tags: ['compressed', `cluster-${clusterId}`, metric],
    });

    // Hard-delete the originals (analytics: no audit needed)
    for (const m of cluster) await client.forget(AGENT, m.id);
    console.log(`Cluster ${clusterId} (${metric}): ${cluster.length} memories -> 1 summary`);
  }
}

// Run monthly: compress the 4-week window that ended 30 days ago
const day = 86_400_000;
await compressWindow(new Date(Date.now() - 58 * day), new Date(Date.now() - 30 * day));

use dakera_client::{BatchMemoryFilter, BatchRecallRequest, DakeraClient, ForgetRequest,
    MemoryType, StoreMemoryRequest};
use std::collections::HashMap;

let client = DakeraClient::builder("http://localhost:3000")
    .api_key("dk-...")
    .build()?;
let agent = "analytics-bot";

// 1. List raw data points (summaries are tagged "compressed", not "daily")
let candidates = client.batch_recall(
    BatchRecallRequest::new(agent)
        .with_filter(
            BatchMemoryFilter::default()
                .with_tags(vec!["daily".into(), "weekly".into()])
                .with_max_importance(0.8),
        )
        .with_limit(1000),
).await?;

// 2. Group by metric: the content starts with "DAU:", "Revenue:", ...
let mut clusters: HashMap<String, Vec<_>> = HashMap::new();
for m in &candidates.memories {
    let metric = m.content.split(':').next().unwrap_or("").trim().to_lowercase();
    clusters.entry(metric).or_default().push(m);
}

// 3. For each cluster: summarize with your LLM, store, then delete the originals
for (metric, cluster) in clusters {
    if cluster.len() < 3 { continue; }
    let summary = summarize_with_llm(&cluster).await?; // your LLM call
    let cluster_id = uuid::Uuid::new_v4().to_string()[..8].to_string();

    client.store_memory(
        StoreMemoryRequest::new(agent, summary)
            .with_type(MemoryType::Semantic)
            .with_importance(0.90)
            .with_tags(vec!["compressed".into(), format!("cluster-{}", cluster_id), metric.clone()]),
    ).await?;

    let ids: Vec<String> = cluster.iter().map(|m| m.id.clone()).collect();
    client.forget(ForgetRequest::by_ids(agent, ids)).await?;
    println!("Cluster {} ({}): {} -> 1 summary", cluster_id, metric, cluster.len());
}

package main

import (
    "context"
    "fmt"
    "strings"
    dakera "github.com/dakera-ai/dakera-go"
)

func compressAgentMemories(ctx context.Context, client *dakera.Client, agent string) {
    // 1. List raw data points (summaries are tagged "compressed", not "daily")
    maxImp := float32(0.8)
    candidates, _ := client.BatchRecall(ctx, dakera.BatchRecallRequest{
        AgentID: agent,
        Filter:  dakera.BatchMemoryFilter{Tags: []string{"daily", "weekly"}, MaxImportance: &maxImp},
        Limit:   1000,
    })

    // 2. Group by metric: the content starts with "DAU:", "Revenue:", ...
    clusters := map[string][]dakera.RecalledMemory{}
    for _, m := range candidates.Memories {
        metric := strings.ToLower(strings.TrimSpace(strings.SplitN(m.Content, ":", 2)[0]))
        clusters[metric] = append(clusters[metric], m)
    }
    fmt.Printf("Found %d clusters from %d memories\n", len(clusters), len(candidates.Memories))

    for metric, cluster := range clusters {
        if len(cluster) < 3 { continue }
        summary := summarizeWithLLM(cluster) // your LLM call
        clusterID := randomID(8)
        importance := float32(0.90)

        // Store compressed summary
        client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
            Content:    summary,
            Importance: &importance,
            MemoryType: "semantic",
            Tags:       []string{"compressed", "cluster-" + clusterID, metric},
        })

        // Delete the originals
        for _, m := range cluster {
            client.Forget(ctx, agent, m.ID)
        }
        fmt.Printf("Cluster %s (%s): %d memories -> 1 summary\n", clusterID, metric, len(cluster))
    }
}