Tool Usage Learning

import time
from typing import Optional
from dakera import DakeraClient

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

IMPORTANCE = {"success": 0.88, "partial": 0.65, "failure": 0.42}


def record_tool_outcome(agent_id: str, tool: str, task_type: str, outcome: str,
                        notes: str, latency_ms: int, error: Optional[str] = None) -> None:
    """Persist a tool invocation outcome for future learning."""
    content = f"{tool} tool {outcome} for {task_type} task. {notes}. Latency: {latency_ms}ms."
    if error:
        content += f" Error: {error}."
    client.store_memory(
        agent_id=agent_id,
        content=content,
        importance=IMPORTANCE.get(outcome, 0.6),
        memory_type="semantic",
        tags=[f"tool:{tool}", f"task:{task_type}", f"outcome:{outcome}"],
        metadata={"tool": tool, "task_type": task_type, "outcome": outcome, "latency_ms": latency_ms},
        ttl_seconds=2_592_000,  # 30 days: stale patterns expire
    )


def get_best_tool(agent_id: str, task_type: str, available_tools: list[str]) -> str:
    """Recall tool history and return the highest-scoring tool for this task type."""
    response = client.recall(agent_id=agent_id, query=f"tool outcomes for {task_type} tasks",
                             top_k=10, min_importance=0.3)
    stats = {t: {"successes": 0, "total": 0, "latency": 0} for t in available_tools}
    for mem in response.memories:
        meta = mem.metadata or {}
        if meta.get("tool") not in stats:
            continue
        s = stats[meta["tool"]]
        s["total"] += 1
        s["successes"] += meta.get("outcome") == "success"
        s["latency"] += meta.get("latency_ms", 5000)

    # Score: 70% success rate + 30% speed (normalized to 60 s)
    best_tool, best_score = available_tools[0], -1.0
    for tool, s in stats.items():
        if s["total"] == 0:
            continue  # no history: let the model decide
        success_rate = s["successes"] / s["total"]
        speed = max(0.0, 1 - (s["latency"] / s["total"]) / 60_000)
        score = success_rate * 0.7 + speed * 0.3
        if score > best_score:
            best_tool, best_score = tool, score
    return best_tool


# --- Usage in a DevOps agent ---
TOOLS = ["kubectl_deploy", "ansible_run", "terraform_apply", "helm_upgrade"]

def deploy_to_production(service: str, version: str) -> dict:
    best = get_best_tool("devops-agent", "production_deploy", TOOLS)
    start = time.time()
    try:
        result = execute_tool(best, service=service, version=version)  # your tool runner
        record_tool_outcome("devops-agent", best, "production_deploy", "success",
                            f"Deployed {service} v{version} to production cluster",
                            int((time.time() - start) * 1000))
        return result
    except Exception as e:
        record_tool_outcome("devops-agent", best, "production_deploy", "failure",
                            f"Failed to deploy {service} v{version}",
                            int((time.time() - start) * 1000), error=str(e))
        raise

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

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

type Outcome = 'success' | 'failure' | 'partial';
const IMPORTANCE: Record<Outcome, number> = { success: 0.88, partial: 0.65, failure: 0.42 };

async function recordToolOutcome(agentId: string, tool: string, taskType: string,
                                 outcome: Outcome, notes: string, latencyMs: number) {
  await client.storeMemory(agentId, {
    content: `${tool} tool ${outcome} for ${taskType} task. ${notes}. Latency: ${latencyMs}ms.`,
    importance: IMPORTANCE[outcome],
    memory_type: 'semantic',
    tags: [`tool:${tool}`, `task:${taskType}`, `outcome:${outcome}`],
    metadata: { tool, task_type: taskType, outcome, latency_ms: latencyMs },
    ttl_seconds: 2_592_000, // 30 days
  });
}

async function getBestTool(agentId: string, taskType: string, tools: string[]): Promise<string> {
  const { memories } = await client.recall(agentId, `tool outcomes for ${taskType} tasks`,
    { top_k: 10, min_importance: 0.3 });

  const stats = new Map(tools.map(t => [t, { successes: 0, total: 0, latency: 0 }]));
  for (const mem of memories) {
    const s = stats.get(mem.metadata?.tool as string);
    if (!s) continue;
    s.total++;
    if (mem.metadata?.outcome === 'success') s.successes++;
    s.latency += (mem.metadata?.latency_ms as number) ?? 5000;
  }

  let best = tools[0];
  let bestScore = -1;
  for (const [tool, s] of stats) {
    if (s.total === 0) continue; // no history: let the model decide
    const speed = Math.max(0, 1 - s.latency / s.total / 60_000);
    const score = (s.successes / s.total) * 0.7 + speed * 0.3;
    if (score > bestScore) { bestScore = score; best = tool; }
  }
  return best;
}

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

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

// Record an outcome; the first words of the content name the tool and the outcome
let (tool, outcome, latency_ms) = ("kubectl_deploy", "success", 1900);
let importance = match outcome { "success" => 0.88, "partial" => 0.65, _ => 0.42 };
client.store_memory(
    StoreMemoryRequest::new(agent, format!(
        "{tool} tool {outcome} for production_deploy task. Latency: {latency_ms}ms."))
        .with_importance(importance)
        .with_tags(vec![format!("tool:{tool}"), "task:production_deploy".into(), format!("outcome:{outcome}")]),
).await?;

// Recall outcomes and compute a success rate per tool from the content
let found = client.recall(
    RecallRequest::new(agent, "tool outcomes for production_deploy tasks").with_top_k(10),
).await?;
for tool in ["kubectl_deploy", "ansible_run"] {
    let runs: Vec<_> = found.memories.iter().filter(|m| m.content.starts_with(tool)).collect();
    let ok = runs.iter().filter(|m| m.content.contains(" tool success ")).count();
    if !runs.is_empty() {
        println!("{tool}: {}/{} successful", ok, runs.len());
    }
}

ctx := context.Background()
client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: "http://localhost:3000",
    APIKey:  os.Getenv("DAKERA_API_KEY"),
})
agent := "devops-agent"
importance := map[string]float32{"success": 0.88, "partial": 0.65, "failure": 0.42}

// Record an outcome; the first words of the content name the tool and the outcome
recordOutcome := func(tool, outcome string, latencyMs int64) error {
    imp := importance[outcome]
    _, err := client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
        Content:    fmt.Sprintf("%s tool %s for production_deploy task. Latency: %dms.", tool, outcome, latencyMs),
        Importance: &imp,
        Tags:       []string{"tool:" + tool, "task:production_deploy", "outcome:" + outcome},
    })
    return err
}
recordOutcome("kubectl_deploy", "success", 1900)

// Recall outcomes and compute a success rate per tool from the content
found, err := client.Recall(ctx, agent, dakera.RecallRequest{
    Query: "tool outcomes for production_deploy tasks",
    TopK:  10,
})
if err != nil {
    log.Fatal(err)
}
for _, tool := range []string{"kubectl_deploy", "ansible_run"} {
    total, ok := 0, 0
    for _, m := range found.Memories {
        if strings.HasPrefix(m.Content, tool) {
            total++
            if strings.Contains(m.Content, " tool success ") {
                ok++
            }
        }
    }
    if total > 0 {
        fmt.Printf("%s: %d/%d successful\n", tool, ok, total)
    }
}