Multi-Agent Shared Memory

import os
from dakera import DakeraClient

URL = "http://localhost:3000"

# Keys are created once with the admin routes (see the REST tab).
# Each agent then works through clients built from its own keys.
researcher = DakeraClient(base_url=URL, api_key=os.environ["RESEARCHER_WRITE_KEY"])
researcher_tasks = DakeraClient(base_url=URL, api_key=os.environ["RESEARCHER_READ_KEY"])
writer = DakeraClient(base_url=URL, api_key=os.environ["WRITER_WRITE_KEY"])
writer_tasks = DakeraClient(base_url=URL, api_key=os.environ["WRITER_READ_KEY"])
qc = DakeraClient(base_url=URL, api_key=os.environ["QC_READ_KEY"])
orchestrator = DakeraClient(base_url=URL, api_key=os.environ["ORCHESTRATOR_WRITE_KEY"])

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

const baseUrl = 'http://localhost:3000';

// Keys are created once with the admin routes (see the REST tab).
// Each agent then works through clients built from its own keys.
const researcher = new DakeraClient({ baseUrl, apiKey: process.env.RESEARCHER_WRITE_KEY });
const researcherTasks = new DakeraClient({ baseUrl, apiKey: process.env.RESEARCHER_READ_KEY });
const writer = new DakeraClient({ baseUrl, apiKey: process.env.WRITER_WRITE_KEY });
const qc = new DakeraClient({ baseUrl, apiKey: process.env.QC_READ_KEY });
const orchestrator = new DakeraClient({ baseUrl, apiKey: process.env.ORCHESTRATOR_WRITE_KEY });

use dakera_client::DakeraClient;

// Keys are created once with the admin routes (see the REST tab).
// Each agent then works through clients built from its own keys.
let client_for = |var: &str| {
    DakeraClient::builder("http://localhost:3000")
        .api_key(std::env::var(var).unwrap_or_default())
        .build()
};
let researcher = client_for("RESEARCHER_WRITE_KEY")?;
let researcher_tasks = client_for("RESEARCHER_READ_KEY")?;
let writer = client_for("WRITER_WRITE_KEY")?;
let qc = client_for("QC_READ_KEY")?;

// Keys are created once with the admin routes (see the REST tab).
// Each agent then works through clients built from its own keys.
clientFor := func(envVar string) *dakera.Client {
    return dakera.NewClientWithOptions(dakera.ClientOptions{
        BaseURL: "http://localhost:3000",
        APIKey:  os.Getenv(envVar),
    })
}
researcher := clientFor("RESEARCHER_WRITE_KEY")
researcherTasks := clientFor("RESEARCHER_READ_KEY")
writer := clientFor("WRITER_WRITE_KEY")
qc := clientFor("QC_READ_KEY")

SHARED = "team-shared"

# --- ORCHESTRATOR: publish a task assignment ---
orchestrator.store_memory(
    agent_id="coordinator",
    content="Task: Research HNSW scaling characteristics at 1M, 10M, 100M vectors. Deadline: 2 hours.",
    importance=0.8,
    tags=["task", "assigned:researcher", "status:in-progress"],
)

# --- RESEARCHER AGENT ---
# 1. Private working notes (never visible to the writer)
researcher.store_memory(
    agent_id="researcher",
    content="Paper #2 claims 8ms at 10M vectors but uses different hardware. Potentially misleading.",
    importance=0.3,
    tags=["internal-note", "unverified"],
)

# 2. Publish verified findings to shared
researcher.store_memory(
    agent_id=SHARED,
    content="VERIFIED: HNSW achieves 5ms P50 at 10M vectors (ef=200, M=32). Scales sub-linearly: 100M vectors = ~12ms P50.",
    importance=0.85,
    memory_type="semantic",
    tags=["finding", "verified", "hnsw", "latency"],
    metadata={"source": "researcher", "papers_cited": 5, "confidence": "high"},
)

# Update task status
orchestrator.store_memory(
    agent_id="coordinator",
    content="Research task complete. Verified findings published to team-shared.",
    importance=0.7,
    tags=["status-update", "task:research", "status:complete"],
)

# --- WRITER AGENT ---
# 3. Recall verified findings from shared
findings = writer.recall(agent_id=SHARED, query="HNSW performance latency memory characteristics", top_k=6)
print(f"Writer retrieved {len(findings.memories)} verified findings:")
for f in findings.memories:
    print(f"  [{f.importance:.2f}] {f.content[:80]}")

# 4. Private draft notes
writer.store_memory(
    agent_id="writer",
    content="Opening with concrete numbers (5ms, 100M vectors) is stronger than abstract claims. Draft A.",
    importance=0.25,
    tags=["draft-note", "structure"],
)

