Tool Usage Learning

import time
from dakera import DakeraClient
from typing import Optional

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

def record_tool_outcome(
    agent_id: str,
    tool: str,
    task_type: str,
    outcome: str,      # "success" | "failure" | "partial"
    notes: str,
    latency_ms: int,
    error: Optional[str] = None
) -> None:
    """Persist a tool invocation outcome for future learning."""
    # Success = high importance, failure = low (still recalled as negative signal)
    importance_map = {"success": 0.88, "partial": 0.65, "failure": 0.42}
    importance = importance_map.get(outcome, 0.6)

    content = (
        f"{tool} tool {outcome} for {task_type} task. "
        f"{notes}. Latency: {latency_ms}ms."
    )
    if error:
        content += f" Error: {error}."

    client.store_memory(
        agent_id=agent_id,
        content=content,
        importance=importance,
        memory_type="semantic",
        tags=[f"tool:{tool}", f"task:{task_type}", f"outcome:{outcome}"],
        ttl_seconds=2_592_000  # 30 days -- stale patterns decay naturally
    )

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."""
    memories = client.recall(
        agent_id=agent_id,
        query=f"tool outcomes for {task_type} tasks",
        top_k=10,
        min_importance=0.3
    )

    # Aggregate success rates per tool
    tool_stats: dict[str, dict] = {t: {"successes": 0, "total": 0, "total_latency": 0} for t in available_tools}

    for mem in memories.get("memories", []):
        content = mem["content"]
        meta = mem.get("metadata", {})
        tool_name = meta.get("tool")
        if tool_name not in tool_stats:
            continue
        tool_stats[tool_name]["total"] += 1
        if meta.get("outcome") == "success":
            tool_stats[tool_name]["successes"] += 1
        tool_stats[tool_name]["total_latency"] += meta.get("latency_ms", 5000)

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

    return best_tool

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

def deploy_to_production(service: str, version: str) -> dict:
    """Deploy a service using the historically most effective tool."""
    best = get_best_tool("devops-agent", "production_deploy", TOOLS)
    print(f"Using {best} based on historical success rate")

    start = time.time()
    try:
        # result = execute_tool(best, service=service, version=version)
        result = {"status": "success", "deployed": f"{service}:{version}"}
        latency_ms = int((time.time() - start) * 1000)

        record_tool_outcome(
            "devops-agent", best, "production_deploy",
            "success",
            f"Deployed {service} v{version} to production cluster",
            latency_ms
        )
        return result
    except Exception as e:
        latency_ms = int((time.time() - start) * 1000)
        record_tool_outcome(
            "devops-agent", best, "production_deploy",
            "failure",
            f"Failed to deploy {service} v{version}",
            latency_ms,
            error=str(e)
        )
        raise

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

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

type Outcome = 'success' | 'failure' | 'partial';

interface ToolOutcome {
  tool: string;
  taskType: string;
  outcome: Outcome;
  notes: string;
  latencyMs: number;
  error?: string;
}

async function recordToolOutcome(agentId: string, o: ToolOutcome): Promise<void> {
  const importanceMap: Record<Outcome, number> = {
    success: 0.88,
    partial: 0.65,
    failure: 0.42,
  };

  const content = [
    `${o.tool} tool ${o.outcome} for ${o.taskType} task.`,
    o.notes,
    `Latency: ${o.latencyMs}ms.`,
    o.error ? `Error: ${o.error}.` : '',
  ].filter(Boolean).join(' ');

  await client.storeMemory(agentId, {
    content,
    importance: importanceMap[o.outcome],
    memoryType: 'semantic',
    tags: [`tool:${o.tool}`, `task:${o.taskType}`, `outcome:${o.outcome}`],
    ttl_seconds: 2_592_000, // 30 days
  });
}

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

  const stats: Record<string, { successes: number; total: number; totalLatency: number }> = {};
  for (const tool of availableTools) {
    stats[tool] = { successes: 0, total: 0, totalLatency: 0 };
  }

  for (const mem of result.memories) {
    const tool = mem.metadata?.tool as string;
    if (!stats[tool]) continue;
    stats[tool].total++;
    if (mem.metadata?.outcome === 'success') stats[tool].successes++;
    stats[tool].totalLatency += (mem.metadata?.latency_ms as number) ?? 5000;
  }

  let bestTool = availableTools[0];
  let bestScore = -1;

  for (const [tool, s] of Object.entries(stats)) {
    if (s.total === 0) continue;
    const successRate = s.successes / s.total;
    const speedScore = Math.max(0, 1 - s.totalLatency / s.total / 60_000);
    const score = successRate * 0.7 + speedScore * 0.3;
    if (score > bestScore) { bestScore = score; bestTool = tool; }
  }

  return bestTool;
}

// --- Usage ---
const tools = ['kubectl_deploy', 'ansible_run', 'terraform_apply'];

async function deployToProduction(service: string, version: string) {
  const best = await getBestTool('devops-agent', 'production_deploy', tools);
  console.log(`Using ${best} (highest historical success rate)`);

  const start = Date.now();
  try {
    // const result = await executeTool(best, { service, version });
    const latencyMs = Date.now() - start;
    await recordToolOutcome('devops-agent', {
      tool: best,
      taskType: 'production_deploy',
      outcome: 'success',
      notes: `Deployed ${service} v${version} to production`,
      latencyMs,
    });
  } catch (err) {
    const latencyMs = Date.now() - start;
    await recordToolOutcome('devops-agent', {
      tool: best,
      taskType: 'production_deploy',
      outcome: 'failure',
      notes: `Failed to deploy ${service} v${version}`,
      latencyMs,
      error: String(err),
    });
    throw err;
  }
}

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest};
use std::collections::HashMap;
use std::time::Instant;

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

async fn record_tool_outcome(
    client: &Client,
    agent_id: &str,
    tool: &str,
    task_type: &str,
    outcome: &str,
    notes: &str,
    latency_ms: u64,
) -> anyhow::Result<()> {
    let importance = match outcome {
        "success" => 0.88,
        "partial" => 0.65,
        _ => 0.42,
    };

    let content = format!(
        "{} tool {} for {} task. {}. Latency: {}ms.",
        tool, outcome, task_type, notes, latency_ms
    );

    client.store_memory(agent_id, StoreMemoryRequest {
        content,
        importance: Some(importance),
        memory_type: "semantic".into(),
        tags: vec![
            format!("tool:{}", tool),
            format!("task:{}", task_type),
            format!("outcome:{}", outcome),
        ],
        ttl_seconds: Some(2_592_000),
        ..Default::default()
    }).await?;

    Ok(())
}

// Recall and score tools before selection
let memories = client.recall("devops-agent", RecallRequest {
    query: "tool outcomes for production deployment tasks".into(),
    top_k: Some(10),
    min_importance: Some(0.3),
    ..Default::default()
}).await?;

// Aggregate per-tool statistics
let mut tool_stats: HashMap<String, (u32, u32, u64)> = HashMap::new(); // (successes, total, total_latency_ms)
for mem in &memories.memories {
    if let Some(meta) = &mem.metadata {
        let tool = meta.get("tool").and_then(|v| v.as_str()).unwrap_or("unknown");
        let outcome = meta.get("outcome").and_then(|v| v.as_str()).unwrap_or("");
        let latency = meta.get("latency_ms").and_then(|v| v.as_u64()).unwrap_or(5000);
        let entry = tool_stats.entry(tool.to_string()).or_insert((0, 0, 0));
        entry.1 += 1;
        entry.2 += latency;
        if outcome == "success" { entry.0 += 1; }
    }
}

// Choose best tool by composite score
let best_tool = tool_stats.iter()
    .filter(|(_, (_, total, _))| *total > 0)
    .map(|(tool, (successes, total, total_latency))| {
        let success_rate = *successes as f64 / *total as f64;
        let avg_latency = *total_latency as f64 / *total as f64;
        let speed_score = (1.0 - avg_latency / 60_000.0).max(0.0);
        let score = success_rate * 0.7 + speed_score * 0.3;
        (tool, score)
    })
    .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
    .map(|(tool, _)| tool.as_str())
    .unwrap_or("kubectl_deploy");

println!("Selecting {} based on historical outcomes", best_tool);

package main

import (
    "context"
    "fmt"
    "time"

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

func recordToolOutcome(ctx context.Context, client *dakera.Client, agentID, tool, taskType, outcome, notes string, latencyMs int64) error {
    importanceMap := map[string]float64{
        "success": 0.88,
        "partial": 0.65,
        "failure": 0.42,
    }
    importance, ok := importanceMap[outcome]
    if !ok {
        importance = 0.5
    }

    content := fmt.Sprintf("%s tool %s for %s task. %s. Latency: %dms.", tool, outcome, taskType, notes, latencyMs)

    _, err := client.StoreMemory(ctx, agentID, dakera.StoreMemoryRequest{
        Content:    content,
        Importance: importance,
        MemoryType: "semantic",
        Tags:       []string{fmt.Sprintf("tool:%s", tool), fmt.Sprintf("task:%s", taskType), fmt.Sprintf("outcome:%s", outcome)},
        TTLSeconds: 2_592_000,
        Metadata: map[string]interface{}{
            "tool":       tool,
            "task_type":  taskType,
            "outcome":    outcome,
            "latency_ms": latencyMs,
        },
    })
    return err
}

func getBestTool(ctx context.Context, client *dakera.Client, agentID, taskType string, tools []string) string {
    result, _ := client.Recall(ctx, agentID, dakera.RecallRequest{
        Query: fmt.Sprintf("tool outcomes for %s tasks", taskType),
        TopK:  10,
    })

    type stats struct{ successes, total int; totalLatency int64 }
    toolStats := map[string]*stats{}
    for _, t := range tools {
        toolStats[t] = &stats{}
    }

    for _, mem := range result.Memories {
        tool, _ := mem.Metadata["tool"].(string)
        if _, ok := toolStats[tool]; !ok {
            continue
        }
        toolStats[tool].total++
        if outcome, _ := mem.Metadata["outcome"].(string); outcome == "success" {
            toolStats[tool].successes++
        }
        if lat, ok := mem.Metadata["latency_ms"].(float64); ok {
            toolStats[tool].totalLatency += int64(lat)
        }
    }

    best, bestScore := tools[0], -1.0
    for tool, s := range toolStats {
        if s.total == 0 { continue }
        successRate := float64(s.successes) / float64(s.total)
        avgLatency := float64(s.totalLatency) / float64(s.total)
        speedScore := max(0, 1-avgLatency/60_000)
        score := successRate*0.7 + speedScore*0.3
        if score > bestScore { bestScore = score; best = tool }
    }
    return best
}

func max(a, b float64) float64 {
    if a > b { return a }
    return b
}