Introduce a lot of search parameters and make Deserr happy

crates/milli/src/index.rs

@@ -1695,7 +1695,7 @@ impl Index {
 
     pub fn chat_config(&self, txn: &RoTxn<'_>) -> heed::Result<ChatConfig> {
         self.main
-            .remap_types::<Str, SerdeBincode<_>>()
+            .remap_types::<Str, SerdeJson<_>>()
             .get(txn, main_key::CHAT)
             .map(|o| o.unwrap_or_default())
     }
@@ -1705,7 +1705,7 @@ impl Index {
         txn: &mut RwTxn<'_>,
         val: &ChatConfig,
     ) -> heed::Result<()> {
-        self.main.remap_types::<Str, SerdeBincode<_>>().put(txn, main_key::CHAT, &val)
+        self.main.remap_types::<Str, SerdeJson<_>>().put(txn, main_key::CHAT, &val)
     }
 
     pub(crate) fn delete_chat_config(&self, txn: &mut RwTxn<'_>) -> heed::Result<bool> {
@@ -1943,15 +1943,54 @@ pub struct ChatConfig {
     pub description: String,
     /// Contains the document template and max template length.
     pub prompt: PromptData,
+    pub search_parameters: SearchParameters,
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchParameters {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub hybrid: Option<HybridQuery>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sort: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub distinct: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub matching_strategy: Option<MatchingStrategy>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attributes_to_search_on: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ranking_score_threshold: Option<f64>,
+}
+
+#[derive(Debug, Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HybridQuery {
+    pub semantic_ratio: f32,
+    pub embedder: String,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct PrefixSettings {
     pub prefix_count_threshold: usize,
     pub max_prefix_length: usize,
     pub compute_prefixes: PrefixSearch,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum MatchingStrategy {
+    /// Remove query words from last to first
+    Last,
+    /// All query words are mandatory
+    All,
+    /// Remove query words from the most frequent to the least
+    Frequency,
+}
+
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default)]
 #[serde(rename_all = "camelCase")]
 pub enum PrefixSearch {

crates/milli/src/update/chat.rs

@@ -1,14 +1,19 @@
+use std::error::Error;
+use std::fmt;
+
+use deserr::errors::JsonError;
 use deserr::Deserr;
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
-use crate::index::ChatConfig;
+use crate::index::{self, ChatConfig, SearchParameters};
 use crate::prompt::{default_max_bytes, PromptData};
 use crate::update::Setting;
+use crate::TermsMatchingStrategy;
 
-#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Deserr, ToSchema)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Deserr, ToSchema)]
 #[serde(deny_unknown_fields, rename_all = "camelCase")]
-#[deserr(deny_unknown_fields, rename_all = camelCase)]
+#[deserr(error = JsonError, deny_unknown_fields, rename_all = camelCase)]
 pub struct ChatSettings {
     #[serde(default, skip_serializing_if = "Setting::is_not_set")]
     #[deserr(default)]
@@ -29,17 +34,226 @@ pub struct ChatSettings {
     #[deserr(default)]
     #[schema(value_type = Option<usize>)]
     pub document_template_max_bytes: Setting<usize>,
+
+    /// The search parameters to use for the LLM.
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<ChatSearchParams>)]
+    pub search_parameters: Setting<ChatSearchParams>,
 }
 
 impl From<ChatConfig> for ChatSettings {
     fn from(config: ChatConfig) -> Self {
-        let ChatConfig { description, prompt: PromptData { template, max_bytes } } = config;
+        let ChatConfig {
+            description,
+            prompt: PromptData { template, max_bytes },
+            search_parameters,
+        } = config;
         ChatSettings {
             description: Setting::Set(description),
             document_template: Setting::Set(template),
             document_template_max_bytes: Setting::Set(
                 max_bytes.unwrap_or(default_max_bytes()).get(),
             ),
+            search_parameters: Setting::Set({
+                let SearchParameters {
+                    hybrid,
+                    limit,
+                    sort,
+                    distinct,
+                    matching_strategy,
+                    attributes_to_search_on,
+                    ranking_score_threshold,
+                } = search_parameters;
+
+                let hybrid = hybrid.map(|index::HybridQuery { semantic_ratio, embedder }| {
+                    HybridQuery { semantic_ratio: SemanticRatio(semantic_ratio), embedder }
+                });
+
+                let matching_strategy = matching_strategy.map(|ms| match ms {
+                    index::MatchingStrategy::Last => MatchingStrategy::Last,
+                    index::MatchingStrategy::All => MatchingStrategy::All,
+                    index::MatchingStrategy::Frequency => MatchingStrategy::Frequency,
+                });
+
+                let ranking_score_threshold = ranking_score_threshold.map(RankingScoreThreshold);
+
+                ChatSearchParams {
+                    hybrid: Setting::some_or_not_set(hybrid),
+                    limit: Setting::some_or_not_set(limit),
+                    sort: Setting::some_or_not_set(sort),
+                    distinct: Setting::some_or_not_set(distinct),
+                    matching_strategy: Setting::some_or_not_set(matching_strategy),
+                    attributes_to_search_on: Setting::some_or_not_set(attributes_to_search_on),
+                    ranking_score_threshold: Setting::some_or_not_set(ranking_score_threshold),
+                }
+            }),
         }
     }
 }
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Deserr, ToSchema)]
+#[serde(deny_unknown_fields, rename_all = "camelCase")]
+#[deserr(error = JsonError, deny_unknown_fields, rename_all = camelCase)]
+pub struct ChatSearchParams {
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<HybridQuery>)]
+    pub hybrid: Setting<HybridQuery>,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default = Setting::Set(20))]
+    #[schema(value_type = Option<usize>)]
+    pub limit: Setting<usize>,
+
+    // #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    // #[deserr(default)]
+    // pub attributes_to_retrieve: Option<BTreeSet<String>>,
+
+    // #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    // #[deserr(default)]
+    // pub filter: Option<Value>,
+    //
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<Vec<String>>)]
+    pub sort: Setting<Vec<String>>,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<String>)]
+    pub distinct: Setting<String>,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<MatchingStrategy>)]
+    pub matching_strategy: Setting<MatchingStrategy>,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<Vec<String>>)]
+    pub attributes_to_search_on: Setting<Vec<String>>,
+
+    #[serde(default, skip_serializing_if = "Setting::is_not_set")]
+    #[deserr(default)]
+    #[schema(value_type = Option<RankingScoreThreshold>)]
+    pub ranking_score_threshold: Setting<RankingScoreThreshold>,
+}
+
+#[derive(Debug, Clone, Default, Deserr, ToSchema, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[deserr(error = JsonError, rename_all = camelCase, deny_unknown_fields)]
+pub struct HybridQuery {
+    #[deserr(default)]
+    #[serde(default)]
+    #[schema(default, value_type = f32)]
+    pub semantic_ratio: SemanticRatio,
+    #[schema(value_type = String)]
+    pub embedder: String,
+}
+
+#[derive(Debug, Clone, Copy, Deserr, ToSchema, PartialEq, Serialize, Deserialize)]
+#[deserr(try_from(f32) = TryFrom::try_from -> InvalidSearchSemanticRatio)]
+pub struct SemanticRatio(f32);
+
+impl Default for SemanticRatio {
+    fn default() -> Self {
+        SemanticRatio(0.5)
+    }
+}
+
+impl std::convert::TryFrom<f32> for SemanticRatio {
+    type Error = InvalidSearchSemanticRatio;
+
+    fn try_from(f: f32) -> Result<Self, Self::Error> {
+        // the suggested "fix" is: `!(0.0..=1.0).contains(&f)`` which is allegedly less readable
+        #[allow(clippy::manual_range_contains)]
+        if f > 1.0 || f < 0.0 {
+            Err(InvalidSearchSemanticRatio)
+        } else {
+            Ok(SemanticRatio(f))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct InvalidSearchSemanticRatio;
+
+impl Error for InvalidSearchSemanticRatio {}
+
+impl fmt::Display for InvalidSearchSemanticRatio {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "the value of `semanticRatio` is invalid, expected a float between `0.0` and `1.0`."
+        )
+    }
+}
+
+impl std::ops::Deref for SemanticRatio {
+    type Target = f32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Deserr, ToSchema, Serialize, Deserialize)]
+#[deserr(rename_all = camelCase)]
+#[serde(rename_all = "camelCase")]
+pub enum MatchingStrategy {
+    /// Remove query words from last to first
+    Last,
+    /// All query words are mandatory
+    All,
+    /// Remove query words from the most frequent to the least
+    Frequency,
+}
+
+impl Default for MatchingStrategy {
+    fn default() -> Self {
+        Self::Last
+    }
+}
+
+impl From<MatchingStrategy> for TermsMatchingStrategy {
+    fn from(other: MatchingStrategy) -> Self {
+        match other {
+            MatchingStrategy::Last => Self::Last,
+            MatchingStrategy::All => Self::All,
+            MatchingStrategy::Frequency => Self::Frequency,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Deserr, ToSchema, Serialize, Deserialize)]
+#[deserr(try_from(f64) = TryFrom::try_from -> InvalidSearchRankingScoreThreshold)]
+pub struct RankingScoreThreshold(pub f64);
+
+impl std::convert::TryFrom<f64> for RankingScoreThreshold {
+    type Error = InvalidSearchRankingScoreThreshold;
+
+    fn try_from(f: f64) -> Result<Self, Self::Error> {
+        // the suggested "fix" is: `!(0.0..=1.0).contains(&f)`` which is allegedly less readable
+        #[allow(clippy::manual_range_contains)]
+        if f > 1.0 || f < 0.0 {
+            Err(InvalidSearchRankingScoreThreshold)
+        } else {
+            Ok(RankingScoreThreshold(f))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct InvalidSearchRankingScoreThreshold;
+
+impl Error for InvalidSearchRankingScoreThreshold {}
+
+impl fmt::Display for InvalidSearchRankingScoreThreshold {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "the value of `rankingScoreThreshold` is invalid, expected a float between `0.0` and `1.0`."
+        )
+    }
+}

crates/milli/src/update/settings.rs

@@ -11,6 +11,7 @@ use roaring::RoaringBitmap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use time::OffsetDateTime;
 
+use super::chat::{ChatSearchParams, RankingScoreThreshold};
 use super::del_add::{DelAdd, DelAddOperation};
 use super::index_documents::{IndexDocumentsConfig, Transform};
 use super::{ChatSettings, IndexerConfig};
@@ -22,8 +23,8 @@ use crate::error::UserError;
 use crate::fields_ids_map::metadata::{FieldIdMapWithMetadata, MetadataBuilder};
 use crate::filterable_attributes_rules::match_faceted_field;
 use crate::index::{
-    ChatConfig, IndexEmbeddingConfig, PrefixSearch, DEFAULT_MIN_WORD_LEN_ONE_TYPO,
-    DEFAULT_MIN_WORD_LEN_TWO_TYPOS,
+    ChatConfig, IndexEmbeddingConfig, MatchingStrategy, PrefixSearch,
+    DEFAULT_MIN_WORD_LEN_ONE_TYPO, DEFAULT_MIN_WORD_LEN_TWO_TYPOS,
 };
 use crate::order_by_map::OrderByMap;
 use crate::prompt::{default_max_bytes, PromptData};
@@ -1263,11 +1264,13 @@ impl<'a, 't, 'i> Settings<'a, 't, 'i> {
                 description: new_description,
                 document_template: new_document_template,
                 document_template_max_bytes: new_document_template_max_bytes,
+                search_parameters: new_search_parameters,
             }) => {
                 let mut old = self.index.chat_config(self.wtxn)?;
                 let ChatConfig {
                     ref mut description,
                     prompt: PromptData { ref mut template, ref mut max_bytes },
+                    ref mut search_parameters,
                 } = old;
 
                 match new_description {
@@ -1288,6 +1291,85 @@ impl<'a, 't, 'i> Settings<'a, 't, 'i> {
                     Setting::NotSet => (),
                 }
 
+                match new_search_parameters {
+                    Setting::Set(sp) => {
+                        let ChatSearchParams {
+                            hybrid,
+                            limit,
+                            sort,
+                            distinct,
+                            matching_strategy,
+                            attributes_to_search_on,
+                            ranking_score_threshold,
+                        } = sp;
+
+                        match hybrid {
+                            Setting::Set(hybrid) => {
+                                search_parameters.hybrid = Some(crate::index::HybridQuery {
+                                    semantic_ratio: *hybrid.semantic_ratio,
+                                    embedder: hybrid.embedder.clone(),
+                                })
+                            }
+                            Setting::Reset => search_parameters.hybrid = None,
+                            Setting::NotSet => (),
+                        }
+
+                        match limit {
+                            Setting::Set(limit) => search_parameters.limit = Some(*limit),
+                            Setting::Reset => search_parameters.limit = None,
+                            Setting::NotSet => (),
+                        }
+
+                        match sort {
+                            Setting::Set(sort) => search_parameters.sort = Some(sort.clone()),
+                            Setting::Reset => search_parameters.sort = None,
+                            Setting::NotSet => (),
+                        }
+
+                        match distinct {
+                            Setting::Set(distinct) => {
+                                search_parameters.distinct = Some(distinct.clone())
+                            }
+                            Setting::Reset => search_parameters.distinct = None,
+                            Setting::NotSet => (),
+                        }
+
+                        match matching_strategy {
+                            Setting::Set(matching_strategy) => {
+                                let strategy = match matching_strategy {
+                                    super::chat::MatchingStrategy::Last => MatchingStrategy::Last,
+                                    super::chat::MatchingStrategy::All => MatchingStrategy::All,
+                                    super::chat::MatchingStrategy::Frequency => {
+                                        MatchingStrategy::Frequency
+                                    }
+                                };
+                                search_parameters.matching_strategy = Some(strategy)
+                            }
+                            Setting::Reset => search_parameters.matching_strategy = None,
+                            Setting::NotSet => (),
+                        }
+
+                        match attributes_to_search_on {
+                            Setting::Set(attributes_to_search_on) => {
+                                search_parameters.attributes_to_search_on =
+                                    Some(attributes_to_search_on.clone())
+                            }
+                            Setting::Reset => search_parameters.attributes_to_search_on = None,
+                            Setting::NotSet => (),
+                        }
+
+                        match ranking_score_threshold {
+                            Setting::Set(RankingScoreThreshold(score)) => {
+                                search_parameters.ranking_score_threshold = Some(*score)
+                            }
+                            Setting::Reset => search_parameters.ranking_score_threshold = None,
+                            Setting::NotSet => (),
+                        }
+                    }
+                    Setting::Reset => *search_parameters = Default::default(),
+                    Setting::NotSet => (),
+                }
+
                 self.index.put_chat_config(self.wtxn, &old)?;
                 Ok(true)
             }