dakera-client 0.11.55

Rust client SDK for Dakera AI Agent Memory Platform
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

//! Basic Dakera Rust SDK usage — vectors, namespaces, search
//!
//! Run: cargo run --example basic

use std::collections::HashMap;

use dakera_client::{CreateNamespaceRequest, DakeraClient, QueryRequest, UpsertRequest, Vector};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = DakeraClient::builder("http://localhost:3300")
        .api_key("dk-mykey")
        .build()?;

    // Check server health
    let health = client.health().await?;
    println!(
        "Server: {} (healthy: {})",
        health.version.as_deref().unwrap_or("unknown"),
        health.healthy
    );

    let namespace = "example-vectors";

    // Create namespace
    client
        .create_namespace(namespace, CreateNamespaceRequest::new().with_dimensions(3))
        .await?;

    // Upsert vectors with metadata
    let resp = client
        .upsert(
            namespace,
            UpsertRequest {
                vectors: vec![
                    Vector::with_metadata(
                        "vec1",
                        vec![0.1, 0.2, 0.3],
                        HashMap::from([
                            ("category".into(), serde_json::json!("electronics")),
                            ("price".into(), serde_json::json!(299.99)),
                        ]),
                    ),
                    Vector::with_metadata(
                        "vec2",
                        vec![0.4, 0.5, 0.6],
                        HashMap::from([
                            ("category".into(), serde_json::json!("books")),
                            ("price".into(), serde_json::json!(19.99)),
                        ]),
                    ),
                    Vector::with_metadata(
                        "vec3",
                        vec![0.15, 0.25, 0.35],
                        HashMap::from([
                            ("category".into(), serde_json::json!("electronics")),
                            ("price".into(), serde_json::json!(599.99)),
                        ]),
                    ),
                ],
            },
        )
        .await?;
    println!("Upserted {} vectors", resp.upserted_count);

    // Query similar vectors
    println!("\n--- Query Results ---");
    let results = client
        .query(namespace, QueryRequest::new(vec![0.1, 0.2, 0.3], 10))
        .await?;
    for m in &results.results {
        println!("ID: {}, Score: {:.4}", m.id, m.score);
    }

    // Query with metadata filter
    println!("\n--- Filtered Query (electronics only) ---");
    let filtered = client
        .query(
            namespace,
            QueryRequest::new(vec![0.1, 0.2, 0.3], 10).with_filter(serde_json::json!({
                "category": { "$eq": "electronics" }
            })),
        )
        .await?;
    for m in &filtered.results {
        println!("ID: {}, Score: {:.4}", m.id, m.score);
    }

    // Fetch vectors by ID
    println!("\n--- Fetched Vectors ---");
    let vectors = client.fetch_by_ids(namespace, &["vec1", "vec2"]).await?;
    for v in &vectors {
        println!("ID: {}, Values: {:?}", v.id, v.values);
    }

    // Delete and cleanup
    client.delete_one(namespace, "vec1").await?;
    println!("\nDeleted vec1");

    Ok(())
}