Cross-Session Context

from dakera import DakeraClient

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

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

    def start_session(self, user_message: str) -> str:
        """Open a Dakera session, recall prior context and build the system prompt."""
        self.session_id = client.start_session(agent_id=self.agent_id)["id"]
        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.memories:
            return "You are a helpful support agent. First conversation with this customer."

        ctx_lines = "\n".join(f"- {m.content}" for m in prior.memories)
        return (
            "You are a support agent with memory of prior sessions.\n\n"
            f"PRIOR SESSION CONTEXT:\n{ctx_lines}\n\n"
            "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, then end the session."""
        for o in outcomes:
            client.store_memory(
                agent_id=self.agent_id,
                content=o["content"],
                memory_type=o.get("memory_type", "episodic"),
                importance=o.get("importance", 0.80),
                tags=o.get("tags", ["session-context"]),
                session_id=self.session_id
            )
        client.end_session(self.session_id)

    def get_session_list(self) -> list:
        """All sessions of this agent, newest first."""
        return client.list_sessions(agent_id=self.agent_id)

# --- 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": ["session-context", "infrastructure"]},
    {"content": "Auth module complete (JWT HS256). Rate limiting is next.",
     "importance": 0.90, "tags": ["session-context", "progress", "open-task"]},
    {"content": "Constraint: AWS free tier only, no paid services",
     "importance": 0.82, "memory_type": "semantic", "tags": ["session-context", "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:3000', apiKey: 'dk-...' });

interface SessionOutcome {
  content: string;
  importance?: number;
  memory_type?: 'episodic' | 'semantic';
  tags?: string[];
}

class CrossSessionAgent {
  private agentId: string;
  private sessionId?: string;

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

  async startSession(userMessage: string): Promise<string> {
    this.sessionId = (await client.startSession(this.agentId)).id;
    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('\n');
    return `You are a support agent with memory of prior sessions.\n\nPRIOR CONTEXT:\n${ctxLines}\n\nContinue seamlessly without asking the user to repeat information.`;
  }

  async endSession(outcomes: SessionOutcome[]): Promise<void> {
    await Promise.all(outcomes.map(o =>
      client.storeMemory(this.agentId, {
        content: o.content,
        memory_type: o.memory_type ?? 'episodic',
        importance: o.importance ?? 0.80,
        tags: o.tags ?? ['session-context'],
        session_id: this.sessionId,
      })
    ));
    if (this.sessionId) await client.endSession(this.sessionId);
  }

  async getSessionHistory() {
    return client.listSessions({ agent_id: this.agentId });
  }
}

// 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: ['session-context', 'infrastructure'] },
  { content: 'Auth complete (JWT HS256). Rate limiting is next open task.', importance: 0.90, tags: ['session-context', 'open-task'] },
  { content: 'Constraint: AWS free tier only, no paid external services', importance: 0.82, memory_type: 'semantic', tags: ['session-context', 'constraint'] },
]);

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

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

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

// --- SESSION 1: open a session; at its end, store distilled facts ---
let session = client.start_session(agent_id).await?;
let outcomes = vec![
    ("Customer runs FastAPI + PostgreSQL 14 on AWS ECS", 0.85f32, MemoryType::Episodic, "infrastructure"),
    ("Auth module complete (JWT HS256). Rate limiting is next open task.", 0.90, MemoryType::Episodic, "open-task"),
    ("Constraint: AWS free tier only, no paid external services.", 0.82, MemoryType::Semantic, "constraint"),
];
for (content, importance, memory_type, tag) in outcomes {
    client.store_memory(
        StoreMemoryRequest::new(agent_id, content)
            .with_type(memory_type)
            .with_importance(importance)
            .with_tags(vec!["session-context".into(), tag.into()])
            .with_session(session.id.clone()),
    ).await?;
}
client.end_session(&session.id, None).await?;

// --- SESSION 2: recall and rehydrate ---
let prior = client.recall(
    RecallRequest::new(agent_id, "project progress open tasks constraints")
        .with_top_k(8)
        .with_min_importance(0.72),
).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.\n\nPRIOR CONTEXT:\n{}\n\nContinue seamlessly.",
    ctx_lines.join("\n")
);

package main

import (
    "context"
    "fmt"
    "log"
    "strings"

    dakera "github.com/dakera-ai/dakera-go"
)

type outcome struct {
    content    string
    importance float32
    memoryType string
    tags       []string
}

func endSession(ctx context.Context, client *dakera.Client, agentID, sessionID string, outcomes []outcome) error {
    for _, o := range outcomes {
        importance := o.importance
        if _, err := client.StoreMemory(ctx, agentID, dakera.StoreMemoryRequest{
            Content:    o.content,
            MemoryType: o.memoryType,
            Importance: &importance,
            Tags:       o.tags,
            SessionID:  sessionID,
        }); err != nil {
            return err
        }
    }
    _, err := client.EndSession(ctx, sessionID)
    return err
}

func startSession(ctx context.Context, client *dakera.Client, agentID, userMsg string) (string, string, error) {
    session, err := client.StartSession(ctx, dakera.StartSessionRequest{AgentID: agentID})
    if err != nil {
        return "", "", err
    }
    minImp := float32(0.72)
    prior, err := client.Recall(ctx, agentID, dakera.RecallRequest{
        Query:         fmt.Sprintf("project progress open tasks constraints: %s", userMsg),
        TopK:          8,
        MinImportance: &minImp,
    })
    if err != nil {
        return "", "", err
    }
    if len(prior.Memories) == 0 {
        return session.ID, "You are a helpful support agent. First conversation with this customer.", nil
    }

    lines := make([]string, 0, len(prior.Memories))
    for _, m := range prior.Memories {
        lines = append(lines, "- "+m.Content)
    }
    return session.ID, fmt.Sprintf(
        "You are a support agent with memory of prior sessions.\n\nPRIOR CONTEXT:\n%s\n\nContinue without asking the user to repeat themselves.",
        strings.Join(lines, "\n"),
    ), nil
}

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

    // SESSION 1: open, converse, store distilled facts, end
    sessionID, _, err := startSession(ctx, client, agentID, "help with FastAPI")
    if err != nil {
        log.Fatal(err)
    }
    // ... conversation ...
    err = endSession(ctx, client, agentID, sessionID, []outcome{
        {"Customer runs FastAPI + PostgreSQL 14 on AWS ECS", 0.85, "episodic", []string{"session-context", "infrastructure"}},
        {"Auth module complete (JWT HS256). Rate limiting is next.", 0.90, "episodic", []string{"session-context", "open-task"}},
        {"Constraint: AWS free tier only, no paid services", 0.82, "semantic", []string{"session-context", "constraint"}},
    })
    if err != nil {
        log.Fatal(err)
    }

    // SESSION 2: recall prior context
    _, system, err := startSession(ctx, client, agentID, "I am back to add rate limiting")
    if err != nil {
        log.Fatal(err)
    }
    _ = system // inject into the LLM call
}