Hierarchical Memory

from dakera import DakeraClient
from collections import defaultdict

client = DakeraClient(base_url="http://localhost:3300", api_key="dk-...")

# Track recall counts for promotion logic
recall_counts = defaultdict(int)
TIER1_PROMOTE_THRESHOLD = 3   # promote to Tier 2 after 3 recalls
TIER2_PROMOTE_THRESHOLD = 10  # promote to Tier 3 after 10 recalls

def store_working(content: str, session_context: str = "") -> dict:
    """Tier 1: Ephemeral session scratchpad. Auto-expires in 1 hour."""
    return client.store_memory(
        agent_id="assistant",
        content=content,
        memory_type="working",
        importance=0.2,
        ttl_seconds=3600,
        tags=["working", "ephemeral"]
    )

def store_long_term(content: str, tags: list[str] = None) -> dict:
    """Tier 2: Consolidated knowledge. Survives weeks of inactivity."""
    return client.store_memory(
        agent_id="assistant",
        content=content,
        memory_type="semantic",
        importance=0.7,
        tags=tags or ["long-term"]
    )

def store_permanent(content: str) -> dict:
    """Tier 3: Identity facts. Never decays. Use sparingly."""
    return client.store_memory(
        agent_id="assistant",
        content=content,
        memory_type="semantic",
        importance=1.0,
        tags=["identity", "permanent"]
    )

def recall_with_promotion(query: str, top_k: int = 5) -> list:
    """Recall and auto-promote frequently accessed memories."""
    memories = client.recall(
        agent_id="assistant",
        query=query,
        top_k=top_k
    )

    for mem in memories:
        mem_id = mem["id"]
        recall_counts[mem_id] += 1
        current_importance = mem.get("importance", 0.2)

        # Promote Tier 1 -> Tier 2 if recalled frequently
        if current_importance < 0.5 and recall_counts[mem_id] >= TIER1_PROMOTE_THRESHOLD:
            client.update_importance(
                agent_id="assistant",
                memory_id=mem_id,
                importance=0.65
            )
            print(f"Promoted memory {mem_id} to Tier 2 (recalled {recall_counts[mem_id]}x)")

        # Promote Tier 2 -> Tier 3 if very frequently recalled
        elif 0.5 <= current_importance < 0.95 and recall_counts[mem_id] >= TIER2_PROMOTE_THRESHOLD:
            client.update_importance(
                agent_id="assistant",
                memory_id=mem_id,
                importance=1.0
            )
            client.update_memory(
                agent_id="assistant",
                memory_id=mem_id,
                tags=["identity", "permanent"]
            )
            print(f"Promoted memory {mem_id} to Tier 3 (recalled {recall_counts[mem_id]}x)")

    return memories

# --- Example usage ---

# On first meeting the user
store_permanent("User: Alex Chen, Senior ML Engineer at Acme Corp, Data Infrastructure team")

# During current session
store_working("User is debugging a memory leak in their Spark job — heap usage grows 2x per batch")
store_working("User mentioned the job processes ~50M records per day")

# After the session — consolidate what we learned
store_long_term(
    "Alex works on Spark data pipelines processing 50M records/day. "
    "Has recurring memory leak issues. Prefers Python solutions over Scala.",
    tags=["tech-stack", "pain-points"]
)

# Recall in the next session
context = recall_with_promotion("what is the user working on and what problems do they have", top_k=8)
for mem in context:
    print(f"[{mem['importance']:.1f}] {mem['content'][:80]}")

import { DakeraClient } from '@dakera-ai/dakera';

const client = new DakeraClient({ baseUrl: 'http://localhost:3300', apiKey: 'dk-...' });

const TIER1_THRESHOLD = 3;
const TIER2_THRESHOLD = 10;
const recallCounts = new Map<string, number>();

// Tier 1: Working memory — expires in 1 hour
async function storeWorking(content: string): Promise<{ id: string }> {
  return client.storeMemory('assistant', {
    content,
    memoryType: 'working',
    importance: 0.2,
    ttl_seconds: 3600,
    tags: ['working', 'ephemeral']
  });
}

// Tier 2: Long-term semantic memory — slow natural decay
async function storeLongTerm(content: string, tags: string[] = []): Promise<{ id: string }> {
  return client.storeMemory('assistant', {
    content,
    memoryType: 'semantic',
    importance: 0.7,
    tags: ['long-term', ...tags]
  });
}

// Tier 3: Permanent identity — never decays
async function storePermanent(content: string): Promise<{ id: string }> {
  return client.storeMemory('assistant', {
    content,
    memoryType: 'semantic',
    importance: 1.0,
    tags: ['identity', 'permanent']
  });
}

// Recall with automatic promotion
async function recallWithPromotion(query: string, topK = 5) {
  const memories = await client.recall('assistant', query, { top_k: topK });

  for (const mem of memories) {
    const count = (recallCounts.get(mem.id) ?? 0) + 1;
    recallCounts.set(mem.id, count);

    if (mem.importance < 0.5 && count >= TIER1_THRESHOLD) {
      // Promote Tier 1 -> Tier 2
      await client.updateImportance('assistant', { memory_id: mem.id, importance: 0.65 });
      console.log(`Promoted ${mem.id} to Tier 2`);
    } else if (mem.importance >= 0.5 && mem.importance < 0.95 && count >= TIER2_THRESHOLD) {
      // Promote Tier 2 -> Tier 3
      await client.updateImportance('assistant', { memory_id: mem.id, importance: 1.0 });
      await client.updateMemory('assistant', mem.id, { tags: ['identity', 'permanent'] });
      console.log(`Promoted ${mem.id} to Tier 3 (permanent)`);
    }
  }

  return memories;
}

