rig_core/providers/voyageai/
wire.rs1use crate::client::env::{self, EnvError};
10use crate::embeddings::Embedding as Vector;
11use crate::error::EncodeError;
12use crate::error::ProviderError;
13use crate::operation::{Embedding, Rerank as RerankOp, RerankRequest};
14use crate::rerank::{RerankResponse, RerankResult};
15use crate::wire::Flow;
16use crate::wire::{
17 Body, Capabilities, Decoder, Descriptor, Encoded, Framing, Mode, Out, Secret, Wire, WireEvent,
18 WireFrame,
19};
20use serde::{Deserialize, Serialize};
21
22use super::{
23 EmbeddingResponse as VoyageEmbeddingResponse, RerankApiResponse, RerankErrorEnvelope,
24 VOYAGEAI_API_BASE_URL, model_dimensions_from_identifier,
25};
26
27const PROVIDER_NAME: &str = "voyageai";
29
30const API_KEY_ENV: &str = "VOYAGE_API_KEY";
32
33const MAX_DOCUMENTS: usize = 1024;
35
36const MAX_RERANK_DOCUMENTS: usize = 1000;
38
39#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct VoyageAiConfig {
44 pub api_key: Secret,
46 pub base_url: String,
48}
49
50impl VoyageAiConfig {
51 pub fn new(api_key: impl Into<Secret>) -> Self {
53 Self {
54 api_key: api_key.into(),
55 base_url: VOYAGEAI_API_BASE_URL.to_owned(),
56 }
57 }
58
59 pub fn from_env() -> Result<Self, EnvError> {
61 Ok(Self::new(env::required(API_KEY_ENV)?))
62 }
63
64 pub fn with_base_url(mut self, base_url: impl AsRef<str>) -> Self {
66 self.base_url = base_url.as_ref().trim_end_matches('/').to_owned();
67 self
68 }
69
70 pub(crate) fn embedding(&self, model: impl Into<String>, ndims: Option<usize>) -> Embeddings {
74 let model = model.into();
75 let ndims = ndims
76 .or_else(|| model_dimensions_from_identifier(&model))
77 .unwrap_or_default();
78 Embeddings {
79 provider: self.clone(),
80 model,
81 ndims,
82 input_type: None,
83 truncation: None,
84 output_dimension: None,
85 }
86 }
87
88 pub(crate) fn rerank(&self, model: impl Into<String>) -> Rerank {
90 Rerank {
91 provider: self.clone(),
92 model: model.into(),
93 top_k: None,
94 return_documents: false,
95 truncation: None,
96 }
97 }
98
99 fn post(&self, path: &str) -> http::request::Builder {
101 http::Request::post(format!("{}{path}", self.base_url))
102 .header(http::header::CONTENT_TYPE, "application/json")
103 .header(
104 http::header::AUTHORIZATION,
105 format!("Bearer {}", self.api_key.expose()),
106 )
107 }
108}
109
110#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
116pub struct Embeddings {
117 pub provider: VoyageAiConfig,
119 pub model: String,
121 pub ndims: usize,
124 pub input_type: Option<String>,
128 pub truncation: Option<bool>,
131 pub output_dimension: Option<usize>,
134}
135
136impl Embeddings {
137 pub fn with_input_type(mut self, input_type: impl Into<String>) -> Self {
139 self.input_type = Some(input_type.into());
140 self
141 }
142
143 pub fn with_truncation(mut self, truncation: bool) -> Self {
145 self.truncation = Some(truncation);
146 self
147 }
148
149 pub fn with_output_dimension(mut self, output_dimension: usize) -> Self {
154 self.output_dimension = Some(output_dimension);
155 self.ndims = output_dimension;
156 self
157 }
158}
159
160impl Wire for Embeddings {
161 type Op = Embedding;
162 type Payload = crate::wire::Encoded;
163 type Frame = crate::wire::WireFrame;
164 type Decoder<'id> = EmbeddingsDecoder;
165
166 fn describe(&self) -> Descriptor<'_> {
167 Descriptor::new(PROVIDER_NAME)
168 .model(self.model.as_str())
169 .capabilities(Capabilities::embedding(MAX_DOCUMENTS, self.ndims))
170 }
171
172 fn encode(&self, texts: Vec<String>, _mode: Mode) -> Result<Encoded, EncodeError> {
173 let mut body = serde_json::Map::new();
174 body.insert("model".to_owned(), serde_json::json!(self.model));
175 body.insert("input".to_owned(), serde_json::json!(texts));
176 if let Some(input_type) = &self.input_type {
177 body.insert("input_type".to_owned(), serde_json::json!(input_type));
178 }
179 if let Some(truncation) = self.truncation {
180 body.insert("truncation".to_owned(), serde_json::json!(truncation));
181 }
182 if let Some(output_dimension) = self.output_dimension {
183 body.insert(
184 "output_dimension".to_owned(),
185 serde_json::json!(output_dimension),
186 );
187 }
188 let request = self
189 .provider
190 .post("/embeddings")
191 .body(Body::Bytes(serde_json::to_vec(&body)?))?;
192 Ok(Encoded::new(request, Framing::Whole))
193 }
194
195 fn decoder<'id>(&self) -> Self::Decoder<'id> {
196 EmbeddingsDecoder
197 }
198}
199
200pub struct EmbeddingsDecoder;
202
203impl<'id> Decoder<'id, Embedding> for EmbeddingsDecoder {
204 type Event = VoyageEmbeddingResponse;
205
206 fn classify(&self, frame: WireFrame) -> WireEvent<Self::Event> {
207 crate::providers::internal::wire::classify_marker_keyed_frame(&frame.as_str(), &["data"])
208 }
209
210 fn decode(
211 &mut self,
212 reply: Self::Event,
213 out: Out<'id, Embedding>,
214 ) -> Result<Flow, ProviderError> {
215 let usage = crate::completion::Usage {
217 input_tokens: Some(reply.usage.total_tokens as u64),
218 total_tokens: Some(reply.usage.total_tokens as u64),
219 ..Default::default()
220 };
221 let vectors = reply
224 .data
225 .into_iter()
226 .map(|embedding| Vector {
227 document: String::new(),
228 vec: embedding.embedding,
229 })
230 .collect();
231 Ok(out.end(crate::embeddings::EmbeddingResponse {
232 model: Some(reply.model),
233 usage,
234 ..crate::embeddings::EmbeddingResponse::new(vectors)
235 }))
236 }
237}
238
239#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
241pub struct Rerank {
242 pub provider: VoyageAiConfig,
244 pub model: String,
246 pub top_k: Option<usize>,
249 pub return_documents: bool,
251 pub truncation: Option<bool>,
254}
255
256impl Rerank {
257 pub fn with_top_k(mut self, top_k: usize) -> Self {
259 self.top_k = Some(top_k);
260 self
261 }
262
263 pub fn with_return_documents(mut self, return_documents: bool) -> Self {
265 self.return_documents = return_documents;
266 self
267 }
268
269 pub fn with_truncation(mut self, truncation: bool) -> Self {
271 self.truncation = Some(truncation);
272 self
273 }
274}
275
276impl Wire for Rerank {
277 type Op = RerankOp;
278 type Payload = crate::wire::Encoded;
279 type Frame = crate::wire::WireFrame;
280 type Decoder<'id> = RerankDecoder;
281
282 fn describe(&self) -> Descriptor<'_> {
283 Descriptor::new(PROVIDER_NAME)
284 .model(self.model.as_str())
285 .capabilities(Capabilities::rerank(MAX_RERANK_DOCUMENTS))
286 }
287
288 fn encode(&self, request: RerankRequest, _mode: Mode) -> Result<Encoded, EncodeError> {
289 let mut body = serde_json::Map::new();
290 body.insert("query".to_owned(), serde_json::json!(request.query));
291 body.insert("documents".to_owned(), serde_json::json!(request.documents));
292 body.insert("model".to_owned(), serde_json::json!(self.model));
293 if let Some(top_k) = self.top_k {
294 body.insert("top_k".to_owned(), serde_json::json!(top_k));
295 }
296 body.insert(
297 "return_documents".to_owned(),
298 serde_json::json!(self.return_documents),
299 );
300 if let Some(truncation) = self.truncation {
301 body.insert("truncation".to_owned(), serde_json::json!(truncation));
302 }
303 let request = self
304 .provider
305 .post("/rerank")
306 .body(Body::Bytes(serde_json::to_vec(&body)?))?;
307 Ok(Encoded::new(request, Framing::Whole))
308 }
309
310 fn decoder<'id>(&self) -> Self::Decoder<'id> {
311 RerankDecoder
312 }
313}
314
315const RERANK_REPLY_MARKERS: &[&str] = &["data", "message"];
318
319const RERANK_ERROR_MARKERS: &[&str] = &["message"];
321
322pub enum RerankReply {
325 Reply(RerankApiResponse),
327 Failure(String),
329}
330
331pub struct RerankDecoder;
333
334impl<'id> Decoder<'id, RerankOp> for RerankDecoder {
335 type Event = RerankReply;
336
337 fn classify(&self, frame: WireFrame) -> WireEvent<Self::Event> {
340 let data = frame.as_str();
341 crate::providers::internal::wire::classify_or(
342 &data,
343 |data| {
344 crate::providers::internal::wire::classify_marker_keyed_frame::<RerankApiResponse>(
345 data,
346 RERANK_REPLY_MARKERS,
347 )
348 .map(RerankReply::Reply)
349 },
350 |data| {
351 crate::providers::internal::wire::classify_marker_keyed_frame::<RerankErrorEnvelope>(
352 data,
353 RERANK_ERROR_MARKERS,
354 )
355 .map(|_| RerankReply::Failure(data.to_owned()))
356 },
357 )
358 }
359
360 fn decode(
361 &mut self,
362 reply: Self::Event,
363 out: Out<'id, RerankOp>,
364 ) -> Result<Flow, ProviderError> {
365 let reply = match reply {
366 RerankReply::Reply(reply) => reply,
367 RerankReply::Failure(body) => {
369 return Err(ProviderError::from_provider_body(body));
370 }
371 };
372 let usage = crate::completion::Usage {
374 input_tokens: Some(reply.usage.total_tokens as u64),
375 total_tokens: Some(reply.usage.total_tokens as u64),
376 ..Default::default()
377 };
378 let results = reply
379 .data
380 .into_iter()
381 .map(|result| RerankResult {
382 index: result.index,
383 document: result.document,
384 relevance_score: result.relevance_score,
385 })
386 .collect();
387 Ok(out.end(RerankResponse {
388 model: Some(reply.model),
389 usage,
390 ..RerankResponse::new(results)
391 }))
392 }
393}
394
395#[cfg(test)]
396mod tests;