use crate::client::Client;
use crate::common::Usage;
use crate::error::Error;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
#[non_exhaustive]
pub enum EncodingFormat {
#[default]
Float,
Base64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum EmbeddingsInput {
Text(String),
TextBatch(Vec<String>),
Tokens(Vec<i64>),
TokensBatch(Vec<Vec<i64>>),
}
impl From<String> for EmbeddingsInput {
fn from(s: String) -> Self {
Self::Text(s)
}
}
impl From<&str> for EmbeddingsInput {
fn from(s: &str) -> Self {
Self::Text(s.to_owned())
}
}
impl From<Vec<String>> for EmbeddingsInput {
fn from(v: Vec<String>) -> Self {
Self::TextBatch(v)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmbeddingsRequest {
pub input: EmbeddingsInput,
pub model: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub dimensions: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub encoding_format: Option<EncodingFormat>,
}
impl EmbeddingsRequest {
pub fn new(input: impl Into<EmbeddingsInput>, model: impl Into<String>) -> Self {
Self {
input: input.into(),
model: model.into(),
dimensions: None,
encoding_format: None,
}
}
#[must_use]
pub fn dimensions(mut self, dimensions: u32) -> Self {
self.dimensions = Some(dimensions);
self
}
#[must_use]
pub fn encoding_format(mut self, format: EncodingFormat) -> Self {
self.encoding_format = Some(format);
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Embedding {
pub embedding: Vec<f64>,
pub index: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Embeddings {
pub data: Vec<Embedding>,
pub model: String,
#[serde(default)]
pub id: Option<String>,
#[serde(default)]
pub usage: Option<Usage>,
}
impl Client {
pub async fn embeddings(&self, req: &EmbeddingsRequest) -> Result<Embeddings, Error> {
let url = self.endpoint("/v1/embeddings")?;
self.post_json(url, req).await
}
}