RAG-Augmented Memory

import asyncio
from dakera import DakeraClient

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

# -- Step 1: index documents at startup --
def index_document(doc_id: str, chunks: list[str], department: str, version: str):
    """Index a document as a series of memory chunks."""
    for chunk in chunks:
        client.store_memory(
            agent_id=AGENT,
            content=chunk,
            importance=0.82,
            memory_type="semantic",
            tags=["doc", department.lower()],
            metadata={"source": "doc", "doc_id": doc_id, "version": version, "department": department},
            ttl_seconds=90 * 24 * 3600,  # expires after 90 days; re-index before then
        )

index_document("help-sso-setup", [
    "SSO (Single Sign-On) is available on Pro and Enterprise plans only. Starter plan users cannot enable SSO.",
    "To enable SSO, navigate to Settings > Security > Single Sign-On. Upload your IdP metadata XML. Supported IdPs: Okta, Azure AD, Google Workspace, OneLogin.",
    "After uploading IdP metadata, test the SSO flow with a sandbox account before enabling it for your entire organization.",
], "IT", "2024-Q4")

# -- Step 2: store user context on first interaction --
client.store_memory(
    agent_id=AGENT,
    content="Alice Chen is a Systems Administrator on the Pro plan. Prefers step-by-step instructions. Uses Okta as IdP.",
    importance=0.95,
    memory_type="semantic",
    tags=["user-profile", "user:alice"],
)

# -- Step 3: two recalls in parallel --
async def retrieve_context(query: str, user_tag: str):
    mem_task = asyncio.to_thread(client.recall, agent_id=AGENT, query=query,
                                 top_k=4, min_importance=0.7, tags=[user_tag])
    doc_task = asyncio.to_thread(client.recall, agent_id=AGENT, query=query,
                                 top_k=6, min_importance=0.6, tags=["doc"])
    mem, docs = await asyncio.gather(mem_task, doc_task)
    return mem.memories, docs.memories

# -- Step 4: merge, rank and trim to the token budget --
def merge_context(memories, docs, token_budget: int = 2000) -> str:
    """Scores rank results within one recall; across the two recalls the order is
    approximate, so user memories win ties."""
    items = [(m.score, 1, "[USER CONTEXT]", m.content) for m in memories] + \
            [(d.score, 0, "[DOCUMENTATION]", d.content) for d in docs]
    items.sort(reverse=True)
    parts, used = [], 0.0
    for _, _, prefix, content in items:
        tokens = len(content.split()) * 1.3  # rough estimate
        if used + tokens > token_budget:
            break
        parts.append(f"{prefix}\n{content}")
        used += tokens
    return "\n\n".join(parts)

# -- Step 5: crystallize facts the answer relied on --
def same_fact(a: str, b: str) -> bool:
    """Your rule or an LLM call. Recall scores rank results; they are not a similarity cut-off."""
    ...

def crystallize_fact(fact: str, user_tag: str, ttl_days: int = 30):
    known = client.recall(agent_id=AGENT, query=fact, top_k=3)
    if any(same_fact(m.content, fact) for m in known.memories):
        return  # already known
    client.store_memory(
        agent_id=AGENT,
        content=fact,
        importance=0.75,
        memory_type="semantic",
        tags=["learned", "doc-derived", user_tag],
        ttl_seconds=ttl_days * 24 * 3600,
    )

async def answer_question(user_query: str):
    memories, docs = await retrieve_context(user_query, "user:alice")
    context = merge_context(memories, docs)
    system_prompt = f"You are a knowledge base assistant. Use the context below.\n\n{context}"
    answer, cited_ids = call_your_llm(system_prompt, user_query)  # ask the model to cite chunk ids
    # After replying (in the background), crystallize the chunks the answer used
    for doc in docs:
        if doc.id in cited_ids:
            crystallize_fact(doc.content, "user:alice")
    return answer

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

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

// -- Index documentation chunks --
async function indexDocument(docId: string, chunks: string[], tags: string[]) {
  for (const chunk of chunks) {
    await client.storeMemory(AGENT, {
      content: chunk,
      importance: 0.82,
      memory_type: 'semantic',
      tags: ['doc', ...tags],
      metadata: { source: 'doc', doc_id: docId },
      ttl_seconds: 90 * 24 * 3600,
    });
  }
}

await indexDocument('help-sso-setup', [
  'SSO is available on Pro and Enterprise plans. Go to Settings > Security > SSO to enable.',
  'Supported IdPs: Okta, Azure AD, Google Workspace, OneLogin. Upload your IdP metadata XML.',
], ['it', 'sso', 'security']);

