Importance-Based Forgetting

from dakera import DakeraClient, BatchForgetRequest, BatchMemoryFilter

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

# --- Importance taxonomy (recall uses min_importance=0.5 by default) ---
IMPORTANCE = {
    "identity":        1.0,   # account facts: always above the threshold
    "escalation":      0.9,
    "preference":      0.8,
    "active_ticket":   0.6,   # above 0.5 while open
    "resolved_ticket": 0.2,   # below 0.5: left out of default recalls
    "greeting":        0.1,
}

# 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", "alex-kim"]
)

# When ticket resolves: drop importance below the recall threshold
def close_ticket(memory_id: str, resolution: str):
    client.update_importance(
        agent_id=AGENT,
        memory_ids=[memory_id],
        importance=IMPORTANCE["resolved_ticket"]
    )
    # Store resolution note below the threshold too, kept for audit
    client.store_memory(
        agent_id=AGENT,
        content=f"RESOLVED: {resolution}",
        importance=0.45,
        memory_type="semantic",
        tags=["ticket", "resolved", "alex-kim"]
    )

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
)
for m in active_context.memories:
    print(f"[{m.importance:.2f}] {m.content}")

# Hard-delete for GDPR compliance: every memory tagged with the user
def delete_user_memories(user_tag: str) -> int:
    resp = client.batch_forget(BatchForgetRequest(
        agent_id=AGENT,
        filter=BatchMemoryFilter(tags=[user_tag]),
    ))
    return resp.deleted_count

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

const client = new DakeraClient({ baseUrl: 'http://localhost:3000', 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,
  memory_type: 'semantic',
  tags: ['identity', 'account', 'alex-kim'],
});

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

// On resolution: drop importance below the recall threshold
async function closeTicket(memoryId: string, resolution: string) {
  await client.updateImportance(AGENT, {
    memory_ids: [memoryId],
    importance: IMPORTANCE.resolvedTicket,
  });
  await client.storeMemory(AGENT, {
    content: `RESOLVED: ${resolution}`,
    importance: 0.45,
    memory_type: 'semantic',
    tags: ['ticket', 'resolved', 'alex-kim'],
  });
}

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

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

// GDPR hard delete: every memory tagged with the user (a filter is required)
const resp = await client.batchForget({
  agent_id: AGENT,
  filter: { tags: ['alex-kim'] },
});
console.log(`Deleted ${resp.deleted_count} memories`);

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

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

// Store permanent identity memory
client.store_memory(
    StoreMemoryRequest::new(agent, "User: Alex Kim, Pro plan, enterprise contract, API access")
        .with_type(MemoryType::Semantic)
        .with_importance(1.0)
        .with_tags(vec!["identity".into(), "account".into(), "alex-kim".into()]),
).await?;

// Store active ticket at medium importance
let ticket = client.store_memory(
    StoreMemoryRequest::new(agent, "Ticket #2091 OPEN: PDF export fails in Firefox 124")
        .with_type(MemoryType::Episodic)
        .with_importance(0.6)
        .with_tags(vec!["ticket".into(), "open".into(), "alex-kim".into()]),
).await?;

// On resolution: drop importance below the recall threshold
client.patch_memory_importance(&ticket.memory_id, agent, 0.2).await?;

// Recall with importance filter
let results = client.recall(
    RecallRequest::new(agent, "Alex Kim open issues")
        .with_min_importance(0.5)
        .with_top_k(10),
).await?;

// Hard delete every memory tagged with the user (GDPR)
let deleted = client.batch_forget(BatchForgetRequest::new(
    agent,
    BatchMemoryFilter::default().with_tags(vec!["alex-kim".into()]),
)).await?;
println!("{} memories deleted", deleted.deleted_count);

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: "http://localhost:3000",
    APIKey:  "dk-...",
})
ctx := context.Background()
agent := "support-bot"
f32 := func(v float32) *float32 { return &v }

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

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

// On resolution: drop importance below the recall threshold
client.PatchMemoryImportance(ctx, ticket.Memory.ID, agent, 0.2)

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

// GDPR: hard delete every memory tagged with the user
resp, _ := client.BatchForget(ctx, dakera.BatchForgetRequest{
    AgentID: agent,
    Filter:  dakera.BatchMemoryFilter{Tags: []string{"alex-kim"}},
})
fmt.Printf("Deleted %d memories\n", resp.DeletedCount)