Enum Key 

pub enum Key {
    Document,
    Embedding,
    Metadata,
    Score,
    MetadataField(String),
}

Represents a field key in search queries.

Used for both selecting fields to return and building filter expressions. Predefined keys access special fields, while custom keys access metadata.

Predefined Keys

• Key::Document - Document text content (#document)
• Key::Embedding - Vector embeddings (#embedding)
• Key::Metadata - All metadata fields (#metadata)
• Key::Score - Search scores (#score)

Custom Keys

Use Key::field() or Key::from() to reference metadata fields:

use chroma_types::operator::Key;

let key = Key::field("author");
let key = Key::from("title");

Examples

Building filters

use chroma_types::operator::Key;

// Equality
let filter = Key::field("status").eq("published");

// Comparisons
let filter = Key::field("year").gte(2020);
let filter = Key::field("score").lt(0.9);

// Set operations
let filter = Key::field("category").is_in(vec!["tech", "science"]);
let filter = Key::field("status").not_in(vec!["deleted", "archived"]);

// Document content
let filter = Key::Document.contains("machine learning");
let filter = Key::Document.regex(r"\bAPI\b");

// Combining filters
let filter = Key::field("status").eq("published")
    & Key::field("year").gte(2020);

Selecting fields

use chroma_types::plan::SearchPayload;
use chroma_types::operator::Key;

let search = SearchPayload::default()
    .select([
        Key::Document,
        Key::Score,
        Key::field("title"),
        Key::field("author"),
    ]);

Variants

Document

Embedding

Metadata

Score

MetadataField(String)

Implementations

impl Key

pub fn field(name: impl Into<String>) -> Key

Creates a Key for a custom metadata field.

Examples

use chroma_types::operator::Key;

let status = Key::field("status");
let year = Key::field("year");
let author = Key::field("author");

pub fn eq<T>(self, value: T) -> Where

where T: Into<MetadataValue>,

Creates an equality filter: field == value.

Examples

use chroma_types::operator::Key;

// String equality
let filter = Key::field("status").eq("published");

// Numeric equality
let filter = Key::field("count").eq(42);

// Boolean equality
let filter = Key::field("featured").eq(true);

pub fn ne<T>(self, value: T) -> Where

where T: Into<MetadataValue>,

Creates an inequality filter: field != value.

Examples

use chroma_types::operator::Key;

let filter = Key::field("status").ne("deleted");
let filter = Key::field("count").ne(0);

pub fn gt<T>(self, value: T) -> Where

where T: Into<MetadataValue>,

Creates a greater-than filter: field > value (numeric only).

Examples

use chroma_types::operator::Key;

let filter = Key::field("score").gt(0.5);
let filter = Key::field("year").gt(2020);

pub fn gte<T>(self, value: T) -> Where

where T: Into<MetadataValue>,

Creates a greater-than-or-equal filter: field >= value (numeric only).

Examples

use chroma_types::operator::Key;

let filter = Key::field("score").gte(0.5);
let filter = Key::field("year").gte(2020);

pub fn lt<T>(self, value: T) -> Where

where T: Into<MetadataValue>,

Creates a less-than filter: field < value (numeric only).

Examples

use chroma_types::operator::Key;

let filter = Key::field("score").lt(0.9);
let filter = Key::field("year").lt(2025);

pub fn lte<T>(self, value: T) -> Where

where T: Into<MetadataValue>,

Creates a less-than-or-equal filter: field <= value (numeric only).

Examples

use chroma_types::operator::Key;

let filter = Key::field("score").lte(0.9);
let filter = Key::field("year").lte(2024);

pub fn is_in<I, T>(self, values: I) -> Where

where I: IntoIterator<Item = T>, Vec<T>: Into<MetadataSetValue>,

Creates a set membership filter: field IN values.

Accepts any iterator (Vec, array, slice, etc.).

Examples

use chroma_types::operator::Key;

// With Vec
let filter = Key::field("year").is_in(vec![2023, 2024, 2025]);

// With array
let filter = Key::field("category").is_in(["tech", "science", "math"]);

// With owned strings
let categories = vec!["tech".to_string(), "science".to_string()];
let filter = Key::field("category").is_in(categories);

pub fn not_in<I, T>(self, values: I) -> Where

where I: IntoIterator<Item = T>, Vec<T>: Into<MetadataSetValue>,

Creates a set exclusion filter: field NOT IN values.

Accepts any iterator (Vec, array, slice, etc.).

Examples

use chroma_types::operator::Key;

// Exclude deleted and archived
let filter = Key::field("status").not_in(vec!["deleted", "archived"]);

// Exclude specific years
let filter = Key::field("year").not_in(vec![2019, 2020]);

pub fn contains<S>(self, text: S) -> Where

where S: Into<String>,

Creates a substring filter (case-sensitive, document content only).

Note: Currently only works with Key::Document. Pattern must have at least 3 literal characters for accurate results.

Examples

use chroma_types::operator::Key;

let filter = Key::Document.contains("machine learning");
let filter = Key::Document.contains("API");

pub fn not_contains<S>(self, text: S) -> Where

where S: Into<String>,

Creates a negative substring filter (case-sensitive, document content only).

Note: Currently only works with Key::Document.

Examples

use chroma_types::operator::Key;

let filter = Key::Document.not_contains("deprecated");
let filter = Key::Document.not_contains("beta");

pub fn regex<S>(self, pattern: S) -> Where

where S: Into<String>,

Creates a regex filter (case-sensitive, document content only).

Note: Currently only works with Key::Document. Pattern must have at least 3 literal characters for accurate results.

Examples

use chroma_types::operator::Key;

// Match whole word "API"
let filter = Key::Document.regex(r"\bAPI\b");

// Match version pattern
let filter = Key::Document.regex(r"v\d+\.\d+\.\d+");

pub fn not_regex<S>(self, pattern: S) -> Where

where S: Into<String>,

Creates a negative regex filter (case-sensitive, document content only).

Note: Currently only works with Key::Document.

Examples

use chroma_types::operator::Key;

// Exclude beta versions
let filter = Key::Document.not_regex(r"beta");

// Exclude test documents
let filter = Key::Document.not_regex(r"\btest\b");

Trait Implementations

impl Clone for Key

fn clone(&self) -> Key

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Key

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Key

fn deserialize<D>( deserializer: D, ) -> Result<Key, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Key

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

Formats the value using the given formatter.

impl From<&str> for Key

fn from(s: &str) -> Key

Converts to this type from the input type.

impl From<String> for Key

fn from(s: String) -> Key

Converts to this type from the input type.

impl Hash for Key

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Key

fn cmp(&self, other: &Key) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Key

fn eq(&self, other: &Key) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Key

fn partial_cmp(&self, other: &Key) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Key

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 Eq for Key

impl StructuralPartialEq for Key