Rust SDK

GitHub · docs.rs · GitHub

# 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(),
    query: "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()),
    dimensions: Some(384),
    ..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?);
}

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.