Struct HybridQuery 

pub struct HybridQuery {
    pub collection: String,
    pub vector: Option<VectorQueryComponent>,
    pub lexical: Option<LexicalQueryComponent>,
    pub filters: Vec<MetadataFilter>,
    pub fusion: FusionConfig,
    pub rerank: Option<RerankConfig>,
    pub limit: usize,
    pub min_score: Option<f32>,
}

Builder for hybrid retrieval queries

Fields

collection: String

Collection to search

vector: Option<VectorQueryComponent>

Vector search component

lexical: Option<LexicalQueryComponent>

Lexical (BM25) search component

filters: Vec<MetadataFilter>

Metadata filters

fusion: FusionConfig

Fusion configuration

rerank: Option<RerankConfig>

Reranking configuration

limit: usize

Result limit

min_score: Option<f32>

Minimum score threshold

Implementations

impl HybridQuery

pub fn new(collection: &str) -> Self

Create a new hybrid query builder

pub fn with_vector(self, embedding: Vec<f32>, weight: f32) -> Self

Add vector search component

pub fn with_vector_text(self, text: String, weight: f32) -> Self

Add vector search from text (requires embedding provider)

pub fn with_lexical(self, query: &str, weight: f32) -> Self

Add lexical (BM25) search component

pub fn with_lexical_fields( self, query: &str, weight: f32, fields: Vec<String>, ) -> Self

Add lexical search with specific fields

pub fn filter(self, field: &str, op: FilterOp, value: SochValue) -> Self

Add metadata filter

pub fn filter_eq(self, field: &str, value: impl Into<SochValue>) -> Self

Add equality filter

pub fn filter_range( self, field: &str, min: Option<SochValue>, max: Option<SochValue>, ) -> Self

Add range filter

pub fn with_fusion(self, method: FusionMethod) -> Self

Set fusion method

pub fn with_rrf_k(self, k: f32) -> Self

Set RRF k parameter

pub fn with_rerank(self, model: &str, top_n: usize) -> Self

Enable reranking

pub fn limit(self, limit: usize) -> Self

Set result limit

pub fn min_score(self, score: f32) -> Self

Set minimum score threshold

Trait Implementations

impl Clone for HybridQuery

fn clone(&self) -> HybridQuery

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HybridQuery

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.