Enum RankExpr 

pub enum RankExpr {
    Absolute(Box<RankExpr>),
    Division {
        left: Box<RankExpr>,
        right: Box<RankExpr>,
    },
    Exponentiation(Box<RankExpr>),
    Knn {
        query: QueryVector,
        key: Key,
        limit: u32,
        default: Option<f32>,
        return_rank: bool,
    },
    Logarithm(Box<RankExpr>),
    Maximum(Vec<RankExpr>),
    Minimum(Vec<RankExpr>),
    Multiplication(Vec<RankExpr>),
    Subtraction {
        left: Box<RankExpr>,
        right: Box<RankExpr>,
    },
    Summation(Vec<RankExpr>),
    Value(f32),
}

A ranking expression for scoring and ordering search results.

Ranking expressions determine which documents appear in results and their order. Lower scores indicate better matches (distance-based scoring).

Variants

Knn - K-Nearest Neighbor Search

The primary ranking method for vector similarity search.

use chroma_types::operator::{RankExpr, QueryVector, Key};

let rank = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,        // Consider top 100 candidates
    default: None,     // No default score for missing documents
    return_rank: false, // Return distances, not rank positions
};

Value - Constant

Represents a constant score.

use chroma_types::operator::RankExpr;

let rank = RankExpr::Value(0.5);

Arithmetic Operations

Combine ranking expressions using standard operators (+, -, *, /).

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn1 = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

let knn2 = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.2, 0.3, 0.4]),
    key: Key::field("other_embedding"),
    limit: 100,
    default: None,
    return_rank: false,
};

// Weighted combination: 70% knn1 + 30% knn2
let combined = knn1 * 0.7 + knn2 * 0.3;

// Normalized
let normalized = combined / 2.0;

Mathematical Functions

Apply mathematical transformations to scores.

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

// Exponential - amplifies differences
let amplified = knn.clone().exp();

// Logarithm - compresses range (add constant to avoid log(0))
let compressed = (knn.clone() + 1.0).log();

// Absolute value
let absolute = knn.clone().abs();

// Min/Max - clamping
let clamped = knn.min(1.0).max(0.0);

Examples

Basic vector search

use chroma_types::operator::{RankExpr, QueryVector, Key};

let rank = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

Hybrid search with weighted combination

use chroma_types::operator::{RankExpr, QueryVector, Key};

let dense = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 200,
    default: None,
    return_rank: false,
};

let sparse = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]), // Use sparse in practice
    key: Key::field("sparse_embedding"),
    limit: 200,
    default: None,
    return_rank: false,
};

// 70% semantic + 30% keyword
let hybrid = dense * 0.7 + sparse * 0.3;

Reciprocal Rank Fusion (RRF)

Use the rrf() function for combining rankings with different score scales.

use chroma_types::operator::{RankExpr, QueryVector, Key, rrf};

let dense = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 200,
    default: None,
    return_rank: true, // RRF requires rank positions
};

let sparse = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::field("sparse_embedding"),
    limit: 200,
    default: None,
    return_rank: true, // RRF requires rank positions
};

let rrf_rank = rrf(
    vec![dense, sparse],
    Some(60),           // k parameter (smoothing)
    Some(vec![0.7, 0.3]), // weights
    false,              // normalize weights
).unwrap();

Variants

Absolute(Box<RankExpr>)

Division

Fields

left: Box<RankExpr>

right: Box<RankExpr>

Exponentiation(Box<RankExpr>)

Knn

Fields

query: QueryVector

key: Key

limit: u32

default: Option<f32>

return_rank: bool

Logarithm(Box<RankExpr>)

Maximum(Vec<RankExpr>)

Minimum(Vec<RankExpr>)

Multiplication(Vec<RankExpr>)

Subtraction

Fields

left: Box<RankExpr>

right: Box<RankExpr>

Summation(Vec<RankExpr>)

Value(f32)

Implementations

impl RankExpr

pub fn default_knn_key() -> Key

