Conversation Summarization & Decay

from dakera import DakeraClient
import openai

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

AGENT = "legal-assistant"
CASE_ID = "case-247"
SUMMARY_TRIGGER = 15  # summarize every 15 turns
MIN_RECALL_IMPORTANCE = 0.8

# Once per agent: summaries (semantic) keep their importance; raw turns (episodic) still decay
policy = client.get_memory_policy(f"_dakera_agent_{AGENT}")
policy.semantic_decay = "flat"
client.set_memory_policy(f"_dakera_agent_{AGENT}", policy)

conversation_turns = []

def store_turn(role: str, content: str):
    """Store a single conversation turn at low importance."""
    turn_text = f"{role.upper()}: {content}"
    conversation_turns.append(turn_text)
    client.store_memory(
        agent_id=AGENT,
        content=turn_text,
        importance=0.3,
        memory_type="episodic",
        tags=["turn", CASE_ID]
    )
    if len(conversation_turns) % SUMMARY_TRIGGER == 0:
        summarize_and_store()

def summarize_and_store():
    """Generate an LLM summary and store it at high importance."""
    turns_text = "\n".join(conversation_turns[-SUMMARY_TRIGGER:])
    response = oai.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "system",
            "content": "You are a legal case summarizer. Extract: client name, key claims, relevant dates, requested documents, and next steps. Be concise and factual."
        }, {
            "role": "user",
            "content": f"Summarize this consultation segment:\n\n{turns_text}"
        }]
    )
    summary = response.choices[0].message.content

    client.store_memory(
        agent_id=AGENT,
        content=f"CASE SUMMARY [{CASE_ID}]: {summary}",
        importance=0.92,
        memory_type="semantic",
        tags=["summary", CASE_ID, "auto-generated"]
    )
    # Consolidate now instead of waiting for AutoPilot's 12-hour cycle
    client.consolidate_agent(AGENT)

def recall_case_context(query: str):
    """Recall summaries and key facts, filtering out raw turns."""
    return client.recall(
        agent_id=AGENT,
        query=query,
        min_importance=MIN_RECALL_IMPORTANCE,
        top_k=5
    )

# --- Simulation ---
store_turn("client", "I was terminated on March 4 after 8 years. No severance was offered.")
store_turn("attorney", "Was there a written employment contract?")
store_turn("client", "No written contract. I was at-will.")
# ... more turns ...

# At session end: force a final summary regardless of the trigger
summarize_and_store()

# Next session: only durable summaries come back
context = recall_case_context("Jane Doe wrongful termination case")
for mem in context.memories:
    print(f"[{mem.importance:.2f}] {mem.content[:120]}")

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

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

const AGENT = 'legal-assistant';
const CASE_ID = 'case-247';
const SUMMARY_TRIGGER = 15;

// Once per agent: summaries (semantic) keep their importance; raw turns still decay
const ns = `_dakera_agent_${AGENT}`;
const policy = await client.getMemoryPolicy(ns);
await client.setMemoryPolicy(ns, { ...policy, semantic_decay: 'flat' });

const conversationTurns: string[] = [];

async function storeTurn(role: 'client' | 'attorney', content: string) {
  const turnText = `${role.toUpperCase()}: ${content}`;
  conversationTurns.push(turnText);
  await client.storeMemory(AGENT, {
    content: turnText,
    importance: 0.3,
    memory_type: 'episodic',
    tags: ['turn', CASE_ID],
  });
  if (conversationTurns.length % SUMMARY_TRIGGER === 0) {
    await summarizeAndStore();
  }
}

async function summarizeAndStore() {
  const recentTurns = conversationTurns.slice(-SUMMARY_TRIGGER).join('\n');
  const response = await oai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      {
        role: 'system',
        content: 'You are a legal case summarizer. Extract: client name, key claims, relevant dates, documents requested, and next steps. Be concise.'
      },
      { role: 'user', content: `Summarize this consultation:\n\n${recentTurns}` }
    ]
  });
  const summary = response.choices[0].message.content ?? '';

  await client.storeMemory(AGENT, {
    content: `CASE SUMMARY [${CASE_ID}]: ${summary}`,
    importance: 0.92,
    memory_type: 'semantic',
    tags: ['summary', CASE_ID, 'auto-generated'],
  });

  // Consolidate now instead of waiting for AutoPilot's 12-hour cycle
  await client.consolidateAgent(AGENT);
}

