Struct CollectionConfig

Source

pub struct CollectionConfig {
    pub dim: usize,
    pub metric: Metric,
    pub hnsw: HnswParams,
}

Fields§

§dim: usize§metric: Metric§hnsw: HnswParams

Implementations§

Source §

impl CollectionConfig

Source

pub fn new(dim: usize, metric: Metric) -> Self

Examples found in repository ?

examples/quickstart.rs (line 14)

9fn main() -> recern_vector::Result<()> {
10    let path = std::env::temp_dir().join("recern-vector-quickstart.rvec");
11    let _ = std::fs::remove_file(&path);
12
13    let mut db = Database::create(&path)?;
14    let docs = db.create_collection("docs", CollectionConfig::new(32, Metric::Cosine))?;
15
16    // Batch insert: (id, vector, metadata). Built on all cores, atomic.
17    let records: Vec<_> = (0..10_000)
18        .map(|i| {
19            let vector: Vec<f32> = (0..32).map(|d| pseudo_random(i * 32 + d)).collect();
20            let lang = ["en", "de", "fr"][i % 3];
21            (
22                format!("doc-{i}"),
23                vector,
24                Some(json!({"lang": lang, "year": 2015 + i % 10})),
25            )
26        })
27        .collect();
28    let query = records[42].1.clone();
29    docs.upsert_many(records)?;
30    println!("{} records", docs.len());
31
32    // Search with a filter; explain() returns the hits and how they were found.
33    let filter = Filter::from_json(&json!({"lang": "en", "year": {"$gte": 2020}}))?;
34    // The same filter, built in code:
35    let _same = Filter::And(vec![
36        Filter::eq("lang", "en"),
37        Filter::between("year", Some(2020.0), None),
38    ]);
39    let report = docs.explain(&query, 3, &SearchOptions::default().filter(filter))?;
40    for hit in &report.hits {
41        println!(
42            "  {:<10} distance={:.4} {}",
43            hit.id,
44            hit.distance,
45            hit.metadata.as_ref().unwrap()
46        );
47    }
48    println!(
49        "strategy={} visited={} selectivity={:.1}% time={:?}",
50        report.strategy,
51        report.visited,
52        report.filter_selectivity.unwrap_or(1.0) * 100.0,
53        report.elapsed
54    );
55
56    // Index health and recall against exact search.
57    let stats = docs.stats();
58    println!(
59        "layers={:?} unreachable={}",
60        stats.nodes_per_layer, stats.unreachable
61    );
62    let recall = docs.estimate_recall(&RecallOptions {
63        ef_values: vec![16, 64],
64        ..Default::default()
65    })?;
66    for point in &recall.points {
67        println!(
68            "  ef={:<3} recall@{}={:.3}",
69            point.ef, recall.k, point.recall
70        );
71    }
72
73    db.save()?;
74    let reopened = Database::open(&path)?;
75    println!("reopened: {} records", reopened.collection("docs")?.len());
76    Ok(())
77}

More examples

Hide additional examples

examples/bench.rs (line 71)

55fn main() -> recern_vector::Result<()> {
56    let args: Vec<String> = std::env::args().skip(1).collect();
57    let arg = |i: usize| {
58        args.get(i)
59            .map(|a| a.parse::<f64>().expect("numeric argument"))
60    };
61    let records = arg(0).map_or(50_000, |v| v as usize);
62    let dim = arg(1).map_or(128, |v| v as usize);
63    let noise = arg(2).map_or(1.0, |v| v as f32);
64    let path = std::env::temp_dir().join("recern-vector-bench.rvec");
65    let _ = std::fs::remove_file(&path);
66
67    let mut data = Clusters::new(100, dim, noise, 0x5EED);
68    let vectors: Vec<Vec<f32>> = (0..records).map(|_| data.sample()).collect();
69
70    let mut db = Database::create(&path)?;
71    let collection = db.create_collection("bench", CollectionConfig::new(dim, Metric::Cosine))?;
72    let start = Instant::now();
73    for (i, v) in vectors.iter().enumerate() {
74        collection.upsert(&i.to_string(), v, None)?;
75    }
76    let build = start.elapsed();
77
78    let start = Instant::now();
79    db.save()?;
80    let save = start.elapsed();
81    let start = Instant::now();
82    let db = Database::open(&path)?;
83    let open = start.elapsed();
84    let collection = db.collection("bench")?;
85    let stats = collection.stats();
86
87    println!("records {records} · dim {dim} · noise {noise} · cosine · m=16 ef_construction=200");
88    println!(
89        "build   {:.2} s ({:.0} inserts/s)",
90        build.as_secs_f64(),
91        records as f64 / build.as_secs_f64()
92    );
93    println!(
94        "file    {:.1} MB · save {:.0} ms · open {:.0} ms",
95        std::fs::metadata(&path)?.len() as f64 / 1_048_576.0,
96        save.as_secs_f64() * 1e3,
97        open.as_secs_f64() * 1e3
98    );
99    println!(
100        "graph   layers {:?} · avg degree L0 {:.1} · unreachable {}",
101        stats.nodes_per_layer, stats.avg_degree_layer0, stats.unreachable
102    );
103
104    let report = collection.estimate_recall(&RecallOptions {
105        sample: 200,
106        k: 10,
107        ef_values: vec![10, 16, 32, 64, 128, 256],
108        seed: 7,
109    })?;
110    println!();
111    println!(
112        "exact scan p50 {:.3} ms",
113        report.exact_p50.as_secs_f64() * 1e3
114    );
115    println!(
116        "{:>6}  {:>9}  {:>10}  {:>10}  {:>9}",
117        "ef", "recall@10", "p50 ms", "p95 ms", "speedup"
118    );
119    for p in &report.points {
120        println!(
121            "{:>6}  {:>9.3}  {:>10.3}  {:>10.3}  {:>8.0}x",
122            p.ef,
123            p.recall,
124            p.p50.as_secs_f64() * 1e3,
125            p.p95.as_secs_f64() * 1e3,
126            report.exact_p50.as_secs_f64() / p.p50.as_secs_f64()
127        );
128    }
129
130    let _ = std::fs::remove_file(&path);
131    Ok(())
132}