Conversation Summarization & Decay

from dakera import DakeraClient
import openai

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

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

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]
    )
    # Check summarization trigger
    if len(conversation_turns) % SUMMARY_TRIGGER == 0:
        summarize_and_store()

def summarize_and_store():
    """Generate an LLM summary and store at high importance."""
    turns_text = "
".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:

{turns_text}"
        }]
    )
    summary = response.choices[0].message.content

    # Store summary with high importance — survives indefinitely
    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"]
    )
    # Trigger Dakera's consolidation to clean up raw turns
    client.consolidate(agent_id=AGENT)

def recall_case_context(query: str):
    """Recall only persistent summaries, filtering out raw turns."""
    return client.recall(
        agent_id=AGENT,
        query=query,
        min_importance=0.8,
        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 final summarization regardless of trigger
summarize_and_store()

# Next session — retrieve only clean summaries
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:3300', apiKey: 'dk-...' });
const oai = new OpenAI();

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

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,
    memoryType: 'episodic',
    tags: ['turn', CASE_ID]
  });

  if (conversationTurns.length % SUMMARY_TRIGGER === 0) {
    await summarizeAndStore();
  }
}

async function summarizeAndStore() {
  const recentTurns = conversationTurns.slice(-SUMMARY_TRIGGER).join('
');
  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:

${recentTurns}` }
    ]
  });

  const summary = response.choices[0].message.content ?? '';

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

  // Trigger consolidation to merge raw turns
  await client.consolidate(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 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_rs::{Client, StoreMemoryRequest, RecallRequest};

let client = Client::new("http://localhost:3300", "dk-...");
let agent = "legal-assistant";

// Store raw conversation turns at low importance
client.store_memory(agent, StoreMemoryRequest {
    content: "CLIENT: Terminated March 4 after 8 years. No severance offered.".into(),
    importance: Some(0.3),
    memory_type: "episodic".into(),
    tags: vec!["turn".into(), "case-247".into()],
    ..Default::default()
}).await?;

// Store LLM-generated summary at high importance
let summary = generate_case_summary(&turns).await?; // your LLM call
client.store_memory(agent, StoreMemoryRequest {
    content: format!("CASE SUMMARY [case-247]: {}", summary),
    importance: Some(0.92),
    memory_type: "semantic".into(),
    tags: vec!["summary".into(), "case-247".into()],
    ..Default::default()
}).await?;

// Trigger consolidation via REST (no direct Rust SDK method)
// POST /v1/agents/legal-assistant/consolidate

// Recall only high-importance summaries next session
let context = client.recall(agent, RecallRequest {
    query: "Jane Doe wrongful termination case details".into(),
    min_importance: Some(0.8),
    top_k: Some(5),
    ..Default::default()
}).await?;

for mem in &context.memories {
    println!("[{:.2}] {}", mem.importance, &mem.content[..120.min(mem.content.len())]);
}

package main

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

func main() {
    client := dakera.NewClient("http://localhost:3300", "dk-...")
    ctx := context.Background()
    agent := "legal-assistant"
    caseID := "case-247"

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

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

    // Trigger consolidation
    client.Consolidate(ctx, agent, dakera.ConsolidateRequest{})

    // Recall only summaries at next session
    result, _ := client.Recall(ctx, agent, dakera.RecallRequest{
        Query:         "Jane Doe wrongful termination case",
        MinImportance: 0.8,
        TopK:          5,
    })

    for _, mem := range result.Memories {
        fmt.Printf("[%.2f] %s
", mem.Importance, mem.Content[:min(120, len(mem.Content))])
    }
}