Feedback Loop Memory

import re
from dakera import DakeraClient
from typing import Optional

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

CORRECTION_PATTERNS = [
    r"\bdon'?t\b.*\b(use|write|include|add|put)\b",
    r"\b(never|stop|no more|avoid)\b.*\b(using|writing|adding|including)\b",
    r"\b(please|always)\b.*\binstead\b",
    r"\bactually,?\b",
    r"\bi prefer\b",
    r"\bfrom now on\b",
    r"\bevery time\b",
    r"\balways\b.*\b(use|do|write|format)\b",
]

POSITIVE_PATTERNS = [
    r"\bexactly (like|right|that|what i)\b",
    r"\b(perfect|yes,? that'?s?|love this|great job)\b",
    r"\bdo it this way\b",
    r"\bkeep (doing|it like)\b",
]

DOMAIN_KEYWORDS = {
    "formatting": ["bullet", "list", "header", "section", "paragraph", "bold", "italic", "indent", "table"],
    "language": ["english", "british", "american", "spelling", "grammar", "comma", "apostrophe", "punctuation"],
    "tone": ["formal", "casual", "technical", "friendly", "professional", "warm", "direct", "concise"],
    "code": ["typescript", "python", "javascript", "function", "async", "class", "variable", "comment"],
    "structure": ["introduction", "conclusion", "outline", "summary", "example", "reference", "citation"],
}

def detect_correction(message: str) -> Optional[dict]:
    """Returns correction info if the message contains a correction signal."""
    msg_lower = message.lower()
    for pattern in CORRECTION_PATTERNS:
        if re.search(pattern, msg_lower):
            domain = classify_domain(msg_lower)
            return {"type": "correction", "domain": domain, "message": message}
    return None

def detect_positive_feedback(message: str) -> bool:
    msg_lower = message.lower()
    return any(re.search(p, msg_lower) for p in POSITIVE_PATTERNS)

def classify_domain(message: str) -> str:
    message_lower = message.lower()
    scores = {domain: 0 for domain in DOMAIN_KEYWORDS}
    for domain, keywords in DOMAIN_KEYWORDS.items():
        scores[domain] = sum(1 for kw in keywords if kw in message_lower)
    return max(scores, key=scores.get) if any(scores.values()) else "general"

def store_lesson(agent_id: str, wrong_behavior: str, correct_behavior: str, domain: str) -> None:
    """Store a user correction as a permanent behavioral lesson."""
    content = (
        f"LESSON: Do NOT {wrong_behavior} when writing. "
        f"Always {correct_behavior} instead."
    )
    client.store_memory(
        agent_id=agent_id,
        content=content,
        importance=0.94,  # Very high -- lessons must always surface
        memory_type="semantic",
        tags=["type:lesson", f"domain:{domain}", "feedback:negative"]
    )

def store_positive_lesson(agent_id: str, behavior: str, domain: str) -> None:
    """Store a preferred behavior confirmed by user positive feedback."""
    client.store_memory(
        agent_id=agent_id,
        content=f"LESSON: User confirmed they love this: {behavior}. Always do this.",
        importance=0.91,
        memory_type="semantic",
        tags=["type:lesson", f"domain:{domain}", "feedback:positive"]
    )

def boost_lesson_importance(agent_id: str, memory_id: str) -> None:
    """Increase importance of a lesson the user positively reinforced."""
    client.update_importance(
        agent_id=agent_id,
        memory_id=memory_id,
        importance=0.96
    )

def get_lessons_for_domain(agent_id: str, domain: str) -> list[str]:
    """Recall all lessons relevant to the current domain."""
    result = client.recall(
        agent_id=agent_id,
        query=f"lessons corrections rules for {domain} writing style behavior",
        top_k=8,
        min_importance=0.85
    )
    return [
        mem["content"] for mem in result.get("memories", [])
        if "LESSON:" in mem["content"]
    ]

def build_behavioral_constraints(agent_id: str, task_domain: str) -> str:
    """Build a system prompt section from recalled lessons."""
    lessons = get_lessons_for_domain(agent_id, task_domain)
    if not lessons:
        return ""

    constraint_block = "User behavioral rules (MUST follow):
"
    for i, lesson in enumerate(lessons, 1):
        # Strip the LESSON: prefix for cleaner prompt injection
        rule = lesson.replace("LESSON: ", "").strip()
        constraint_block += f"{i}. {rule}
"
    return constraint_block

# --- Full writing assistant workflow ---
def process_user_message(agent_id: str, message: str, task_domain: str = "general") -> str:
    # 1. Check for feedback signals
    correction = detect_correction(message)
    is_positive = detect_positive_feedback(message)

    if correction:
        # Parse wrong/correct from message (simplified -- use LLM extraction in production)
        store_lesson(agent_id, "use bullet points", "use prose paragraphs", correction["domain"])
        return "Got it — I'll remember to always use prose paragraphs going forward."

    if is_positive:
        # Boost the most recently recalled memory
        # In production: pass the memory_id from the last recall call
        return "Great, I'll keep doing it this way!"

    # 2. Build constraints from recalled lessons
    constraints = build_behavioral_constraints(agent_id, task_domain)

    # 3. Inject into system prompt for your LLM call
    # system_prompt = f"{BASE_SYSTEM_PROMPT}

{constraints}"
    # response = llm.complete(system=system_prompt, user=message)

    return f"[Constraints active]
{constraints}"

