cortex_sdk/client/
search.rs

1use super::transport::decode_value;
2use super::CortexDbClient;
3use crate::http::path;
4use crate::{
5    AnnEvaluationResponse, SdkResult, SearchExplainResponse, SearchResponse, VectorAlgorithm,
6};
7
8impl CortexDbClient {
9    pub fn search_keyword(
10        &self,
11        scope: &str,
12        query: &str,
13        limit: usize,
14    ) -> SdkResult<serde_json::Value> {
15        self.post(
16            &path(
17                "/v1/search",
18                &[
19                    ("scope", scope),
20                    ("mode", "keyword"),
21                    ("q", query),
22                    ("limit", &limit.to_string()),
23                ],
24            ),
25            "",
26        )
27    }
28
29    pub fn search_keyword_response(
30        &self,
31        scope: &str,
32        query: &str,
33        limit: usize,
34    ) -> SdkResult<SearchResponse> {
35        decode_value(self.search_keyword(scope, query, limit)?)
36    }
37
38    pub fn search_auto(
39        &self,
40        scope: &str,
41        query: &str,
42        vector: Option<&str>,
43        limit: usize,
44    ) -> SdkResult<serde_json::Value> {
45        let limit = limit.to_string();
46        let mut params = vec![
47            ("scope", scope),
48            ("mode", "auto"),
49            ("q", query),
50            ("limit", limit.as_str()),
51        ];
52        if let Some(vector) = vector {
53            params.push(("vector", vector));
54        }
55        self.post(&path("/v1/search", &params), "")
56    }
57
58    pub fn search_auto_response(
59        &self,
60        scope: &str,
61        query: &str,
62        vector: Option<&str>,
63        limit: usize,
64    ) -> SdkResult<SearchResponse> {
65        decode_value(self.search_auto(scope, query, vector, limit)?)
66    }
67
68    pub fn search_explain(
69        &self,
70        scope: &str,
71        query: &str,
72        mode: &str,
73        vector: Option<&str>,
74        limit: usize,
75    ) -> SdkResult<serde_json::Value> {
76        let limit = limit.to_string();
77        let mut params = vec![
78            ("scope", scope),
79            ("mode", mode),
80            ("q", query),
81            ("limit", limit.as_str()),
82        ];
83        if let Some(vector) = vector {
84            params.push(("vector", vector));
85        }
86        self.post(&path("/v1/search/explain", &params), "")
87    }
88
89    pub fn search_explain_response(
90        &self,
91        scope: &str,
92        query: &str,
93        mode: &str,
94        vector: Option<&str>,
95        limit: usize,
96    ) -> SdkResult<SearchExplainResponse> {
97        decode_value(self.search_explain(scope, query, mode, vector, limit)?)
98    }
99
100    pub fn search_vector(
101        &self,
102        scope: &str,
103        vector: &[i16],
104        algorithm: VectorAlgorithm,
105        limit: usize,
106    ) -> SdkResult<serde_json::Value> {
107        let literal = vector
108            .iter()
109            .map(i16::to_string)
110            .collect::<Vec<_>>()
111            .join(",");
112        self.post(
113            &path(
114                "/v1/search",
115                &[
116                    ("scope", scope),
117                    ("mode", "vector"),
118                    ("algorithm", algorithm.as_str()),
119                    ("vector", &literal),
120                    ("limit", &limit.to_string()),
121                ],
122            ),
123            "",
124        )
125    }
126
127    pub fn search_vector_response(
128        &self,
129        scope: &str,
130        vector: &[i16],
131        algorithm: VectorAlgorithm,
132        limit: usize,
133    ) -> SdkResult<SearchResponse> {
134        decode_value(self.search_vector(scope, vector, algorithm, limit)?)
135    }
136
137    pub fn evaluate_ann(
138        &self,
139        scope: &str,
140        vector: &[i16],
141        limit: usize,
142    ) -> SdkResult<serde_json::Value> {
143        let literal = vector
144            .iter()
145            .map(i16::to_string)
146            .collect::<Vec<_>>()
147            .join(",");
148        self.post(
149            &path(
150                "/v1/search/ann-evaluate",
151                &[
152                    ("scope", scope),
153                    ("vector", &literal),
154                    ("limit", &limit.to_string()),
155                ],
156            ),
157            "",
158        )
159    }
160
161    pub fn evaluate_ann_response(
162        &self,
163        scope: &str,
164        vector: &[i16],
165        limit: usize,
166    ) -> SdkResult<AnnEvaluationResponse> {
167        decode_value(self.evaluate_ann(scope, vector, limit)?)
168    }
169}
cortex_sdk/client/search.rs

cortex_sdk/client/
search.rs
