Cross-Session Context

from dakera import DakeraClient

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

class CrossSessionAgent:
    def __init__(self, customer_id: str):
        self.agent_id = f"support-customer-{customer_id}"

    def start_session(self, user_message: str) -> str:
        """Recall prior context and build system prompt."""
        prior = client.recall(
            agent_id=self.agent_id,
            query=f"project progress, open tasks, decisions, constraints: {user_message}",
            top_k=8,
            min_importance=0.72
        )
        if not prior.get("memories"):
            return "You are a helpful support agent. First conversation with this customer."

        ctx_lines = "
".join(f"- {m['content']}" for m in prior["memories"])
        return (
            "You are a support agent with memory of prior sessions.

"
            f"PRIOR SESSION CONTEXT:
{ctx_lines}

"
            "Continue from where we left off. Do not ask the user to repeat themselves."
        )

    def end_session(self, outcomes: list) -> None:
        """Store distilled session outcomes for future recall."""
        for o in outcomes:
            client.store_memory(
                agent_id=self.agent_id,
                content=o["content"],
                memory_type="episodic",
                importance=o.get("importance", 0.80),
                tags=o.get("tags", ["session-context"])
            )

    def get_session_list(self) -> list:
        """List all sessions for this agent."""
        return client.list_sessions()

# --- SESSION 1 (Monday) ---
agent = CrossSessionAgent("9182")
print(agent.start_session("help with FastAPI"))
# Output: first-conversation message

# ... LLM conversation happens ...

agent.end_session([
    {"content": "Customer runs FastAPI + PostgreSQL 14 on AWS ECS",
     "importance": 0.85, "tags": ["infrastructure"]},
    {"content": "Auth module complete (JWT HS256). Rate limiting is next.",
     "importance": 0.90, "tags": ["progress", "open-task"]},
    {"content": "Constraint: AWS free tier only, no paid services",
     "importance": 0.82, "tags": ["constraint"]},
])

# --- SESSION 2 (Wednesday, new process) ---
agent2 = CrossSessionAgent("9182")
system2 = agent2.start_session("I am back to add rate limiting")
print(system2)
# Output includes all 3 prior facts, agent picks up seamlessly

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

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

interface SessionOutcome {
  content: string;
  importance?: number;
  tags?: string[];
}

class CrossSessionAgent {
  private agentId: string;

  constructor(customerId: string) {
    this.agentId = `support-customer-${customerId}`;
  }

  async startSession(userMessage: string): Promise<string> {
    const prior = await client.recall(
      this.agentId,
      `project progress, open tasks, decisions, constraints: ${userMessage}`,
      { top_k: 8, min_importance: 0.72 }
    );

    if (!prior.memories.length) {
      return 'You are a helpful support agent. First conversation with this customer.';
    }

    const ctxLines = prior.memories.map(m => `- ${m.content}`).join('
');
    return `You are a support agent with memory of prior sessions.

PRIOR CONTEXT:
${ctxLines}

Continue seamlessly without asking the user to repeat information.`;
  }

  async endSession(outcomes: SessionOutcome[]): Promise<void> {
    // Parallel store for speed
    await Promise.all(outcomes.map(o =>
      client.storeMemory(this.agentId, {
        content: o.content,
        memoryType: 'episodic',
        importance: o.importance ?? 0.80,
        tags: o.tags ?? ['session-context']
      })
    ));
  }

  async getSessionHistory() {
    return client.listSessions();
  }
}

// SESSION 1
const agent = new CrossSessionAgent('9182');
const sys1 = await agent.startSession('help with FastAPI project');

// ... conversation ...

await agent.endSession([
  { content: 'Customer runs FastAPI + PostgreSQL 14 on AWS ECS', importance: 0.85, tags: ['infrastructure'] },
  { content: 'Auth complete (JWT HS256). Rate limiting is next open task.', importance: 0.90, tags: ['open-task'] },
  { content: 'Constraint: AWS free tier only, no paid external services', importance: 0.82, tags: ['constraint'] },
]);

// SESSION 2 (Wednesday)
const agent2 = new CrossSessionAgent('9182');
const sys2 = await agent2.startSession('back to add rate limiting');
// sys2 contains all prior context — user never has to repeat themselves

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

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

// --- END OF SESSION 1: store distilled facts ---
let outcomes = vec![
    ("Customer runs FastAPI + PostgreSQL 14 on AWS ECS", 0.85f32, vec!["infrastructure"]),
    ("Auth module complete (JWT HS256). Rate limiting is next open task.", 0.90, vec!["open-task"]),
    ("Constraint: AWS free tier only, no paid external services.", 0.82, vec!["constraint"]),
];

for (content, importance, tags) in &outcomes {
    client.store_memory(agent_id, StoreMemoryRequest {
        content: content.to_string(),
        memory_type: "episodic".into(),
        importance: Some(*importance),
        tags: tags.iter().map(|t| t.to_string()).collect(),
        ..Default::default()
    }).await?;
}

// --- START OF SESSION 2: recall and rehydrate ---
let prior = client.recall(agent_id, RecallRequest {
    query: "project progress open tasks constraints".into(),
    top_k: Some(8),
    min_importance: Some(0.72),
    ..Default::default()
}).await?;

let ctx_lines: Vec<String> = prior.memories
    .iter()
    .map(|m| format!("- {}", m.content))
    .collect();

let system_prompt = format!(
    "You are a support agent with prior session memory.

PRIOR CONTEXT:
{}

Continue seamlessly.",
    ctx_lines.join("
")
);

package main

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

func endSession(ctx context.Context, client *dakera.Client, agentID string, outcomes []map[string]interface{}) {
    for _, o := range outcomes {
        importance, _ := o["importance"].(float64)
        tags, _ := o["tags"].([]string)
        client.StoreMemory(ctx, agentID, dakera.StoreMemoryRequest{
            Content:    o["content"].(string),
            MemoryType: "episodic",
            Importance: importance,
            Tags:       tags,
        })
    }
}

func startSession(ctx context.Context, client *dakera.Client, agentID, userMsg string) string {
    prior, _ := client.Recall(ctx, agentID, dakera.RecallRequest{
        Query:         fmt.Sprintf("project progress open tasks constraints: %s", userMsg),
        TopK:          8,
        MinImportance: 0.72,
    })

    if len(prior.Memories) == 0 {
        return "You are a helpful support agent. First conversation with this customer."
    }

    lines := make([]string, 0, len(prior.Memories))
    for _, m := range prior.Memories {
        lines = append(lines, "- "+m.Content)
    }

    return fmt.Sprintf(
        "You are a support agent with memory of prior sessions.

PRIOR CONTEXT:
%s

Continue without asking the user to repeat themselves.",
        strings.Join(lines, "
"),
    )
}

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

    // SESSION 2: recall prior context
    system := startSession(ctx, client, agentID, "I am back to add rate limiting")
    _ = system // inject into LLM call
}