# --- Example ---
agent = "writing-assistant-user-1"
store_lesson(agent, "use bullet points in blog articles", "use flowing prose paragraphs with clear topic sentences", "formatting")
store_lesson(agent, "use American English spellings", "use British English (colour, realise, etc.)", "language")
print(build_behavioral_constraints(agent, "formatting"))

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

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

const CORRECTION_PATTERNS = [
  /don'?t.*(use|write|include|add)/i,
  /b(never|stop|avoid|no more).*b(using|writing|adding)/i,
  /b(always|please).*instead/i,
  /actually,?/i,
  /i prefer/i,
  /from now on/i,
];

const POSITIVE_PATTERNS = [
  /exactly (like|right|that)/i,
  /b(perfect|love this|great job)/i,
  /do it this way/i,
];

function detectCorrection(message: string): boolean {
  return CORRECTION_PATTERNS.some(p => p.test(message));
}

function detectPositiveFeedback(message: string): boolean {
  return POSITIVE_PATTERNS.some(p => p.test(message));
}

async function storeLesson(
  agentId: string,
  wrongBehavior: string,
  correctBehavior: string,
  domain: string
): Promise<void> {
  await client.storeMemory(agentId, {
    content: `LESSON: Do NOT ${wrongBehavior}. Always ${correctBehavior} instead.`,
    importance: 0.94,
    memoryType: 'semantic',
    tags: ['type:lesson', `domain:${domain}`, 'feedback:negative'],
  });
}

async function storePositiveLesson(agentId: string, behavior: string, domain: string): Promise<void> {
  await client.storeMemory(agentId, {
    content: `LESSON: User confirmed they prefer: ${behavior}. Always do this.`,
    importance: 0.91,
    memoryType: 'semantic',
    tags: ['type:lesson', `domain:${domain}`, 'feedback:positive'],
  });
}

async function boostLessonImportance(agentId: string, memoryId: string): Promise<void> {
  await client.updateImportance(agentId, { memoryId, importance: 0.96 });
}

async function getConstraintsForDomain(agentId: string, domain: string): Promise<string> {
  const result = await client.recall(
    agentId,
    `lessons corrections rules for ${domain} writing style`,
    { top_k: 8, min_importance: 0.85 }
  );

  const lessons = result.memories
    .filter(m => m.content.startsWith('LESSON:'))
    .map(m => m.content.replace('LESSON: ', '').trim());

  if (lessons.length === 0) return '';

  return 'User behavioral rules (MUST follow):
' +
    lessons.map((l, i) => `${i + 1}. ${l}`).join('
');
}

// Usage
await storeLesson('writing-assistant-user-1', 'use bullet points in blog content', 'use prose paragraphs', 'formatting');
const constraints = await getConstraintsForDomain('writing-assistant-user-1', 'formatting');
console.log(constraints);

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

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

// Store a lesson from user correction
client.store_memory("writing-assistant-user-1", StoreMemoryRequest {
    content: "LESSON: Do NOT use bullet point lists for blog posts. Always use flowing prose paragraphs with clear topic sentences instead.".into(),
    importance: Some(0.94),
    memory_type: "semantic".into(),
    tags: vec!["type:lesson".into(), "domain:formatting".into(), "feedback:negative".into()],
    ..Default::default()
}).await?;

// Recall lessons for domain before responding
let lessons = client.recall("writing-assistant-user-1", RecallRequest {
    query: "lessons corrections rules for formatting writing style".into(),
    top_k: Some(8),
    min_importance: Some(0.85),
    ..Default::default()
}).await?;

// Build constraint block for system prompt
let constraints: String = lessons.memories.iter()
    .filter(|m| m.content.contains("LESSON:"))
    .enumerate()
    .map(|(i, m)| format!("{}. {}", i + 1, m.content.replace("LESSON: ", "")))
    .collect::<Vec<_>>()
    .join("
");

println!("User behavioral rules:
{}", constraints);

// Boost importance after positive feedback
client.forget("writing-assistant-user-1", "mem_abc123").await?; // example: remove outdated lesson

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

// Store a lesson from correction
client.StoreMemory(ctx, "writing-assistant-user-1", dakera.StoreMemoryRequest{
    Content:    "LESSON: Do NOT use bullet points for blog articles. Always use prose paragraphs with clear topic sentences instead.",
    Importance: 0.94,
    MemoryType: "semantic",
    Tags:       []string{"type:lesson", "domain:formatting", "feedback:negative"},
    Metadata: map[string]interface{}{
        "wrong_behavior":   "bullet_points",
        "correct_behavior": "prose_paragraphs",
        "domain":           "formatting",
    },
})

// Recall lessons before responding
lessons, _ := client.Recall(ctx, "writing-assistant-user-1", dakera.RecallRequest{
    Query:         "lessons corrections rules formatting writing style",
    TopK:          8,
    MinImportance: 0.85,
})

// Build constraint block
var constraints []string
for i, mem := range lessons.Memories {
    if strings.HasPrefix(mem.Content, "LESSON:") {
        rule := strings.TrimPrefix(mem.Content, "LESSON: ")
        constraints = append(constraints, fmt.Sprintf("%d. %s", i+1, rule))
    }
}
constraintBlock := "User behavioral rules:
" + strings.Join(constraints, "
")
fmt.Println(constraintBlock)