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
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use super::*;
impl RuntimeQueryPort for RedDBRuntime {
    fn execute_query(&self, query: &str) -> RedDBResult<RuntimeQueryResult> {
        RedDBRuntime::execute_query(self, query)
    }

    fn explain_query(&self, query: &str) -> RedDBResult<RuntimeQueryExplain> {
        RedDBRuntime::explain_query(self, query)
    }

    fn scan_collection(
        &self,
        collection: &str,
        cursor: Option<ScanCursor>,
        limit: usize,
    ) -> RedDBResult<ScanPage> {
        RedDBRuntime::scan_collection(self, collection, cursor, limit)
    }

    fn search_similar(
        &self,
        collection: &str,
        vector: &[f32],
        k: usize,
        min_score: f32,
    ) -> RedDBResult<Vec<SimilarResult>> {
        super::ensure_collection_model_read(
            &self.db(),
            collection,
            crate::catalog::CollectionModel::Vector,
        )?;
        RedDBRuntime::search_similar(self, collection, vector, k, min_score)
    }

    fn search_ivf(
        &self,
        collection: &str,
        vector: &[f32],
        k: usize,
        n_lists: usize,
        n_probes: Option<usize>,
    ) -> RedDBResult<RuntimeIvfSearchResult> {
        super::ensure_collection_model_read(
            &self.db(),
            collection,
            crate::catalog::CollectionModel::Vector,
        )?;
        RedDBRuntime::search_ivf(self, collection, vector, k, n_lists, n_probes)
    }

    fn search_hybrid(
        &self,
        vector: Option<Vec<f32>>,
        query: Option<String>,
        k: Option<usize>,
        collections: Option<Vec<String>>,
        entity_types: Option<Vec<String>>,
        capabilities: Option<Vec<String>>,
        graph_pattern: Option<RuntimeGraphPattern>,
        filters: Vec<RuntimeFilter>,
        weights: Option<RuntimeQueryWeights>,
        min_score: Option<f32>,
        limit: Option<usize>,
    ) -> RedDBResult<DslQueryResult> {
        RedDBRuntime::search_hybrid(
            self,
            vector,
            query,
            k,
            collections,
            entity_types,
            capabilities,
            graph_pattern,
            filters,
            weights,
            min_score,
            limit,
        )
    }

    fn search_text(
        &self,
        query: String,
        collections: Option<Vec<String>>,
        entity_types: Option<Vec<String>>,
        capabilities: Option<Vec<String>>,
        fields: Option<Vec<String>>,
        limit: Option<usize>,
        fuzzy: bool,
    ) -> RedDBResult<DslQueryResult> {
        RedDBRuntime::search_text(
            self,
            query,
            collections,
            entity_types,
            capabilities,
            fields,
            limit,
            fuzzy,
        )
    }

    fn search_multimodal(
        &self,
        query: String,
        collections: Option<Vec<String>>,
        entity_types: Option<Vec<String>>,
        capabilities: Option<Vec<String>>,
        limit: Option<usize>,
    ) -> RedDBResult<DslQueryResult> {
        RedDBRuntime::search_multimodal(self, query, collections, entity_types, capabilities, limit)
    }

    fn search_index(
        &self,
        index: String,
        value: String,
        exact: bool,
        collections: Option<Vec<String>>,
        entity_types: Option<Vec<String>>,
        capabilities: Option<Vec<String>>,
        limit: Option<usize>,
    ) -> RedDBResult<DslQueryResult> {
        RedDBRuntime::search_index(
            self,
            index,
            value,
            exact,
            collections,
            entity_types,
            capabilities,
            limit,
        )
    }

    fn search_context(
        &self,
        input: crate::application::SearchContextInput,
    ) -> RedDBResult<crate::runtime::ContextSearchResult> {
        RedDBRuntime::search_context(self, input)
    }

    fn resolve_semantic_api_key(&self, provider: &crate::ai::AiProvider) -> RedDBResult<String> {
        crate::ai::resolve_api_key_from_runtime(provider, None, self)
    }
}