vantadb 0.1.4

VantaDB: An embedded persistent memory and vector retrieval engine for local-first AI applications.
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

/// Benchmark comparing search performance with and without prefetch
/// on the current hardware. This helps determine if prefetch benefits
/// modern SSDs or if it's only useful for HDDs/slow storage.
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};
use std::time::Instant;
use tempfile::TempDir;
use vantadb::sdk::{VantaEmbedded, VantaMemoryInput, VantaMemorySearchRequest};
use vantadb::DistanceMetric;

fn insert_vectors(db: &VantaEmbedded, count: usize, dim: usize) {
    let mut rng = StdRng::seed_from_u64(42);
    for i in 0..count {
        let vec: Vec<f32> = (0..dim).map(|_| rng.random::<f32>()).collect();
        let mut input = VantaMemoryInput::new("bench", i.to_string(), format!("doc {}", i));
        input.vector = Some(vec);
        db.put(input).unwrap();
    }
}

fn measure_search_latency(
    db: &VantaEmbedded,
    query: Vec<f32>,
    _dim: usize,
    iterations: usize,
    top_k: usize,
) -> f64 {
    // Warmup
    for _ in 0..10 {
        let request = VantaMemorySearchRequest {
            namespace: "bench".to_string(),
            query_vector: query.clone(),
            filters: Default::default(),
            text_query: None,
            top_k,
            distance_metric: DistanceMetric::Cosine,
            explain: false,
        };
        let _ = db.search(request);
    }

    // Measure
    let start = Instant::now();
    for _ in 0..iterations {
        let request = VantaMemorySearchRequest {
            namespace: "bench".to_string(),
            query_vector: query.clone(),
            filters: Default::default(),
            text_query: None,
            top_k,
            distance_metric: DistanceMetric::Cosine,
            explain: false,
        };
        let _ = db.search(request);
    }
    start.elapsed().as_secs_f64() / iterations as f64 * 1000.0
}

#[test]
fn test_prefetch_impact_on_search_latency() {
    let vector_count = 500;
    let vector_dim = 64;
    let query_iterations = 50;
    let top_k = 10;

    let mut rng = StdRng::seed_from_u64(42);
    let query: Vec<f32> = (0..vector_dim).map(|_| rng.random::<f32>()).collect();

    // --- Run with prefetch ENABLED (default) ---
    let avg_prefetch_on = {
        let dir = TempDir::new().unwrap();
        let db = VantaEmbedded::open(dir.path().to_str().unwrap()).unwrap();
        insert_vectors(&db, vector_count, vector_dim);
        let old = std::env::var_os("VANTA_DISABLE_PREFETCH");
        std::env::remove_var("VANTA_DISABLE_PREFETCH");
        let result =
            measure_search_latency(&db, query.clone(), vector_dim, query_iterations, top_k);
        if let Some(val) = old {
            std::env::set_var("VANTA_DISABLE_PREFETCH", val);
        } else {
            std::env::remove_var("VANTA_DISABLE_PREFETCH");
        }
        result
    };
    println!(
        "PREFETCH_ON:  avg {:.3}ms over {} queries",
        avg_prefetch_on, query_iterations
    );

    // --- Run with prefetch DISABLED ---
    let avg_prefetch_off = {
        let dir = TempDir::new().unwrap();
        let db = VantaEmbedded::open(dir.path().to_str().unwrap()).unwrap();
        insert_vectors(&db, vector_count, vector_dim);
        let old = std::env::var_os("VANTA_DISABLE_PREFETCH");
        std::env::set_var("VANTA_DISABLE_PREFETCH", "1");
        let result =
            measure_search_latency(&db, query.clone(), vector_dim, query_iterations, top_k);
        if let Some(val) = old {
            std::env::set_var("VANTA_DISABLE_PREFETCH", val);
        } else {
            std::env::remove_var("VANTA_DISABLE_PREFETCH");
        }
        result
    };
    println!(
        "PREFETCH_OFF: avg {:.3}ms over {} queries",
        avg_prefetch_off, query_iterations
    );

    let ratio = avg_prefetch_on / avg_prefetch_off;
    println!();
    println!("=== PREFETCH IMPACT REPORT ===");
    println!("Prefetch ON:  {:.3}ms", avg_prefetch_on);
    println!("Prefetch OFF: {:.3}ms", avg_prefetch_off);
    println!("Ratio (on/off): {:.3}x", ratio);
    if ratio < 0.95 {
        println!("→ Prefetch is BENEFICIAL on this hardware (faster with prefetch)");
    } else if ratio > 1.05 {
        println!("→ Prefetch is HARMFUL on this hardware (slower with prefetch)");
    } else {
        println!("→ Prefetch has NO SIGNIFICANT IMPACT on this hardware (within noise)");
    }
    println!("================================");
}