# 5. Publish the completed article to shared
writer.store_memory(
    agent_id=SHARED,
    content="COMPLETED: 'HNSW at Scale: Making Billion-Vector Search Practical', 1,400 words, data-backed, reviewed.",
    importance=0.9,
    memory_type="semantic",
    tags=["output", "article", "status:complete"],
    metadata={"source": "writer", "word_count": 1400},
)

# --- QUALITY CHECK AGENT (read key on team-shared only) ---
outputs = qc.recall(agent_id=SHARED, query="completed articles and verified findings", top_k=10)

const SHARED = 'team-shared';

// Researcher: private working notes
await researcher.storeMemory('researcher', {
  content: 'Paper #2 claims 8ms but uses a different hardware config. May not be representative.',
  importance: 0.3,
  tags: ['internal-note', 'unverified'],
});

// Researcher: publish a verified finding to team-shared
await researcher.storeMemory(SHARED, {
  content: 'VERIFIED: HNSW at 10M vectors achieves 5ms P50 (ef=200, M=32). Sub-linear scaling confirmed across 5 papers.',
  importance: 0.85,
  memory_type: 'semantic',
  tags: ['finding', 'verified', 'hnsw', 'latency'],
  metadata: { source: 'researcher' },
});

// Writer: recall from team-shared (only verified, high-importance findings)
const { memories: findings } = await writer.recall(SHARED, 'HNSW performance latency memory', { top_k: 6 });
console.log(`Retrieved ${findings.length} verified findings`);

// Writer: private draft notes
await writer.storeMemory('writer', {
  content: 'Lead with the 5ms number: concrete, compelling. Draft A structure.',
  importance: 0.25,
  tags: ['draft-note'],
});

// Writer: publish the completed article to team-shared
await writer.storeMemory(SHARED, {
  content: 'COMPLETED: HNSW at Scale article, 1,400 words, data-backed, QC ready.',
  importance: 0.9,
  memory_type: 'semantic',
  tags: ['output', 'article', 'status:complete'],
  metadata: { source: 'writer' },
});

// QC agent: read key on team-shared only
const { memories: outputs } = await qc.recall(SHARED, 'completed outputs and verified findings', { top_k: 10 });
console.log(`team-shared returned ${outputs.length} items`);

use dakera_client::{RecallRequest, StoreMemoryRequest};

// Researcher: private notes
researcher.store_memory(
    StoreMemoryRequest::new("researcher", "Paper #2 figures may be skewed by hardware; cross-checking now")
        .with_importance(0.3)
        .with_tags(vec!["internal-note".into()]),
).await?;

// Researcher: publish a verified finding
researcher.store_memory(
    StoreMemoryRequest::new("team-shared", "VERIFIED: HNSW 10M vectors = 5ms P50 (ef=200). Sub-linear at scale.")
        .with_importance(0.85)
        .with_tags(vec!["finding".into(), "verified".into(), "hnsw".into()]),
).await?;

// Writer: recall only from team-shared
let findings = writer.recall(
    RecallRequest::new("team-shared", "HNSW performance latency at scale").with_top_k(6),
).await?;
println!("Writer retrieved {} findings", findings.memories.len());

// Writer: publish the completed output
writer.store_memory(
    StoreMemoryRequest::new("team-shared", "COMPLETED: HNSW at Scale article, 1,400 words, verified data.")
        .with_importance(0.9)
        .with_tags(vec!["output".into(), "article".into(), "status:complete".into()]),
).await?;

ctx := context.Background()
const sharedNS = "team-shared"
low, high, done := float32(0.3), float32(0.85), float32(0.9)

// Researcher: private notes (the writer's key cannot read these)
researcher.StoreMemory(ctx, "researcher", dakera.StoreMemoryRequest{
    Content:    "Paper #2 hardware config skews results; cross-checking with 4 other sources",
    Importance: &low,
    Tags:       []string{"internal-note", "unverified"},
})

// Researcher: publish a verified finding
researcher.StoreMemory(ctx, sharedNS, dakera.StoreMemoryRequest{
    Content:    "VERIFIED: HNSW 10M vectors achieves 5ms P50 latency (ef=200, M=32). Confirmed across 5 papers.",
    Importance: &high,
    Tags:       []string{"finding", "verified", "hnsw", "latency"},
})

// Writer: recall from team-shared only
findings, _ := writer.Recall(ctx, sharedNS, dakera.RecallRequest{
    Query: "HNSW performance latency at scale",
    TopK:  6,
})
fmt.Printf("Writer retrieved %d findings\n", len(findings.Memories))

// Writer: publish the completed article
writer.StoreMemory(ctx, sharedNS, dakera.StoreMemoryRequest{
    Content:    "COMPLETED: HNSW at Scale article, 1,400 words, data-backed",
    Importance: &done,
    Tags:       []string{"output", "article", "status:complete"},
})