User Preference Recall

from dakera import DakeraClient
from typing import Optional

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

PREF_CATEGORIES = {
    "language": ["python", "javascript", "typescript", "rust", "go", "ruby"],
    "format": ["bullet", "concise", "verbose", "markdown", "code block"],
    "timezone": ["utc", "pst", "est", "gmt", "cet"],
    "communication": ["formal", "casual", "brief", "detailed"],
}

def detect_preference_category(content: str) -> list[str]:
    """Simple heuristic: replace with an LLM classifier in production."""
    tags = ["preference"]
    content_lower = content.lower()
    for cat, keywords in PREF_CATEGORIES.items():
        if any(kw in content_lower for kw in keywords):
            tags.append(cat)
    return tags

def find_preference_id(user_id: str, category: str, query: str) -> Optional[str]:
    """Find the stored preference in one category, to update it in place."""
    response = client.recall(agent_id=f"user-{user_id}-prefs", query=query,
                             top_k=1, tags=[category])
    return response.memories[0].id if response.memories else None

def store_preference(
    user_id: str,
    preference: str,
    importance: float = 0.9,
    memory_id: Optional[str] = None
) -> str:
    """Store a new preference, or update an existing one. Returns the memory ID."""
    agent_id = f"user-{user_id}-prefs"

    if memory_id:
        # Overwrite the old value, then set its importance
        client.update_memory(agent_id=agent_id, memory_id=memory_id, content=preference)
        client.update_importance(agent_id=agent_id, memory_ids=[memory_id], importance=importance)
        return memory_id

    stored = client.store_memory(
        agent_id=agent_id,
        content=preference,
        memory_type="semantic",
        importance=importance,
        tags=detect_preference_category(preference)
    )
    return stored["id"]

# Seed Alice's preferences on first interaction
store_preference("alice", "User prefers Python over JavaScript for all backend code", 0.95)
store_preference("alice", "User wants concise bullet-point responses, not paragraphs", 0.9)
store_preference("alice", "User works in Pacific timezone (UTC-8), 9am-6pm PST", 0.92)
store_preference("alice", "User is senior engineer, skip beginner explanations", 0.88)
store_preference("alice", "User prefers async/await patterns over callbacks", 0.87)

# Later: Alice switches languages, so update the record instead of adding a second one
old_id = find_preference_id("alice", "language", "preferred backend language")
store_preference("alice", "User switched from Python to TypeScript for new projects", 0.95, old_id)

def build_system_prompt(user_id: str, task_context: str) -> str:
    """Build a personalized system prompt from stored preferences."""
    response = client.recall(
        agent_id=f"user-{user_id}-prefs",
        query=f"preferences relevant to: {task_context}",
        top_k=8,
        min_importance=0.8
    )

    if not response.memories:
        return "You are a helpful assistant."

    pref_lines = "\n".join(f"- {m.content}" for m in response.memories)
    return f"""You are a personalized assistant. Apply these known user preferences:
{pref_lines}

Always follow these preferences without being asked."""

# Use at the start of every session
system = build_system_prompt("alice", "writing Python API code")
print(system)
# Output:
# You are a personalized assistant. Apply these known user preferences:
# - User switched from Python to TypeScript for new projects
# - User wants concise bullet-point responses, not paragraphs
# - User is senior engineer, skip beginner explanations
# ...

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

const BASE_URL = 'http://localhost:3000';
const API_KEY = process.env.DAKERA_API_KEY!;
const client = new DakeraClient({ baseUrl: BASE_URL, apiKey: API_KEY });

interface PreferenceOptions {
  importance?: number;
  tags?: string[];
  memoryId?: string;
}

async function storePreference(
  userId: string,
  preference: string,
  options: PreferenceOptions = {}
): Promise<void> {
  const { importance = 0.9, tags = ['preference'], memoryId } = options;
  const agentId = `user-${userId}-prefs`;

  if (memoryId) {
    // PUT /v1/memory/update/{id} changes content, importance and tags in one call
    const res = await fetch(`${BASE_URL}/v1/memory/update/${memoryId}`, {
      method: 'PUT',
      headers: { Authorization: `Bearer ${API_KEY}`, 'Content-Type': 'application/json' },
      body: JSON.stringify({ agent_id: agentId, content: preference, importance, tags }),
    });
    if (!res.ok) throw new Error(`update failed: ${res.status}`);
    return;
  }

  await client.storeMemory(agentId, {
    content: preference,
    memory_type: 'semantic',
    importance,
    tags
  });
}

