Multi-Agent Shared Memory

from dakera import DakeraClient

admin = DakeraClient(base_url="http://localhost:3300", api_key="dk-admin-key")

# Create all namespaces upfront
for ns in ["team-shared", "researcher", "writer", "coordinator"]:
    admin.create_namespace(ns)

# Verify
namespaces = admin.list_namespaces()
print([n["name"] for n in namespaces])

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

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

// Create all namespaces
for (const ns of ['team-shared', 'researcher', 'writer', 'coordinator']) {
  await admin.createNamespace(ns);
}

const namespaces = await admin.listNamespaces();
console.log(namespaces.map(n => n.name));

use dakera_rs::{Client, CreateNamespaceRequest};

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

for ns in &["team-shared", "researcher", "writer", "coordinator"] {
    admin.create_namespace(ns, CreateNamespaceRequest::default()).await?;
}

let namespaces = admin.list_namespaces().await?;
println!("{:?}", namespaces.iter().map(|n| &n.name).collect::<Vec<_>>());

admin := dakera.NewClient("http://localhost:3300", "dk-admin-key")
ctx := context.Background()

for _, ns := range []string{"team-shared", "researcher", "writer", "coordinator"} {
    admin.CreateNamespace(ctx, ns, nil)
}

namespaces, _ := admin.ListNamespaces(ctx)
fmt.Println(namespaces)

from dakera import DakeraClient

# Each agent uses its own scoped client
researcher = DakeraClient(base_url="http://localhost:3300", api_key="dk-researcher-key")
writer = DakeraClient(base_url="http://localhost:3300", api_key="dk-writer-key")
coordinator = DakeraClient(base_url="http://localhost:3300", api_key="dk-coordinator-key")

SHARED_NS = "team-shared"

# --- ORCHESTRATOR: Publish task assignment ---
coordinator.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. Store private working notes (never visible to 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"]
)

researcher.store_memory(
    agent_id="researcher",
    content="Cross-referencing 5 papers: all agree on sub-linear scaling. Latency variance due to ef parameter.",
    importance=0.4,
    tags=["internal-note", "analysis-in-progress"]
)

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

researcher.store_memory(
    agent_id=SHARED_NS,
    content="VERIFIED: Memory footprint ~1.2GB per 1M 768-dim vectors with HNSW. 4x higher than flat index but 20x faster at recall.",
    importance=0.8,
    tags=["finding", "verified", "hnsw", "memory"],
    metadata={"source": "researcher"}
)

# Update task status
coordinator.store_memory(
    agent_id="coordinator",
    content="Research task complete. 2 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_NS,
    query="HNSW performance latency memory characteristics",
    top_k=6
)

print(f"Writer retrieved {len(findings)} verified findings:")
for f in findings:
    print(f"  [{f['importance']:.2f}] {f['content'][:80]}")

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

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

# --- QUALITY CHECK AGENT (reads shared, never sees private) ---
qc = DakeraClient(base_url="http://localhost:3300", api_key="dk-qc-key")
outputs = qc.recall(
    agent_id=SHARED_NS,
    query="completed articles and verified findings",
    top_k=10
)

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

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

const SHARED = 'team-shared';

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

// Researcher: publish verified finding to shared namespace
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,
  tags: ['finding', 'verified', 'hnsw', 'latency'],
  memoryType: 'semantic'
});

await researcher.storeMemory(SHARED, {
  content: 'VERIFIED: HNSW memory: ~1.2GB per 1M 768-dim vectors. 4x flat index cost, 20x faster recall.',
  importance: 0.8,
  tags: ['finding', 'verified', 'hnsw', 'memory'],
  memoryType: 'semantic'
});

// Writer: recall from shared (only verified, high-importance findings)
const 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 completed artifact to shared
await writer.storeMemory(SHARED, {
  content: 'COMPLETED: HNSW at Scale article — 1,400 words, data-backed, QC ready.',
  importance: 0.9,
  tags: ['output', 'article', 'status:complete'],
  memoryType: 'semantic'
});

// Batch recall from shared to check all outputs
const allOutputs = await researcher.recall(SHARED, 'completed outputs and verified findings', { top_k: 10 });
console.log(`Team shared namespace has ${allOutputs.length} items`);

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

let researcher = Client::new("http://localhost:3300", "dk-researcher-key");
let writer = Client::new("http://localhost:3300", "dk-writer-key");

// Researcher: private notes
researcher.store_memory("researcher", StoreMemoryRequest {
    content: "Paper #2 figures may be skewed by hardware — cross-checking now".into(),
    importance: Some(0.3),
    tags: vec!["internal-note".into()],
    ..Default::default()
}).await?;

// Researcher: publish verified finding
researcher.store_memory("team-shared", StoreMemoryRequest {
    content: "VERIFIED: HNSW 10M vectors = 5ms P50 (ef=200). Sub-linear at scale.".into(),
    importance: Some(0.85),
    memory_type: Some("semantic".into()),
    tags: vec!["finding".into(), "verified".into(), "hnsw".into()],
    ..Default::default()
}).await?;

// Writer: recall only from shared namespace
let findings = writer.recall("team-shared", RecallRequest {
    query: "HNSW performance latency at scale".into(),
    top_k: Some(6),
    ..Default::default()
}).await?;

println!("Writer retrieved {} findings", findings.len());

// Writer: publish completed output
writer.store_memory("team-shared", StoreMemoryRequest {
    content: "COMPLETED: HNSW at Scale article, 1400 words, verified data.".into(),
    importance: Some(0.9),
    tags: vec!["output".into(), "article".into(), "status:complete".into()],
    ..Default::default()
}).await?;

researcher := dakera.NewClient("http://localhost:3300", "dk-researcher-key")
writer := dakera.NewClient("http://localhost:3300", "dk-writer-key")
ctx := context.Background()

const sharedNS = "team-shared"

// Researcher: private notes (writer can't see these)
researcher.StoreMemory(ctx, "researcher", dakera.StoreMemoryRequest{
    Content:    "Paper #2 hardware config skews results — cross-checking with 4 other sources",
    Importance: 0.3,
    Tags:       []string{"internal-note", "unverified"},
})

// Researcher: publish 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: 0.85,
    MemoryType: "semantic",
    Tags:       []string{"finding", "verified", "hnsw", "latency"},
})

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

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