Feedback Loop Memory

import re
from dakera import DakeraClient
from typing import Optional

client = DakeraClient(base_url="http://localhost:3000", 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 persistent 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,  # high, so lessons rank above ordinary memories
        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 upvote_lessons(agent_id: str, memory_ids: list[str]) -> None:
    """Reinforce the lessons that shaped a response the user praised."""
    for memory_id in memory_ids:
        # Dakera raises importance by 0.05 plus 5% of its current value (at most 1.0)
        client.feedback_memory(memory_id=memory_id, agent_id=agent_id, signal="upvote")

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

def build_behavioral_constraints(lessons: list) -> str:
    """Build a system prompt section from recalled lessons."""
    if not lessons:
        return ""
    constraint_block = "User behavioral rules (MUST follow):\n"
    for i, lesson in enumerate(lessons, 1):
        # Strip the LESSON: prefix for cleaner prompt injection
        rule = lesson.content.replace("LESSON: ", "").strip()
        constraint_block += f"{i}. {rule}\n"
    return constraint_block

# --- Full writing assistant workflow ---
last_lesson_ids: list[str] = []  # lessons used in the previous response

def process_user_message(agent_id: str, message: str, task_domain: str = "general") -> str:
    global last_lesson_ids

    # 1. Check for feedback signals
    correction = detect_correction(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 use prose paragraphs from now on."

    if detect_positive_feedback(message):
        if last_lesson_ids:
            upvote_lessons(agent_id, last_lesson_ids)
        else:
            store_positive_lesson(agent_id, "the style of the last response", task_domain)
        return "Great, I'll keep doing it this way!"

    # 2. Build constraints from recalled lessons
    lessons = get_lessons_for_domain(agent_id, task_domain)
    last_lesson_ids = [m.id for m in lessons]
    constraints = build_behavioral_constraints(lessons)

    # 3. Inject into system prompt for your LLM call
    # system_prompt = f"{BASE_SYSTEM_PROMPT}\n\n{constraints}"
    # response = llm.complete(system=system_prompt, user=message)

    return f"[Constraints active]\n{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(get_lessons_for_domain(agent, "formatting")))

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

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

const CORRECTION_PATTERNS = [
  /\bdon'?t\b.*\b(use|write|include|add)\b/i,
  /\b(never|stop|avoid|no more)\b.*\b(using|writing|adding)\b/i,
  /\b(always|please)\b.*\binstead\b/i,
  /\bactually,?\b/i,
  /\bi prefer\b/i,
  /\bfrom now on\b/i,
];

const POSITIVE_PATTERNS = [
  /\bexactly (like|right|that)\b/i,
  /\b(perfect|love this|great job)\b/i,
  /\bdo it this way\b/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,
    memory_type: '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,
    memory_type: 'semantic',
    tags: ['type:lesson', `domain:${domain}`, 'feedback:positive'],
  });
}

// Upvote raises importance by 0.05 plus 5% of the current value (at most 1.0)
async function upvoteLessons(agentId: string, memoryIds: string[]): Promise<void> {
  for (const id of memoryIds) {
    await client.feedbackMemory(id, agentId, 'upvote');
  }
}

async function getLessonsForDomain(agentId: string, domain: string) {
  const { memories } = await client.recall(
    agentId,
    `lessons corrections rules for ${domain} writing style`,
    { top_k: 8, min_importance: 0.85, tags: ['type:lesson'] }
  );
  return memories.filter(m => m.content.startsWith('LESSON:'));
}

function buildConstraints(lessons: { content: string }[]): string {
  if (lessons.length === 0) return '';
  return 'User behavioral rules (MUST follow):\n' +
    lessons.map((l, i) => `${i + 1}. ${l.content.replace('LESSON: ', '').trim()}`).join('\n');
}

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

// Later, the user says "exactly like that": reinforce the lessons that were in the prompt
await upvoteLessons('writing-assistant-user-1', lessons.map(l => l.id));

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

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

// Store a lesson from user correction
client.store_memory(
    StoreMemoryRequest::new(
        "writing-assistant-user-1",
        "LESSON: Do NOT use bullet point lists for blog posts. Always use flowing prose paragraphs with clear topic sentences instead.",
    )
    .with_type(MemoryType::Semantic)
    .with_importance(0.94)
    .with_tags(vec!["type:lesson".into(), "domain:formatting".into(), "feedback:negative".into()]),
).await?;

// Recall lessons for the domain before responding
let lessons = client.recall(
    RecallRequest::new("writing-assistant-user-1", "lessons corrections rules for formatting writing style")
        .with_top_k(8)
        .with_min_importance(0.85)
        .with_tags(vec!["type:lesson".into()]),
).await?;

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

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

// Positive feedback: upvote the lessons that shaped the praised response
for m in &rules {
    client.feedback_memory(&m.id, "writing-assistant-user-1", FeedbackSignal::Upvote).await?;
}

client := dakera.NewClientWithOptions(dakera.ClientOptions{
    BaseURL: "http://localhost:3000",
    APIKey:  "dk-...",
})
ctx := context.Background()

// Store a lesson from correction
importance := float32(0.94)
_, err := 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.",
    MemoryType: "semantic",
    Importance: &importance,
    Tags:       []string{"type:lesson", "domain:formatting", "feedback:negative"},
})

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

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

// Positive feedback: upvote the lessons that were in the prompt
for _, id := range usedIDs {
    _, err = client.FeedbackMemory(ctx, id, "writing-assistant-user-1", dakera.FeedbackSignalUpvote)
}