Struct Schema 

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

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

Implementations

impl Schema

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

pub fn apply_update_configuration( &mut self, config: &UpdateCollectionConfiguration, ) -> Result<(), SchemaError>

Apply updates from UpdateCollectionConfiguration.

Only supports updating:

• spann: SPANN configuration parameters (search_nprobe, ef_search)
• embedding_function: Embedding function configuration

Returns an error if:

• hnsw is provided (HNSW updates are not supported)
• Schema is missing expected structure (defaults/embedding vector index or spann config)

pub fn is_sparse_index_enabled(&self) -> bool

pub fn is_maxscore_enabled(&self) -> bool

Check if any sparse index is configured to use MaxScore.

pub fn enabled_sparse_keys(&self) -> Vec<String>

Metadata keys that have an enabled sparse vector index, in sorted order for deterministic iteration. Each key owns one independent sparse index.

pub fn is_key_maxscore_enabled(&self, key: &str) -> bool

Whether the sparse index on a specific metadata key uses MaxScore. Falls back to the schema defaults when the key has no explicit config. Defaults to WAND (false) when nothing is configured.

pub fn set_sparse_algorithm(&mut self, algorithm: SparseIndexAlgorithm)

Set the sparse index algorithm on all sparse index configs (defaults and every key-specific config).

pub fn is_fts_enabled(&self) -> bool

pub fn is_token_bitmap_fts_enabled(&self) -> bool

Check if the FTS index is configured to use TokenBitmap.

pub fn set_fts_algorithm(&mut self, algorithm: FtsAlgorithm)

Set the FTS index algorithm on all FTS index configs (defaults and every key-specific config).

impl Schema

pub fn new_default(default_knn_index: KnnIndex) -> Self

Create a new Schema with strongly-typed default configurations

pub fn new_record_only() -> Self

Create a record-only Schema with all indexing disabled.

Suitable for output collections that are never queried via vector search, metadata filtering, or full-text search Records are stored but no inverted, vector, FTS, or sparse indexes are built at query-planning time.

pub fn get_spann_config(&self) -> Option<(SpannIndexConfig, Space)>

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

pub fn is_quantization_enabled(&self) -> bool

Check if quantization is enabled in the SPANN index configuration

pub fn get_spann_config_mut(&mut self) -> Option<&mut SpannIndexConfig>

Get a mutable reference to the SPANN index configuration Checks the #embedding key first, then falls back to defaults

pub fn quantize(&mut self, variant: Quantization)

Set the quantization variant and apply impl-specific SPANN config defaults. Note: this intentionally skips SpannIndexConfig::validate() because the hardcoded quantization defaults (e.g. split_threshold=512) exceed the user-facing validation ranges. Those ranges gate user input only; programmatic defaults set here are known-good constants.

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_key_unindexed( &self, key: &str, value_type: MetadataValueType, ) -> bool

Returns true if the inverted index is disabled for the given key and value type. Used to determine if the larger document size quota should apply for unindexed fields.

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 StructuralPartialEq for Schema

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.