RAG-Augmented Memory

import asyncio
from dakera import DakeraClient

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

# ── 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 i, chunk in enumerate(chunks):
        client.store_memory(
            agent_id="kb-assistant",
            content=chunk,
            importance=0.82,
            memory_type="semantic",
            tags=["doc", department.lower()],
            # TTL: auto-expire doc chunks after 90 days, force re-index on update
            ttl_seconds=90 * 24 * 3600
        )

# Index your SSO documentation
sso_chunks = [
    "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 for your entire organization. SSO enforcement will lock out users without IdP accounts.",
]
index_document("help-sso-setup", sso_chunks, "IT", "2024-Q4")

# ── Step 2: Store user preferences on first interaction ─────────────────────

client.store_memory(
    agent_id="kb-assistant",
    content="Alice Chen is a Systems Administrator on the Pro plan. Prefers step-by-step instructions. Has SAML experience. Uses Okta as IdP.",
    importance=0.95,
    memory_type="semantic",
    tags=["user-profile", "user:alice"]
)

# ── Step 3: Parallel retrieval on each query ────────────────────────────────

async def retrieve_context(query: str, user_tag: str) -> dict:
    """Run memory recall and doc recall in parallel."""
    # Both calls to the same Dakera instance; run concurrently
    mem_task = asyncio.to_thread(
        client.recall,
        agent_id="kb-assistant",
        query=query,
        top_k=4,
        min_importance=0.7,
        tags=[user_tag]  # user-specific memories only
    )
    doc_task = asyncio.to_thread(
        client.recall,
        agent_id="kb-assistant",
        query=query,
        top_k=6,
        min_importance=0.6,
        tags=["doc"]  # documentation chunks only
    )
    mem_results, doc_results = await asyncio.gather(mem_task, doc_task)
    return {"memories": mem_results["memories"], "docs": doc_results["memories"]}

# ── Step 4: Merge and rank results ──────────────────────────────────────────

def merge_context(memories: list, docs: list, token_budget: int = 2000) -> str:
    """Merge memory + doc results, rank by score, trim to token budget."""
    # Tag source for the LLM
    tagged = [
        {"content": m["content"], "score": m["score"], "source": "memory"}
        for m in memories
    ] + [
        {"content": d["content"], "score": d["score"], "source": "doc"}
        for d in docs
    ]
    # Sort by score descending; user memories win ties (memory source sorted first)
    tagged.sort(key=lambda x: (x["score"], x["source"] == "memory"), reverse=True)

    context_parts = []
    token_count = 0
    for item in tagged:
        tokens = len(item["content"].split()) * 1.3  # rough estimate
        if token_count + tokens > token_budget:
            break
        prefix = "[USER CONTEXT]" if item["source"] == "memory" else "[DOCUMENTATION]"
        context_parts.append(f"{prefix}
{item['content']}")
        token_count += tokens

    return "

".join(context_parts)

# ── Step 5: Crystallize learned facts back to memory ────────────────────────

def crystallize_fact(agent_id: str, fact: str, user_tag: str, ttl_days: int = 30):
    """Store a learned fact from RAG results into persistent memory."""
    # Check for near-duplicate first
    existing = client.search_memories(agent_id=agent_id, query=fact)
    if existing["memories"] and existing["memories"][0]["score"] > 0.85:
        return  # Already known — skip

    client.store_memory(
        agent_id=agent_id,
        content=fact,
        importance=0.75,
        memory_type="semantic",
        tags=["learned", "doc-derived", user_tag],
        ttl_seconds=ttl_days * 24 * 3600
    )

# Example usage
async def answer_question(user_query: str):
    context_data = await retrieve_context(user_query, "user:alice")
    context_str = merge_context(context_data["memories"], context_data["docs"])

    # Build system prompt with merged context
    system_prompt = f"""You are a knowledge base assistant.
Use the context below to answer accurately and personally.

{context_str}"""

    # ... call your LLM here ...
    # After response, crystallize high-value facts:
    for doc in context_data["docs"]:
        if doc["score"] > 0.90:  # High-confidence relevant doc chunk
            crystallize_fact("kb-assistant", doc["content"], "user:alice")

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

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

// ── Index documentation chunks ──────────────────────────────────────────────

async function indexDocument(docId: string, chunks: string[], tags: string[]) {
  await Promise.all(chunks.map((chunk, i) =>
    client.storeMemory('kb-assistant', {
      content: chunk,
      importance: 0.82,
      memoryType: 'semantic',
      tags: ['doc', ...tags],
      ttl_seconds: 90 * 24 * 3600,
    })
  ));
}

// Index SSO docs
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.',
  'Test with a sandbox account before enforcing SSO organization-wide to avoid lockouts.',
], ['it', 'sso', 'security']);

// ── Store user profile ──────────────────────────────────────────────────────

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

// ── Parallel retrieval ──────────────────────────────────────────────────────

async function retrieveContext(query: string, userTag: string) {
  const [memResults, docResults] = await Promise.all([
    client.recall('kb-assistant', query, { top_k: 4, min_importance: 0.7, memory_type: 'semantic' }),
    client.recall('kb-assistant', query, { top_k: 6, min_importance: 0.6, memory_type: 'semantic' }),
  ]);

  return {
    memories: memResults.memories.filter((m: any) => m.tags?.includes(userTag)),
    docs: docResults.memories.filter((m: any) => m.tags?.includes('doc')),
  };
}