async function recallCaseContext(query: string) {
  return client.recall(AGENT, query, { min_importance: 0.8, top_k: 5 });
}

// Usage
await storeTurn('client', 'I was terminated on March 4 after 8 years. No severance.');
await storeTurn('attorney', 'Was there a written contract?');
await storeTurn('client', 'No written contract. I was at-will.');

// Force a final summary at session end
await summarizeAndStore();

// Retrieve clean context next session
const context = await recallCaseContext('Jane Doe wrongful termination');
context.memories.forEach(m => console.log(`[${m.importance}] ${m.content.slice(0, 120)}`));

use dakera_client::{DakeraClient, MemoryType, RecallRequest, StoreMemoryRequest};

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

// Once per agent: summaries (semantic) keep their importance; raw turns still decay
let ns = format!("_dakera_agent_{}", agent);
let mut policy = client.get_memory_policy(&ns).await?;
policy.semantic_decay = Some("flat".into());
client.set_memory_policy(&ns, policy).await?;

// Store raw conversation turns at low importance
client.store_memory(
    StoreMemoryRequest::new(agent, "CLIENT: Terminated March 4 after 8 years. No severance offered.")
        .with_type(MemoryType::Episodic)
        .with_importance(0.3)
        .with_tags(vec!["turn".into(), "case-247".into()]),
).await?;

// Store the LLM-generated summary at high importance
let summary = generate_case_summary(&turns).await?; // your LLM call
client.store_memory(
    StoreMemoryRequest::new(agent, format!("CASE SUMMARY [case-247]: {}", summary))
        .with_type(MemoryType::Semantic)
        .with_importance(0.92)
        .with_tags(vec!["summary".into(), "case-247".into()]),
).await?;

// Consolidate now instead of waiting for AutoPilot's 12-hour cycle
client.consolidate_agent(agent).await?;

// Recall only high-importance summaries next session
let context = client.recall(
    RecallRequest::new(agent, "Jane Doe wrongful termination case details")
        .with_min_importance(0.8)
        .with_top_k(5),
).await?;

for mem in &context.memories {
    let preview: String = mem.content.chars().take(120).collect();
    println!("[{:.2}] {}", mem.importance, preview);
}

package main

import (
    "context"
    "fmt"
    "log"

    dakera "github.com/dakera-ai/dakera-go"
)

func main() {
    client := dakera.NewClientWithOptions(dakera.ClientOptions{
        BaseURL: "http://localhost:3000",
        APIKey:  "dk-...",
    })
    ctx := context.Background()
    agent := "legal-assistant"
    caseID := "case-247"

    // Once per agent: summaries (semantic) keep their importance; raw turns still decay
    ns := "_dakera_agent_" + agent
    policy, err := client.GetMemoryPolicy(ctx, ns)
    if err != nil {
        log.Fatal(err)
    }
    flat := "flat"
    policy.SemanticDecay = &flat
    if _, err := client.SetMemoryPolicy(ctx, ns, *policy); err != nil {
        log.Fatal(err)
    }

    // Store a raw turn at low importance
    turnImp := float32(0.3)
    client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
        Content:    "CLIENT: Terminated March 4 after 8 years. No severance.",
        Importance: &turnImp,
        MemoryType: "episodic",
        Tags:       []string{"turn", caseID},
    })

    // After summarization, store the summary at high importance
    summary := generateCaseSummary(turns) // your LLM call
    summaryImp := float32(0.92)
    client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
        Content:    fmt.Sprintf("CASE SUMMARY [%s]: %s", caseID, summary),
        Importance: &summaryImp,
        MemoryType: "semantic",
        Tags:       []string{"summary", caseID},
    })

    // Consolidate now instead of waiting for AutoPilot's 12-hour cycle
    client.ConsolidateAgent(ctx, agent)

    // Recall only summaries at the next session
    minImp := float32(0.8)
    result, err := client.Recall(ctx, agent, dakera.RecallRequest{
        Query:         "Jane Doe wrongful termination case",
        MinImportance: &minImp,
        TopK:          5,
    })
    if err != nil {
        log.Fatal(err)
    }
    for _, mem := range result.Memories {
        fmt.Printf("[%.2f] %s\n", mem.Importance, mem.Content[:min(120, len(mem.Content))])
    }
}