pub fn default_knn_limit() -> u32

pub fn knn_queries(&self) -> Vec<KnnQuery>

pub fn exp(self) -> RankExpr

Applies exponential transformation: e^rank.

Amplifies differences between scores.

Examples

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

let amplified = knn.exp();

pub fn log(self) -> RankExpr

Applies natural logarithm transformation: ln(rank).

Compresses the score range. Add a constant to avoid log(0).

Examples

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

// Add constant to avoid log(0)
let compressed = (knn + 1.0).log();

pub fn abs(self) -> RankExpr

Takes absolute value of the ranking expression.

Examples

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn1 = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

let knn2 = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.2, 0.3, 0.4]),
    key: Key::field("other"),
    limit: 100,
    default: None,
    return_rank: false,
};

// Absolute difference
let diff = (knn1 - knn2).abs();

pub fn max(self, other: impl Into<RankExpr>) -> RankExpr

Returns maximum of this expression and another.

Can be chained to clamp scores to a maximum value.

Examples

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

// Clamp to maximum of 1.0
let clamped = knn.clone().max(1.0);

// Clamp to range [0.0, 1.0]
let range_clamped = knn.min(0.0).max(1.0);

pub fn min(self, other: impl Into<RankExpr>) -> RankExpr

Returns minimum of this expression and another.

Can be chained to clamp scores to a minimum value.

Examples

use chroma_types::operator::{RankExpr, QueryVector, Key};

let knn = RankExpr::Knn {
    query: QueryVector::Dense(vec![0.1, 0.2, 0.3]),
    key: Key::Embedding,
    limit: 100,
    default: None,
    return_rank: false,
};

// Clamp to minimum of 0.0 (ensure non-negative)
let clamped = knn.clone().min(0.0);

// Clamp to range [0.0, 1.0]
let range_clamped = knn.min(0.0).max(1.0);

Trait Implementations

impl Add<f32> for RankExpr

type Output = RankExpr

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> <RankExpr as Add<f32>>::Output

Performs the + operation.

impl Add for RankExpr

type Output = RankExpr

The resulting type after applying the + operator.

fn add(self, rhs: RankExpr) -> <RankExpr as Add>::Output

Performs the + operation.

impl Clone for RankExpr

fn clone(&self) -> RankExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RankExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RankExpr

fn deserialize<__D>( __deserializer: __D, ) -> Result<RankExpr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for RankExpr

type Output = RankExpr

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> <RankExpr as Div<f32>>::Output

Performs the / operation.

impl Div for RankExpr

type Output = RankExpr

The resulting type after applying the / operator.

fn div(self, rhs: RankExpr) -> <RankExpr as Div>::Output

Performs the / operation.

impl From<f32> for RankExpr

fn from(v: f32) -> RankExpr

Converts to this type from the input type.

impl Mul<f32> for RankExpr

type Output = RankExpr

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> <RankExpr as Mul<f32>>::Output

Performs the * operation.

impl Mul for RankExpr

type Output = RankExpr

The resulting type after applying the * operator.

fn mul(self, rhs: RankExpr) -> <RankExpr as Mul>::Output

Performs the * operation.

impl Neg for RankExpr

type Output = RankExpr

The resulting type after applying the - operator.

fn neg(self) -> <RankExpr as Neg>::Output

Performs the unary - operation.

impl Serialize for RankExpr

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<f32> for RankExpr

type Output = RankExpr

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> <RankExpr as Sub<f32>>::Output

Performs the - operation.

impl Sub for RankExpr

type Output = RankExpr

The resulting type after applying the - operator.

fn sub(self, rhs: RankExpr) -> <RankExpr as Sub>::Output

Performs the - operation.

impl TryFrom<RankExpr> for RankExpr

type Error = QueryConversionError

The type returned in the event of a conversion error.

fn try_from( proto_expr: RankExpr, ) -> Result<RankExpr, <RankExpr as TryFrom<RankExpr>>::Error>

Performs the conversion.