// ── Merge results ───────────────────────────────────────────────────────────

function mergeContext(
  memories: any[],
  docs: any[],
  tokenBudget = 2000
): string {
  const tagged = [
    ...memories.map(m => ({ ...m, source: 'memory' as const })),
    ...docs.map(d => ({ ...d, source: 'doc' as const })),
  ].sort((a, b) => b.score - a.score);

  const parts: string[] = [];
  let tokens = 0;
  for (const item of tagged) {
    const est = item.content.split(' ').length * 1.3;
    if (tokens + est > tokenBudget) break;
    const prefix = item.source === 'memory' ? '[USER CONTEXT]' : '[DOCUMENTATION]';
    parts.push(`${prefix}
${item.content}`);
    tokens += est;
  }
  return parts.join('

');
}

// ── Crystallize facts ───────────────────────────────────────────────────────

async function crystallizeFact(fact: string, userTag: string) {
  const existing = await client.searchMemories('kb-assistant', fact, { top_k: 1 });
  if (existing.memories[0]?.score > 0.85) return; // Already known

  await client.storeMemory('kb-assistant', {
    content: fact,
    importance: 0.75,
    memoryType: '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.

${context}`,
    messages: [{ role: 'user', content: userQuery }],
  });

  // Crystallize highly relevant doc chunks for faster future recall
  for (const doc of docs.filter((d: any) => d.score > 0.90)) {
    await crystallizeFact(doc.content, 'user:alice');
  }

  return response.content[0].type === 'text' ? response.content[0].text : '';
}

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

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

// Index document chunks
client.store_memory("kb-assistant", StoreMemoryRequest {
    content: "SSO is available on Pro and Enterprise plans. Settings > Security > SSO.".into(),
    importance: Some(0.82),
    memory_type: Some("semantic".into()),
    tags: Some(vec!["doc".into(), "sso".into()]),
    ttl_seconds: Some(90 * 24 * 3600),
    ..Default::default()
}).await?;

// Store user context
client.store_memory("kb-assistant", StoreMemoryRequest {
    content: "Alice is a sysadmin on Pro plan, uses Okta, prefers step-by-step guides.".into(),
    importance: Some(0.95),
    memory_type: Some("semantic".into()),
    tags: Some(vec!["user-profile".into(), "user:alice".into()]),
    ..Default::default()
}).await?;

// Parallel recall: user memories + doc chunks
let query = "How do I enable SSO?";
let (mem_results, doc_results) = join!(
    client.recall("kb-assistant", RecallRequest {
        query: query.into(),
        top_k: Some(4),
        min_importance: Some(0.7),
        ..Default::default()
    }),
    client.recall("kb-assistant", RecallRequest {
        query: query.into(),
        top_k: Some(6),
        min_importance: Some(0.6),
        ..Default::default()
    })
);

let (mem, docs) = (mem_results?, doc_results?);

// Build context string
let mut context = String::new();
for m in &mem.memories {
    context.push_str(&format!("[USER CONTEXT]
{}

", m.content));
}
for d in &docs.memories {
    context.push_str(&format!("[DOCUMENTATION]
{}

", d.content));
}

println!("Context for LLM:
{}", context);

package main

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

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

    // Index documentation chunk
    client.StoreMemory(ctx, "kb-assistant", dakera.StoreMemoryRequest{
        Content:    "SSO available on Pro and Enterprise. Settings > Security > SSO. Upload IdP metadata XML.",
        Importance: 0.82,
        MemoryType: "semantic",
        Tags:       []string{"doc", "sso"},
        TTLSeconds: 90 * 24 * 3600,
    })

    // Store user profile
    client.StoreMemory(ctx, "kb-assistant", dakera.StoreMemoryRequest{
        Content:    "Alice Chen: sysadmin, Pro plan, Okta IdP, prefers step-by-step instructions.",
        Importance: 0.95,
        MemoryType: "semantic",
        Tags:       []string{"user-profile", "user:alice"},
    })

    // Parallel retrieval
    var (
        memResults *dakera.RecallResponse
        docResults *dakera.RecallResponse
        wg         sync.WaitGroup
    )
    query := "How do I enable SSO?"

    wg.Add(2)
    go func() {
        defer wg.Done()
        memResults, _ = client.Recall(ctx, "kb-assistant", dakera.RecallRequest{
            Query:         query,
            TopK:          4,
            MinImportance: 0.7,
        })
    }()
    go func() {
        defer wg.Done()
        docResults, _ = client.Recall(ctx, "kb-assistant", dakera.RecallRequest{
            Query:         query,
            TopK:          6,
            MinImportance: 0.6,
        })
    }()
    wg.Wait()

    // Build merged context
    contextStr := ""
    for _, m := range memResults.Memories {
        contextStr += fmt.Sprintf("[USER CONTEXT]
%s

", m.Content)
    }
    for _, d := range docResults.Memories {
        contextStr += fmt.Sprintf("[DOCUMENTATION]
%s

", d.Content)
    }
    fmt.Println("Merged context:", contextStr)
}