use crate::chunks::Chunk;
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 SearchMethod {
Hybrid,
#[default]
Semantic,
Lexical,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct CreateSearch {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub query: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub collection_ids: Vec<i64>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub document_ids: Vec<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata_filters: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub offset: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub method: Option<SearchMethod>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub rff_k: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub score_threshold: Option<f64>,
}
impl CreateSearch {
pub fn new(query: impl Into<String>) -> Self {
Self {
query: Some(query.into()),
..Self::default()
}
}
#[must_use]
pub fn collections(mut self, ids: impl IntoIterator<Item = i64>) -> Self {
self.collection_ids = ids.into_iter().collect();
self
}
#[must_use]
pub fn documents(mut self, ids: impl IntoIterator<Item = i64>) -> Self {
self.document_ids = ids.into_iter().collect();
self
}
#[must_use]
pub fn limit(mut self, limit: i64) -> Self {
self.limit = Some(limit);
self
}
#[must_use]
pub fn method(mut self, method: SearchMethod) -> Self {
self.method = Some(method);
self
}
#[must_use]
pub fn score_threshold(mut self, threshold: f64) -> Self {
self.score_threshold = Some(threshold);
self
}
#[must_use]
pub fn metadata_filters(mut self, filters: serde_json::Value) -> Self {
self.metadata_filters = Some(filters);
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Search {
pub method: SearchMethod,
pub score: f64,
pub chunk: Chunk,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct Searches {
pub data: Vec<Search>,
#[serde(default)]
pub usage: Option<Usage>,
}
impl Client {
pub async fn search(&self, req: &CreateSearch) -> Result<Searches, Error> {
let url = self.endpoint("/v1/search")?;
self.post_json(url, req).await
}
}