// -- Store user profile --
await client.storeMemory(AGENT, {
  content: 'Alice Chen is a Systems Administrator on Pro plan. Uses Okta IdP. Prefers step-by-step instructions.',
  importance: 0.95,
  memory_type: 'semantic',
  tags: ['user-profile', 'user:alice'],
});

// -- Two recalls in parallel --
async function retrieveContext(query: string, userTag: string) {
  const [mem, docs] = await Promise.all([
    client.recall(AGENT, query, { top_k: 4, min_importance: 0.7, tags: [userTag] }),
    client.recall(AGENT, query, { top_k: 6, min_importance: 0.6, tags: ['doc'] }),
  ]);
  return { memories: mem.memories, docs: docs.memories };
}

// -- Merge: scores rank within one recall, so user memories win ties --
function mergeContext(memories: any[], docs: any[], tokenBudget = 2000): string {
  const items = [
    ...memories.map(m => ({ ...m, prefix: '[USER CONTEXT]', tie: 1 })),
    ...docs.map(d => ({ ...d, prefix: '[DOCUMENTATION]', tie: 0 })),
  ].sort((a, b) => b.score - a.score || b.tie - a.tie);
  const parts: string[] = [];
  let tokens = 0;
  for (const item of items) {
    const est = item.content.split(' ').length * 1.3;
    if (tokens + est > tokenBudget) break;
    parts.push(`${item.prefix}\n${item.content}`);
    tokens += est;
  }
  return parts.join('\n\n');
}

// -- Crystallize a fact unless your check finds it already known --
declare function sameFact(a: string, b: string): Promise<boolean>; // your rule or an LLM call

async function crystallizeFact(fact: string, userTag: string) {
  const { memories } = await client.recall(AGENT, fact, { top_k: 3 });
  for (const m of memories) if (await sameFact(m.content, fact)) return;
  await client.storeMemory(AGENT, {
    content: fact,
    importance: 0.75,
    memory_type: 'semantic',
    tags: ['learned', 'doc-derived', userTag],
    ttl_seconds: 30 * 24 * 3600,
  });
}

// -- Full pipeline --
async function answerQuestion(userQuery: string) {
  const { memories, docs } = await retrieveContext(userQuery, 'user:alice');
  const context = mergeContext(memories, docs);
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    system: `You are a knowledge base assistant. Use the context below.\n\n${context}`,
    messages: [{ role: 'user', content: userQuery }],
  });
  const answer = response.content[0].type === 'text' ? response.content[0].text : '';
  // After replying (in the background), crystallize the chunks the answer used
  for (const doc of docs.filter(d => answer.includes(d.content))) {
    void crystallizeFact(doc.content, 'user:alice');
  }
  return answer;
}

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

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

// Index a document chunk and the user's profile in the same agent
client.store_memory(
    StoreMemoryRequest::new(agent, "SSO is available on Pro and Enterprise plans. Settings > Security > SSO.")
        .with_importance(0.82)
        .with_tags(vec!["doc".into(), "sso".into()]),
).await?;
client.store_memory(
    StoreMemoryRequest::new(agent, "Alice is a sysadmin on Pro plan, uses Okta, prefers step-by-step guides.")
        .with_importance(0.95)
        .with_tags(vec!["user-profile".into(), "user:alice".into()]),
).await?;

// One recall without a tag filter ranks memories and doc chunks together
// (for the two-path version with tag filters, see the REST or Python tab)
let found = client.recall(RecallRequest::new(agent, "How do I enable SSO?").with_top_k(8)).await?;

let mut context = String::new();
for m in &found.memories {
    context.push_str(&format!("{}\n\n", m.content));
}
println!("Context for LLM:\n{}", context);

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

docImp, userImp := float32(0.82), float32(0.95)

// Index a documentation chunk and the user's profile in the same agent
client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
    Content:    "SSO available on Pro and Enterprise. Settings > Security > SSO. Upload IdP metadata XML.",
    Importance: &docImp,
    Tags:       []string{"doc", "sso"},
})
client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
    Content:    "Alice Chen: sysadmin, Pro plan, Okta IdP, prefers step-by-step instructions.",
    Importance: &userImp,
    Tags:       []string{"user-profile", "user:alice"},
})

// One recall without a tag filter ranks memories and doc chunks together
// (for the two-path version with tag filters, see the REST or Python tab)
found, err := client.Recall(ctx, agent, dakera.RecallRequest{Query: "How do I enable SSO?", TopK: 8})
if err != nil {
    log.Fatal(err)
}
contextStr := ""
for _, m := range found.Memories {
    contextStr += m.Content + "\n\n"
}
fmt.Println("Context for LLM:", contextStr)