Struct Schema 

pub struct Schema {
    pub defaults: ValueTypes,
    pub keys: HashMap<String, ValueTypes>,
    pub cmek: Option<Cmek>,
    pub source_attached_function_id: Option<String>,
}

Schema representation for collection index configurations

This represents the server-side schema structure used for index management

Fields

defaults: ValueTypes

Default index configurations for each value type

keys: HashMap<String, ValueTypes>

Key-specific index overrides TODO(Sanket): Needed for backwards compatibility. Should remove after deploy.

cmek: Option<Cmek>

Customer-managed encryption key for collection data

source_attached_function_id: Option<String>

ID of the attached function that created this output collection (if applicable)

Implementations

impl Schema

pub fn update(&mut self, configuration: &InternalUpdateCollectionConfiguration)

pub fn is_sparse_index_enabled(&self) -> bool

impl Schema

pub fn new_default(default_knn_index: KnnIndex) -> Self

Create a new Schema with strongly-typed default configurations

pub fn get_internal_spann_config(&self) -> Option<InternalSpannConfiguration>

pub fn get_internal_hnsw_config(&self) -> Option<InternalHnswConfiguration>

pub fn get_internal_hnsw_config_with_legacy_fallback( &self, segment: &Segment, ) -> Result<Option<InternalHnswConfiguration>, HnswParametersFromSegmentError>

pub fn reconcile_with_defaults( user_schema: Option<&Schema>, knn_index: KnnIndex, ) -> Result<Self, SchemaError>

Reconcile user-provided schema with system defaults

This method merges user configurations with system defaults, ensuring that:

• User overrides take precedence over defaults
• Missing user configurations fall back to system defaults
• Field-level merging for complex configurations (Vector, HNSW, SPANN, etc.)

pub fn merge(&self, other: &Schema) -> Result<Schema, SchemaError>

Merge two schemas together, combining key overrides when possible.

pub fn reconcile_with_collection_config( schema: &Schema, collection_config: &InternalCollectionConfiguration, default_knn_index: KnnIndex, ) -> Result<Schema, SchemaError>

Reconcile Schema with InternalCollectionConfiguration

Simple reconciliation logic:

1. If collection config is default → return schema (schema is source of truth)
2. If collection config is non-default and schema is default → override schema with collection config

Note: The case where both are non-default is validated earlier in reconcile_schema_and_config

pub fn reconcile_schema_and_config( schema: Option<&Schema>, configuration: Option<&InternalCollectionConfiguration>, knn_index: KnnIndex, ) -> Result<Schema, SchemaError>

pub fn default_with_embedding_function( embedding_function: EmbeddingFunctionConfiguration, ) -> Schema

pub fn is_default(&self) -> bool

Check if schema is default by checking each field individually

pub fn is_metadata_type_index_enabled( &self, key: &str, value_type: MetadataValueType, ) -> Result<bool, SchemaError>

Check if a specific metadata key-value should be indexed based on schema configuration

pub fn is_metadata_where_indexing_enabled( &self, where_clause: &Where, ) -> Result<(), FilterValidationError>

pub fn is_knn_key_indexing_enabled( &self, key: &str, query: &QueryVector, ) -> Result<(), FilterValidationError>

pub fn ensure_key_from_metadata( &mut self, key: &str, value_type: MetadataValueType, ) -> bool

pub fn create_index( self, key: Option<&str>, config: IndexConfig, ) -> Result<Self, SchemaBuilderError>

Create an index configuration (builder pattern)

This method allows fluent, chainable configuration of indexes on a schema. It matches the Python API’s .create_index() method.

Arguments

• key - Optional key name for per-key index. None applies to defaults/special keys
• config - Index configuration to create

Returns

Self for method chaining

Errors

Returns error if:

• Attempting to create index on special keys (#document, #embedding)
• Invalid configuration (e.g., vector index on non-embedding key)
• Conflicting with existing indexes (e.g., multiple sparse vector indexes)

Examples

use chroma_types::{Schema, VectorIndexConfig, StringInvertedIndexConfig, Space, SchemaBuilderError};

let schema = Schema::default()
    .create_index(None, VectorIndexConfig {
        space: Some(Space::Cosine),
        embedding_function: None,
        source_key: None,
        hnsw: None,
        spann: None,
    }.into())?
    .create_index(Some("category"), StringInvertedIndexConfig {}.into())?;

pub fn delete_index( self, key: Option<&str>, config: IndexConfig, ) -> Result<Self, SchemaBuilderError>

Delete/disable an index configuration (builder pattern)

This method allows disabling indexes on a schema. It matches the Python API’s .delete_index() method.

Arguments

• key - Optional key name for per-key index. None applies to defaults
• config - Index configuration to disable

Returns

Self for method chaining

Errors

Returns error if:

• Attempting to delete index on special keys (#document, #embedding)
• Attempting to delete vector, FTS, or sparse vector indexes (not currently supported)

Examples

use chroma_types::{Schema, StringInvertedIndexConfig, SchemaBuilderError};

let schema = Schema::default()
    .delete_index(Some("category"), StringInvertedIndexConfig {}.into())?;

pub fn with_cmek(self, cmek: Cmek) -> Self

Set customer-managed encryption key for the collection (builder pattern)

This method allows setting CMEK on a schema for fluent, chainable configuration.

Arguments

• cmek - Customer-managed encryption key configuration

Returns

Self for method chaining

Examples

use chroma_types::{Schema, Cmek};

let schema = Schema::default()
    .with_cmek(Cmek::gcp("projects/my-project/locations/us/keyRings/my-ring/cryptoKeys/my-key".to_string()));

Trait Implementations

impl Clone for Schema

fn clone(&self) -> Schema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Schema

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

Formats the value using the given formatter.

impl Default for Schema

fn default() -> Self

Create a default Schema that matches Python’s behavior exactly.

Python creates a Schema with:

• All inverted indexes enabled by default (string, int, float, bool)
• Vector and FTS indexes disabled in defaults
• Special keys configured: #document (FTS enabled) and #embedding (vector enabled)
• Vector config has space=None, hnsw=None, spann=None (deferred to backend)

Examples

use chroma_types::Schema;

let schema = Schema::default();
assert!(schema.keys.contains_key("#document"));
assert!(schema.keys.contains_key("#embedding"));

impl<'de> Deserialize<'de> for Schema

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Schema

fn eq(&self, other: &Schema) -> 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 Serialize for Schema

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&InternalCollectionConfiguration> for Schema

type Error = SchemaError

The type returned in the event of a conversion error.

fn try_from( config: &InternalCollectionConfiguration, ) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&Schema> for InternalCollectionConfiguration

type Error = String

The type returned in the event of a conversion error.

fn try_from(schema: &Schema) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Schema