Rust SDK

GitHub · docs.rs · Changelog

# Cargo.toml
[dependencies]
dakera-client = "0.11"
tokio = { version = "1", features = ["full"] }

Client setup

use dakera_client::{DakeraClient, Config};

// Recommended: configure via env vars
// DAKERA_URL=http://<YOUR_SERVER_IP>:3300
// DAKERA_API_KEY=your-api-key

let client = DakeraClient::new(Config {
    base_url: std::env::var("DAKERA_URL")
        .unwrap_or_else(|_| "http://localhost:3300".into()),
    api_key: std::env::var("DAKERA_API_KEY").ok(),
    ..Default::default()
})?;

Memory operations

use dakera_client::memory::{StoreRequest, RecallRequest};

client.memories().store(StoreRequest {
    agent_id: "my-agent".into(), content: "User is learning Rust".into(),
    importance: Some(0.8), tags: vec!["learning".into()], ..Default::default()
}).await?;

let memories = client.memories().recall(RecallRequest {
    agent_id: "my-agent".into(), query: "programming languages".into(),
    top_k: Some(10), ..Default::default()
}).await?;

let session = client.sessions().start(StartRequest {
    agent_id: "my-agent".into(), ..Default::default()
}).await?;

Vector operations

use dakera_client::vectors::{UpsertRequest, QueryRequest};

// Upsert a vector
client.vectors().upsert(UpsertRequest {
    namespace: "my-namespace".into(),
    id: "doc-001".into(),
    text: "quarterly revenue report".into(),
    metadata: serde_json::json!({ "source": "finance" }),
    ..Default::default()
}).await?;

// Query vectors
let results = client.vectors().query(QueryRequest {
    namespace: "my-namespace".into(),
    text: "revenue trends".into(),
    top_k: Some(5),
    ..Default::default()
}).await?;

Namespace management

use dakera_client::namespaces::CreateRequest;

// Create namespace
client.namespaces().create(CreateRequest {
    name: "production".into(),
    index_type: Some("hnsw".into()),
    dimension: Some(1024),
    ..Default::default()
}).await?;

// List namespaces
let ns_list = client.namespaces().list().await?;

// Delete namespace
client.namespaces().delete("old-namespace").await?;

gRPC transport

# Enable in Cargo.toml
dakera-client = { version = "0.11", features = ["grpc"] }

let client = DakeraClient::grpc(GrpcConfig {
    endpoint: "http://localhost:50051".into(),
    ..Default::default()
})?;

Knowledge graph

use dakera_client::knowledge::{GraphRequest, DeduplicateRequest};

// Build knowledge graph from seed
let graph = client.knowledge().graph(GraphRequest {
    agent_id: "my-agent".into(), memory_id: "mem-abc".into(),
    depth: Some(2), ..Default::default()
}).await?;

// Deduplicate (preview)
let dupes = client.knowledge().deduplicate(DeduplicateRequest {
    agent_id: "my-agent".into(), threshold: Some(0.93), dry_run: Some(true),
}).await?;

Full-text & hybrid search

// Full-text search
let results = client.vectors().fulltext_search("docs", "revenue", 5).await?;

// Hybrid search (vector + BM25)
let results = client.vectors().hybrid_search(HybridRequest {
    namespace: "docs".into(), text: "revenue trends".into(),
    vector_weight: Some(0.7), ..Default::default()
}).await?;

Entity extraction & feedback

// Extract entities
let entities = client.extract_entities("Alice met Bob at Google HQ", None).await?;

// Feedback loop
client.memories().feedback("mem-abc", "upvote").await?;
let summary = client.agents().feedback_summary("my-agent").await?;

Import, export & streaming

// Export memories
let data = client.export_memories("my-agent", "jsonl").await?;

// Stream memory events (SSE)
let mut stream = client.stream_memory_events("my-agent", None).await?;
while let Some(event) = stream.next().await {
    println!("{:?}", event?);
}

Batch operations

use dakera_client::memory::{BatchForgetRequest, BatchForgetFilter};

// Batch forget — remove memories matching filters
let resp = client.batch_forget(BatchForgetRequest {
    agent_id: "my-agent".into(),
    filter: BatchForgetFilter { tags: Some(vec!["obsolete".into()]), ..Default::default() },
}).await?;

// Batch query text — multi-query in one call
let results = client.vectors().batch_query_text("docs", vec![
    ("revenue report", 5),
    ("product roadmap", 3),
]).await?;