// Seed preferences
await storePreference('alice', 'User prefers Python for backend, TypeScript for frontend', {
  importance: 0.95,
  tags: ['preference', 'language']
});
await storePreference('alice', 'User wants concise bullet-point responses', {
  importance: 0.90,
  tags: ['preference', 'format']
});
await storePreference('alice', 'User is in Pacific timezone (UTC-8)', {
  importance: 0.92,
  tags: ['preference', 'timezone']
});
await storePreference('alice', 'User is senior engineer, skip beginner explanations', {
  importance: 0.88,
  tags: ['preference', 'communication']
});

// Build personalized system prompt at session start
async function buildSystemPrompt(userId: string, taskContext: string): Promise<string> {
  const { memories } = await client.recall(`user-${userId}-prefs`, `preferences for: ${taskContext}`, {
    top_k: 8,
    min_importance: 0.8
  });

  if (!memories.length) return 'You are a helpful assistant.';

  const prefLines = memories.map(m => `- ${m.content}`).join('\n');
  return `You are a personalized assistant. Known user preferences:\n${prefLines}\n\nAlways apply these without being asked.`;
}

// Example: fetch only language preferences with a tag-filtered recall
async function getLanguagePrefs(userId: string): Promise<string[]> {
  const { memories } = await client.recall(`user-${userId}-prefs`, 'programming language framework preference', {
    top_k: 3,
    tags: ['language']
  });
  return memories.map(m => m.content);
}

const system = await buildSystemPrompt('alice', 'writing REST API code');

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

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

// Store preferences at the stated tier (0.9 to 1.0)
let prefs = [
    ("User prefers Python over JavaScript for all backend code", 0.95, "language"),
    ("User wants concise bullet-point responses, not paragraphs", 0.90, "format"),
    ("User is in Pacific timezone (UTC-8), works 9am-6pm PST", 0.92, "timezone"),
];
for (content, importance, category) in prefs {
    client.store_memory(
        StoreMemoryRequest::new("user-alice-prefs", content)
            .with_importance(importance)
            .with_tags(vec!["preference".into(), category.into()]),
    ).await?;
}

// Recall at session start. The Rust docs show no min_importance builder;
// send min_importance over REST if you need the 0.8 floor here.
let prefs = client.recall(
    RecallRequest::new("user-alice-prefs", "coding language style format preferences").with_top_k(8),
).await?;

// Build system prompt from recalled preferences
let pref_text = prefs.memories
    .iter()
    .map(|m| format!("- {}", m.content))
    .collect::<Vec<_>>()
    .join("\n");

let system_prompt = format!(
    "You are a personalized assistant. Known user preferences:\n{}\n\nApply these at all times.",
    pref_text
);

package main

import (
    "context"
    "fmt"
    "log"
    "os"
    "strings"

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

func main() {
    client := dakera.NewClientWithOptions(dakera.ClientOptions{
        BaseURL: "http://localhost:3000",
        APIKey:  os.Getenv("DAKERA_API_KEY"),
    })
    ctx := context.Background()

    // Store preferences by confidence tier
    prefs := []struct {
        content    string
        importance float32
        tags       []string
    }{
        {"User prefers Python for backend, TypeScript for frontend", 0.95, []string{"preference", "language"}},
        {"User wants concise bullet-point responses", 0.90, []string{"preference", "format"}},
        {"User is in Pacific timezone (UTC-8)", 0.92, []string{"preference", "timezone"}},
        {"User is senior engineer, skip beginner explanations", 0.88, []string{"preference", "communication"}},
    }

    for _, p := range prefs {
        imp := p.importance
        if _, err := client.StoreMemory(ctx, "user-alice-prefs", dakera.StoreMemoryRequest{
            Content:    p.content,
            Importance: &imp,
            Tags:       p.tags,
        }); err != nil {
            log.Fatal(err)
        }
    }

    // Recall at session start. The Go docs show no MinImportance field;
    // send min_importance over REST if you need the 0.8 floor here.
    recalled, err := client.Recall(ctx, "user-alice-prefs", dakera.RecallRequest{
        Query: "coding language style preferences",
        TopK:  8,
    })
    if err != nil {
        log.Fatal(err)
    }

    lines := make([]string, 0, len(recalled.Memories))
    for _, m := range recalled.Memories {
        lines = append(lines, "- "+m.Content)
    }

    systemPrompt := fmt.Sprintf(
        "You are a personalized assistant. Known preferences:\n%s\n\nApply these without being asked.",
        strings.Join(lines, "\n"),
    )
    _ = systemPrompt
}