use khive_fusion::{FusionStrategy, FusionStrategyError};
use khive_score::DeterministicScore;
use serde::{Deserialize, Serialize};
pub const HYBRID_CANDIDATE_MULTIPLIER: u32 = 4;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum QueryNode {
Vector {
embedding: Vec<f32>,
top_k: usize,
min_score: Option<DeterministicScore>,
},
Keyword {
text: String,
top_k: usize,
min_score: Option<DeterministicScore>,
},
Fuse {
children: Vec<QueryNode>,
strategy: FuseStrategy,
top_k: usize,
},
Collect {
children: Vec<QueryNode>,
},
Filter {
child: Box<QueryNode>,
predicate: FilterPredicate,
},
Rerank {
child: Box<QueryNode>,
method: RerankMethod,
top_k: usize,
},
Empty,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FuseStrategy {
Rrf {
k: usize,
},
Weighted {
weights: Vec<f64>,
},
WeightedRrf {
k: usize,
weights: Vec<f64>,
},
Union,
VectorOnly,
KeywordOnly,
Custom {
name: String,
params: serde_json::Value,
},
}
impl From<FusionStrategy> for FuseStrategy {
fn from(strategy: FusionStrategy) -> Self {
match strategy {
FusionStrategy::Rrf { k } => Self::Rrf { k },
FusionStrategy::Weighted { weights } => Self::Weighted { weights },
FusionStrategy::WeightedRrf { k, weights } => Self::WeightedRrf { k, weights },
FusionStrategy::Union => Self::Union,
FusionStrategy::VectorOnly => Self::VectorOnly,
FusionStrategy::KeywordOnly => Self::KeywordOnly,
FusionStrategy::Custom { name, params } => Self::Custom { name, params },
}
}
}
impl TryFrom<FuseStrategy> for FusionStrategy {
type Error = FusionStrategyError;
fn try_from(strategy: FuseStrategy) -> Result<Self, Self::Error> {
match strategy {
FuseStrategy::Rrf { k } => Self::try_rrf(k),
FuseStrategy::Weighted { weights } => Self::try_weighted(weights),
FuseStrategy::WeightedRrf { k, weights } => Self::try_weighted_rrf(k, weights),
FuseStrategy::Union => Ok(Self::Union),
FuseStrategy::VectorOnly => Ok(Self::VectorOnly),
FuseStrategy::KeywordOnly => Ok(Self::KeywordOnly),
FuseStrategy::Custom { name, params } => Self::try_custom(name, params),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum FilterPredicate {
MinScore(DeterministicScore),
TopK(usize),
MetadataEquals {
field: String,
value: serde_json::Value,
},
And(Vec<FilterPredicate>),
Or(Vec<FilterPredicate>),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RerankMethod {
CrossEncoder {
model: String,
},
ScoreWeighted {
weights: Vec<f64>,
},
}
impl QueryNode {
pub fn vector(embedding: Vec<f32>, top_k: usize) -> Self {
QueryNode::Vector {
embedding,
top_k,
min_score: None,
}
}
pub fn keyword(text: impl Into<String>, top_k: usize) -> Self {
QueryNode::Keyword {
text: text.into(),
top_k,
min_score: None,
}
}
pub fn hybrid(embedding: Vec<f32>, text: impl Into<String>, top_k: usize) -> Self {
let candidate_k = top_k.saturating_mul(HYBRID_CANDIDATE_MULTIPLIER as usize);
QueryNode::Fuse {
children: vec![
QueryNode::vector(embedding, candidate_k),
QueryNode::keyword(text, candidate_k),
],
strategy: FuseStrategy::Rrf { k: 60 },
top_k,
}
}
#[must_use]
pub fn with_min_score(self, min_score: DeterministicScore) -> Self {
QueryNode::Filter {
child: Box::new(self),
predicate: FilterPredicate::MinScore(min_score),
}
}
#[must_use]
pub fn with_top_k(self, k: usize) -> Self {
QueryNode::Filter {
child: Box::new(self),
predicate: FilterPredicate::TopK(k),
}
}
pub fn is_empty(&self) -> bool {
match self {
QueryNode::Empty => true,
QueryNode::Vector { top_k: 0, .. } => true,
QueryNode::Keyword { top_k: 0, .. } => true,
QueryNode::Keyword { text, .. } if text.is_empty() => true,
QueryNode::Fuse { children, .. } if children.is_empty() => true,
QueryNode::Collect { children } => children.iter().all(Self::is_empty),
QueryNode::Filter { child, .. } => child.is_empty(),
QueryNode::Rerank { child, .. } => child.is_empty(),
_ => false,
}
}
pub fn leaf_count(&self) -> usize {
match self {
QueryNode::Vector { .. } | QueryNode::Keyword { .. } => 1,
QueryNode::Fuse { children, .. } | QueryNode::Collect { children } => {
children.iter().map(|c| c.leaf_count()).sum()
}
QueryNode::Filter { child, .. } | QueryNode::Rerank { child, .. } => child.leaf_count(),
QueryNode::Empty => 0,
}
}
pub fn top_k(&self) -> usize {
match self {
QueryNode::Vector { top_k, .. } => *top_k,
QueryNode::Keyword { top_k, .. } => *top_k,
QueryNode::Fuse { top_k, .. } => *top_k,
QueryNode::Collect { children } => children
.iter()
.fold(0usize, |total, child| total.saturating_add(child.top_k())),
QueryNode::Filter { child, predicate } => match predicate {
FilterPredicate::TopK(k) => *k,
_ => child.top_k(),
},
QueryNode::Rerank { top_k, .. } => *top_k,
QueryNode::Empty => 0,
}
}
pub fn depth(&self) -> usize {
match self {
QueryNode::Empty => 0,
QueryNode::Vector { .. } | QueryNode::Keyword { .. } => 1,
QueryNode::Fuse { children, .. } | QueryNode::Collect { children } => {
1 + children.iter().map(|c| c.depth()).max().unwrap_or(0)
}
QueryNode::Filter { child, .. } | QueryNode::Rerank { child, .. } => 1 + child.depth(),
}
}
}
#[cfg(test)]
#[allow(clippy::uninlined_format_args)]
#[path = "query_ir/tests.rs"]
mod tests;