Health probes

// Readiness probe (dependencies healthy)
let ready = client.health_ready().await?;

// Liveness probe (process alive)
let live = client.health_live().await?;

Vector bulk operations

// Bulk update vectors by ID
client.vectors().bulk_update("docs", vec![
    BulkUpdateItem { id: "doc-001".into(), metadata: json!({ "reviewed": true }) },
]).await?;

// Bulk delete vectors by ID
client.vectors().bulk_delete("docs", vec!["doc-003".into(), "doc-004".into()]).await?;

// Count vectors in a namespace
let count = client.vectors().count("docs").await?;

Full-text index management

// Get full-text index stats
let stats = client.vectors().fulltext_stats("docs").await?;

// Delete a full-text document by ID
client.vectors().fulltext_delete("docs", "doc-001").await?;

TTL & storage

// TTL engine stats
let ttl = client.ttl_stats().await?;

// Storage tier overview
let tiers = client.storage_tier_overview().await?;

// Memory type stats
let type_stats = client.memory_type_stats().await?;

Agent consolidation

// Trigger consolidation
client.agents().consolidate("my-agent").await?;

// Get consolidation log
let log = client.agents().consolidation_log("my-agent").await?;

// Patch consolidation config
client.agents().patch_consolidation_config("my-agent", ConsolidationConfig {
    threshold: Some(0.9), max_batch: Some(100), ..Default::default()
}).await?;

Namespace config

// Get entity extraction config
let config = client.namespaces().get_entity_config("production").await?;

// Get namespace extractor
let extractor = client.namespaces().get_extractor("production").await?;

// Migrate namespace dimensions (e.g. 768 → 1024)
client.namespaces().migrate_dimensions("production", 1024).await?;

Admin & ops

// Cluster status
let cluster = client.cluster_status().await?;

// Maintenance mode
client.admin_enable_maintenance("scheduled upgrade").await?;
client.admin_disable_maintenance().await?;

// Quota management
let quotas = client.get_quotas().await?;

// Slow query log
let slow = client.slow_queries(Some(20)).await?;

// Backups
let backup = client.create_backup(true).await?;
let backups = client.list_backups().await?;

// Ops diagnostics
let diag = client.ops_diagnostics().await?;

// List background jobs
let jobs = client.ops_list_jobs().await?;

// Trigger compaction
client.ops_compact("production").await?;

// Graceful shutdown
client.ops_shutdown().await?;

Autopilot & decay (admin)

// AutoPilot status
let status = client.autopilot_status().await?;

// Update AutoPilot config
client.autopilot_update_config(AutoPilotConfigRequest {
    enabled: Some(true), dedup_threshold: Some(0.93), ..Default::default()
}).await?;

// Trigger dedup cycle
client.autopilot_trigger("dedup").await?;

// Decay engine
let decay = client.decay_config().await?;
client.decay_update_config(DecayConfigUpdateRequest {
    half_life_days: Some(30), ..Default::default()
}).await?;

Memory policy

// Set namespace memory lifecycle policy
client.namespaces().set_memory_policy("production", MemoryPolicy {
    episodic_ttl_seconds: Some(604800),
    working_ttl_seconds: Some(3600),
    ..Default::default()
}).await?;

// Get current policy
let policy = client.namespaces().get_memory_policy("production").await?;

Builder pattern & configuration

use dakera_client::{DakeraClient, RetryConfig};
use std::time::Duration;

let client = DakeraClient::builder("http://localhost:3300")
    .api_key("your-key")
    .timeout(Duration::from_secs(30))
    .retry_config(RetryConfig {
        max_retries: 3, base_delay: Duration::from_millis(500),
        max_delay: Duration::from_secs(10), jitter: true,
    })
    .build()?;

Error handling

use dakera_client::{DakeraError, ErrorKind};

match client.memories().get("mem-abc").await {
    Ok(memory) => println!("{}", memory.content),
    Err(DakeraError { kind: ErrorKind::NotFound, .. }) => println!("Not found"),
    Err(DakeraError { kind: ErrorKind::RateLimited, .. }) => println!("Rate limited"),
    Err(e) => eprintln!("Error: {e}"),
}

Error variants: Unauthorized, NotFound, Validation, RateLimited, ServerError, Connection, Timeout. All carry kind and message.