Importance-Based Forgetting

from dakera import DakeraClient

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

# --- Importance taxonomy ---
IMPORTANCE = {
    "identity":        1.0,   # permanent: never decays
    "escalation":      0.9,   # high: persists 6+ months
    "preference":      0.8,   # high: persists months
    "active_ticket":   0.6,   # medium: persists weeks
    "resolved_ticket": 0.2,   # low: decays within 2 weeks
    "greeting":        0.1,   # ephemeral: decays within days
}

# Store permanent account fact
client.store_memory(
    agent_id=AGENT,
    content="User: Alex Kim, Pro plan $299/mo, enterprise contract, API access enabled",
    importance=IMPORTANCE["identity"],
    memory_type="semantic",
    tags=["identity", "account", "alex-kim"]
)

# Store active ticket
ticket_mem = client.store_memory(
    agent_id=AGENT,
    content="Ticket #2091 OPEN: cannot export to PDF, reproducible Firefox 124, macOS",
    importance=IMPORTANCE["active_ticket"],
    memory_type="episodic",
    tags=["ticket", "open", "pdf-export"]
)

# When ticket resolves: drop importance to trigger decay
def close_ticket(memory_id: str, resolution: str):
    client.update_importance(
        agent_id=AGENT,
        memory_id=memory_id,
        importance=IMPORTANCE["resolved_ticket"]
    )
    # Store resolution note at medium importance for audit
    client.store_memory(
        agent_id=AGENT,
        content=f"RESOLVED: {resolution}",
        importance=0.45,
        memory_type="semantic",
        tags=["ticket", "resolved"]
    )

close_ticket(ticket_mem.id, "Ticket #2091: PDF export fixed in v2.14.1, deployed 2026-05-15")

# Recall: only active, relevant memories
active_context = client.recall(
    agent_id=AGENT,
    query="Alex Kim account and open issues",
    min_importance=0.5,
    top_k=10
)

# Hard-delete for GDPR compliance
def delete_user_memories(memory_ids: list[str]):
    client.batch_forget(request={
        "agent_id": AGENT,
        "memory_ids": memory_ids
    })

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

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

const IMPORTANCE = {
  identity:       1.0,
  escalation:     0.9,
  preference:     0.8,
  activeTicket:   0.6,
  resolvedTicket: 0.2,
  greeting:       0.1,
} as const;

// Store permanent identity fact
await client.storeMemory(AGENT, {
  content: 'User: Alex Kim — Pro plan $299/mo, enterprise contract, API access',
  importance: IMPORTANCE.identity,
  memoryType: 'semantic',
  tags: ['identity', 'account', 'alex-kim']
});

// Store active ticket
const ticketMem = await client.storeMemory(AGENT, {
  content: 'Ticket #2091 OPEN: cannot export to PDF, reproducible Firefox 124',
  importance: IMPORTANCE.activeTicket,
  memoryType: 'episodic',
  tags: ['ticket', 'open', 'pdf-export']
});

// On resolution: downgrade importance to enable decay
async function closeTicket(memoryId: string, resolution: string) {
  await client.updateImportance(AGENT, {
    memory_id: memoryId,
    importance: IMPORTANCE.resolvedTicket
  });
  await client.storeMemory(AGENT, {
    content: `RESOLVED: ${resolution}`,
    importance: 0.45,
    memoryType: 'semantic',
    tags: ['ticket', 'resolved']
  });
}

await closeTicket(ticketMem.id, 'Ticket #2091: PDF fix deployed in v2.14.1');

// Filtered recall — resolved tickets never appear
const context = await client.recall(AGENT, 'Alex Kim account and open issues', {
  min_importance: 0.5,
  top_k: 10
});

// GDPR hard delete
await client.batchForget({
  agent_id: AGENT,
  memory_ids: ['mem-001', 'mem-002']
});

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest};

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

// Store permanent identity memory
client.store_memory(agent, StoreMemoryRequest {
    content: "User: Alex Kim, Pro plan, enterprise contract, API access".into(),
    importance: Some(1.0),
    memory_type: "semantic".into(),
    tags: vec!["identity".into(), "account".into()],
    ..Default::default()
}).await?;

// Store active ticket at medium importance
let ticket = client.store_memory(agent, StoreMemoryRequest {
    content: "Ticket #2091 OPEN: PDF export fails in Firefox 124".into(),
    importance: Some(0.6),
    memory_type: "episodic".into(),
    tags: vec!["ticket".into(), "open".into()],
    ..Default::default()
}).await?;

// On resolution: downgrade importance via REST
// PUT /v1/memory/{id}/importance  { "importance": 0.2 }

// Recall with importance filter
let results = client.recall(agent, RecallRequest {
    query: "Alex Kim open issues".into(),
    min_importance: Some(0.5),
    top_k: Some(10),
    ..Default::default()
}).await?;

// Hard delete via REST: POST /v1/memory/batch-forget
// { "agent_id": "support-bot", "memory_ids": ["mem-001"] }

client := dakera.NewClient("http://localhost:3300", "dk-...")
ctx := context.Background()
agent := "support-bot"

// Permanent identity fact
client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
    Content:    "User: Alex Kim — Pro plan, enterprise contract, API access",
    Importance: 1.0,
    MemoryType: "semantic",
    Tags:       []string{"identity", "account"},
})

// Active ticket at medium importance
ticket, _ := client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
    Content:    "Ticket #2091 OPEN: PDF export fails in Firefox 124",
    Importance: 0.6,
    MemoryType: "episodic",
    Tags:       []string{"ticket", "open"},
})

// On resolution: downgrade importance
client.Forget(ctx, agent, ticket.ID) // or call update_importance via REST

// Recall with filter
results, _ := client.Recall(ctx, agent, dakera.RecallRequest{
    Query:         "Alex Kim open issues",
    MinImportance: 0.5,
    TopK:          10,
})