zova 0.25.0

Safe Rust bindings for Zova, a SQLite-backed embedded database for records, objects, vectors, and graph relationships.
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

use zova::{
    Database, GraphEdgeInput, GraphNeighborsOptions, GraphNodeInput, GraphTargetType, Step,
    VectorCollectionOptions, VectorElementType, VectorMetric, VectorValues, DEFAULT_GRAPH_NAME,
};

fn hex(bytes: [u8; 32]) -> String {
    bytes.iter().map(|byte| format!("{byte:02x}")).collect()
}

fn main() -> zova::Result<()> {
    let path = std::env::temp_dir().join(format!(
        "zova-rust-graph-rag-example-{}.zova",
        std::process::id()
    ));
    let _ = std::fs::remove_file(&path);

    let mut db = Database::create(&path)?;
    db.exec("create table chunks(id text primary key, body text not null)")?;
    db.exec("insert into chunks(id, body) values ('chunk:1', 'Zova stores records, objects, and vectors together')")?;
    db.create_graph(DEFAULT_GRAPH_NAME)?;

    db.create_vector_collection(
        "chunks",
        VectorCollectionOptions {
            dimensions: 2,
            metric: VectorMetric::L2,
            element_type: VectorElementType::F32,
        },
    )?;
    db.put_vector("chunks", "chunk:1", VectorValues::F32(&[0.0, 1.0]))?;

    let object_id = db.put_object(b"attachment bytes")?;
    let object_hex = hex(object_id.into_bytes());

    db.put_graph_node(GraphNodeInput {
        graph_name: DEFAULT_GRAPH_NAME,
        node_id: "chunk:1",
        kind: "chunk",
        target_type: GraphTargetType::Vector,
        target_namespace: Some("chunks"),
        target_ref: Some("chunk:1"),
    })?;
    db.put_graph_node(GraphNodeInput {
        graph_name: DEFAULT_GRAPH_NAME,
        node_id: "attachment:1",
        kind: "attachment",
        target_type: GraphTargetType::Object,
        target_namespace: Some("sha256"),
        target_ref: Some(&object_hex),
    })?;
    db.put_graph_node(GraphNodeInput {
        graph_name: DEFAULT_GRAPH_NAME,
        node_id: "entity:zova",
        kind: "entity",
        target_type: GraphTargetType::Entity,
        target_namespace: None,
        target_ref: Some("zova"),
    })?;
    db.put_graph_edge(GraphEdgeInput {
        graph_name: DEFAULT_GRAPH_NAME,
        from_node_id: "chunk:1",
        edge_type: "mentions",
        to_node_id: "entity:zova",
    })?;
    db.put_graph_edge(GraphEdgeInput {
        graph_name: DEFAULT_GRAPH_NAME,
        from_node_id: "chunk:1",
        edge_type: "has_attachment",
        to_node_id: "attachment:1",
    })?;

    let nearest = db.search_vectors("chunks", VectorValues::F32(&[0.0, 1.0]), 1)?;
    for hit in nearest {
        let neighbors = db.graph_neighbors(GraphNeighborsOptions {
            graph_name: DEFAULT_GRAPH_NAME,
            node_id: &hit.id,
            direction: zova::GraphNeighborDirection::Outgoing,
            edge_type: None,
            limit: 10,
        })?;
        for neighbor in neighbors {
            if neighbor.node_id == "attachment:1" {
                println!("attachment bytes: {}", db.get_object(object_id)?.len());
            } else {
                let mut stmt = db.prepare("select body from chunks where id = ?1")?;
                stmt.bind_text(1, &hit.id)?;
                if stmt.step()? == Step::Row {
                    println!(
                        "{}: {}",
                        neighbor.node_id,
                        stmt.column_text(0)?.unwrap_or_default()
                    );
                }
            }
        }
    }

    let _ = std::fs::remove_file(path);
    Ok(())
}