// --- Usage ---

// First session: store identity
await storePermanent('User: Alex Chen, Senior ML Engineer at Acme Corp');

// During session: working scratchpad
await storeWorking('User debugging Spark memory leak — heap grows 2x per batch cycle');
await storeWorking('Spark job processes ~50M records/day on 8-node cluster');

// End of session: consolidate to long-term
await storeLongTerm(
  'Alex runs Spark pipelines processing 50M records/day. Recurring OOM issues. Prefers Python.',
  ['tech-stack', 'pain-points']
);

// Next session recall
const context = await recallWithPromotion('what is the user building and what problems do they face', 8);
context.forEach(m => console.log(`[${m.importance.toFixed(1)}] ${m.content.substring(0, 80)}`));

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest, UpdateMemoryRequest};
use std::collections::HashMap;

let client = Client::new("http://localhost:3300", "dk-...");
let mut recall_counts: HashMap<String, u32> = HashMap::new();

// Tier 1: Working memory — auto-expires in 1 hour
client.store_memory("assistant", StoreMemoryRequest {
    content: "User debugging Spark memory leak — heap grows 2x per batch cycle".into(),
    memory_type: Some("working".into()),
    importance: Some(0.2),
    ttl_seconds: Some(3600),
    tags: vec!["working".into(), "ephemeral".into()],
    ..Default::default()
}).await?;

// Tier 2: Long-term semantic — slow decay
client.store_memory("assistant", StoreMemoryRequest {
    content: "Alex runs Spark pipelines processing 50M records/day. OOM issues recurring.".into(),
    memory_type: Some("semantic".into()),
    importance: Some(0.7),
    tags: vec!["tech-stack".into(), "pain-points".into()],
    ..Default::default()
}).await?;

// Tier 3: Permanent identity — no decay
client.store_memory("assistant", StoreMemoryRequest {
    content: "User: Alex Chen, Senior ML Engineer at Acme Corp, Data Infrastructure".into(),
    memory_type: Some("semantic".into()),
    importance: Some(1.0),
    tags: vec!["identity".into(), "permanent".into()],
    ..Default::default()
}).await?;

// Recall all tiers in one call — importance ranking is automatic
let memories = client.recall("assistant", RecallRequest {
    query: "who is the user and what are they working on".into(),
    top_k: Some(8),
    ..Default::default()
}).await?;

// Promotion logic
for mem in &memories {
    let count = recall_counts.entry(mem.id.clone()).or_insert(0);
    *count += 1;

    if mem.importance < 0.5 && *count >= 3 {
        client.update_memory("assistant", &mem.id, UpdateMemoryRequest {
            importance: Some(0.65),
            ..Default::default()
        }).await?;
        println!("Promoted {} to Tier 2", mem.id);
    }
}

package main

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

func main() {
    client := dakera.NewClient("http://localhost:3300", "dk-...")
    ctx := context.Background()
    recallCounts := make(map[string]int)

    // Tier 3: Permanent identity — store once, recall forever
    client.StoreMemory(ctx, "assistant", dakera.StoreMemoryRequest{
        Content:    "User: Alex Chen, Senior ML Engineer at Acme Corp",
        MemoryType: "semantic",
        Importance: 1.0,
        Tags:       []string{"identity", "permanent"},
    })

    // Tier 1: Working memory — expires in 1 hour
    client.StoreMemory(ctx, "assistant", dakera.StoreMemoryRequest{
        Content:    "User debugging Spark memory leak — heap grows 2x per batch",
        MemoryType: "working",
        Importance: 0.2,
        TTLSeconds: 3600,
        Tags:       []string{"working", "ephemeral"},
    })

    // Tier 2: Long-term knowledge — slow natural decay
    client.StoreMemory(ctx, "assistant", dakera.StoreMemoryRequest{
        Content:    "Alex runs Spark pipelines, 50M records/day, OOM issues, prefers Python",
        MemoryType: "semantic",
        Importance: 0.7,
        Tags:       []string{"tech-stack", "pain-points"},
    })

    // Single recall call covers all tiers
    memories, _ := client.Recall(ctx, "assistant", dakera.RecallRequest{
        Query: "who is the user and what are they working on",
        TopK:  8,
    })

    for _, mem := range memories {
        recallCounts[mem.ID]++
        fmt.Printf("[%.1f] %s
", mem.Importance, mem.Content[:min(len(mem.Content), 80)])

        // Promote if recalled frequently
        if mem.Importance < 0.5 && recallCounts[mem.ID] >= 3 {
            client.UpdateMemory(ctx, "assistant", mem.ID, dakera.UpdateMemoryRequest{
                Importance: 0.65,
            })
        }
    }
}