qdrant-edge 0.7.0

A lightweight, in-process vector search engine designed for embedded devices, autonomous systems, and mobile agents.
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

use std::cmp::max;

use crate::common::types::ScoredPointOffset;
use itertools::Itertools;
use rand::SeedableRng;
use rand::prelude::StdRng;
use rstest::rstest;

use crate::segment::fixtures::index_fixtures::random_vector;
use crate::segment::index::hnsw_index::graph_layers::{GraphLayersBase, SearchAlgorithm};
use crate::segment::index::hnsw_index::graph_layers_builder::GraphLayersBuilder;
use crate::segment::index::hnsw_index::graph_links::GraphLinksFormat;
use crate::segment::index::hnsw_index::point_scorer::FilteredScorer;
use crate::segment::index::hnsw_index::tests::create_graph_layer_builder_fixture;
use crate::segment::types::Distance;
use crate::segment::vector_storage::DEFAULT_STOPPED;

fn search_in_builder(
    builder: &GraphLayersBuilder,
    top: usize,
    ef: usize,
    mut points_scorer: FilteredScorer,
) -> Vec<ScoredPointOffset> {
    let Some(entry_point) = builder
        .get_entry_points()
        .get_entry_point(|point_id| points_scorer.filters().check_vector(point_id))
    else {
        return vec![];
    };

    let zero_level_entry = builder
        .search_entry(
            entry_point.point_id,
            entry_point.level,
            0,
            &mut points_scorer,
            &DEFAULT_STOPPED,
        )
        .unwrap();

    let nearest = builder
        .search_on_level(
            zero_level_entry,
            0,
            max(top, ef),
            &mut points_scorer,
            &DEFAULT_STOPPED,
        )
        .unwrap();
    nearest.into_iter_sorted().take(top).collect_vec()
}

/// Check that HNSW index with raw and compacted links gives the same results
#[rstest]
#[case::uncompressed(GraphLinksFormat::Plain)]
#[case::compressed(GraphLinksFormat::Compressed)]
#[case::compressed_with_vectors(GraphLinksFormat::CompressedWithVectors)]
fn test_compact_graph_layers(#[case] format: GraphLinksFormat) {
    let num_vectors = 1000;
    let num_queries = 100;
    let m = 16;
    let dim = 8;
    let top = 5;
    let ef = 100;

    let mut rng = StdRng::seed_from_u64(42);

    let (vector_holder, graph_layers_builder) = create_graph_layer_builder_fixture(
        num_vectors,
        m,
        dim,
        false,
        format.is_with_vectors(),
        Distance::Cosine,
        &mut rng,
    );

    let queries = (0..num_queries)
        .map(|_| random_vector(&mut rng, dim))
        .collect_vec();

    let reference_results = queries
        .iter()
        .map(|query| {
            let scorer = vector_holder.scorer(query.clone());
            search_in_builder(&graph_layers_builder, top, ef, scorer)
        })
        .collect_vec();

    let graph_layers = graph_layers_builder.into_graph_layers_ram(
        format.with_param_for_tests(vector_holder.graph_links_vectors().as_ref()),
    );

    let results = queries
        .iter()
        .map(|query| {
            let scorer = vector_holder.scorer(query.clone());
            graph_layers
                .search(
                    top,
                    ef,
                    SearchAlgorithm::Hnsw,
                    scorer,
                    None,
                    &DEFAULT_STOPPED,
                )
                .unwrap()
        })
        .collect_vec();

    assert_eq!(reference_results, results);
}