reddb-io-server 1.2.0

RedDB server-side engine: storage, runtime, replication, MCP, AI, and the gRPC/HTTP/RedWire/PG-wire dispatchers. Re-exported by the umbrella `reddb` crate.
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

use std::cmp::Ordering;

use crate::storage::engine::distance::{distance, DistanceMetric};
use crate::storage::{EntityId, SimilarResult, UnifiedEntity};

#[derive(Debug, Clone)]
pub(crate) struct VectorIndexEntry {
    pub entity_id: EntityId,
    pub vector: Vec<f32>,
    pub entity: UnifiedEntity,
}

#[derive(Debug, Default)]
pub(crate) struct BruteForceVectorIndex {
    entries: Vec<VectorIndexEntry>,
}

impl BruteForceVectorIndex {
    pub(crate) fn upsert(&mut self, entry: VectorIndexEntry) {
        if let Some(existing) = self
            .entries
            .iter_mut()
            .find(|existing| existing.entity_id == entry.entity_id)
        {
            *existing = entry;
        } else {
            self.entries.push(entry);
        }
    }

    pub(crate) fn delete(&mut self, entity_id: EntityId) {
        self.entries.retain(|entry| entry.entity_id != entity_id);
    }

    pub(crate) fn search(
        &self,
        query: &[f32],
        k: usize,
        metric: DistanceMetric,
        threshold: Option<f32>,
    ) -> Vec<SimilarResult> {
        let mut results: Vec<SimilarResult> = self
            .entries
            .iter()
            .filter(|entry| entry.vector.len() == query.len())
            .filter_map(|entry| {
                let raw_distance = distance(query, &entry.vector, metric);
                let score = vector_score(raw_distance, metric);
                if !within_threshold(score, raw_distance, metric, threshold) {
                    return None;
                }
                Some(SimilarResult {
                    entity_id: entry.entity_id,
                    score,
                    distance: raw_distance,
                    entity: entry.entity.clone(),
                })
            })
            .collect();

        results.sort_by(|left, right| {
            right
                .score
                .partial_cmp(&left.score)
                .unwrap_or(Ordering::Equal)
                .then_with(|| left.entity_id.raw().cmp(&right.entity_id.raw()))
        });
        results.truncate(k);
        results
    }
}

fn vector_score(distance: f32, metric: DistanceMetric) -> f32 {
    match metric {
        DistanceMetric::Cosine => 1.0 - distance,
        DistanceMetric::InnerProduct | DistanceMetric::L2 => -distance,
    }
}

fn within_threshold(
    score: f32,
    distance: f32,
    metric: DistanceMetric,
    threshold: Option<f32>,
) -> bool {
    let Some(threshold) = threshold else {
        return true;
    };
    match metric {
        DistanceMetric::L2 => distance <= threshold,
        DistanceMetric::Cosine | DistanceMetric::InnerProduct => score >= threshold,
    }
}