User Preference Recall

from dakera import DakeraClient
from typing import Optional

client = DakeraClient(base_url="http://localhost:3300", 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 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 store_preference(
    user_id: str,
    preference: str,
    importance: float = 0.9,
    memory_id: Optional[str] = None
) -> dict:
    """Store or update a user preference."""
    tags = detect_preference_category(preference)

    if memory_id:
        # Update existing preference
        return client.update_memory(
            agent_id=f"user-{user_id}-prefs",
            memory_id=memory_id,
            content=preference,
            importance=importance
        )

    return client.store_memory(
        agent_id=f"user-{user_id}-prefs",
        content=preference,
        memory_type="semantic",
        importance=importance,
        tags=tags
    )

# 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)

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

    if not prefs.get("memories"):
        return "You are a helpful assistant."

    pref_lines = "
".join(
        f"- {m['content']}" for m in prefs["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 prefers Python over JavaScript for all backend code
# - User wants concise bullet-point responses, not paragraphs
# - User is senior engineer, skip beginner explanations
# ...

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

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

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;

  if (memoryId) {
    await client.updateMemory(`user-${userId}-prefs`, memoryId, {
      content: preference,
      importance
    });
    return;
  }

  await client.storeMemory(`user-${userId}-prefs`, {
    content: preference,
    memoryType: '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 prefs = await client.recall(`user-${userId}-prefs`, `preferences for: ${taskContext}`, {
    top_k: 6,
    min_importance: 0.8
  });

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

  const prefLines = prefs.memories.map(m => `- ${m.content}`).join('
');
  return `You are a personalized assistant. Known user preferences:
${prefLines}

Always apply these without being asked.`;
}

// Example: fetch language-specific preferences using search
async function getLanguagePrefs(userId: string): Promise<string[]> {
  const results = await client.searchMemories(`user-${userId}-prefs`, 'programming language framework preference', { top_k: 3 });
  return results.memories.map(m => m.content);
}

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

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

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

// Store preferences at high importance
client.store_memory("user-alice-prefs", StoreMemoryRequest {
    content: "User prefers Python over JavaScript for all backend code".into(),
    memory_type: "semantic".into(),
    importance: Some(0.95),
    tags: vec!["preference".into(), "language".into()],
    ..Default::default()
}).await?;

client.store_memory("user-alice-prefs", StoreMemoryRequest {
    content: "User wants concise bullet-point responses, not paragraphs".into(),
    memory_type: "semantic".into(),
    importance: Some(0.90),
    tags: vec!["preference".into(), "format".into()],
    ..Default::default()
}).await?;

client.store_memory("user-alice-prefs", StoreMemoryRequest {
    content: "User is in Pacific timezone (UTC-8), works 9am-6pm PST".into(),
    memory_type: "semantic".into(),
    importance: Some(0.92),
    tags: vec!["preference".into(), "timezone".into()],
    ..Default::default()
}).await?;

// Recall at session start
let prefs = client.recall("user-alice-prefs", RecallRequest {
    query: "coding language style format preferences".into(),
    top_k: Some(5),
    min_importance: Some(0.8),
    ..Default::default()
}).await?;

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

let system_prompt = format!(
    "You are a personalized assistant. Known user preferences:
{}

Apply these at all times.",
    pref_text
);

package main

import (
    "context"
    "fmt"
    "strings"
    "github.com/dakera-ai/dakera-go"
)

func main() {
    client := dakera.NewClient("http://localhost:3300", "dk-...")
    ctx := context.Background()

    // Store preferences at high importance
    prefs := []struct {
        content    string
        importance float64
        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 {
        client.StoreMemory(ctx, "user-alice-prefs", dakera.StoreMemoryRequest{
            Content:    p.content,
            MemoryType: "semantic",
            Importance: p.importance,
            Tags:       p.tags,
        })
    }

    // Recall at session start
    recalled, _ := client.Recall(ctx, "user-alice-prefs", dakera.RecallRequest{
        Query:         "coding language style preferences",
        TopK:          5,
        MinImportance: 0.8,
    })

    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:
%s

Apply these without being asked.",
        strings.Join(lines, "
"),
    )
    _ = systemPrompt
}