Struct Schema 

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

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.

Implementations

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 reconcile_with_defaults( user_schema: Option<Schema>, ) -> 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, ) -> 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 non-default → error (both set)
3. If collection config is non-default and schema is default → override schema with collection config

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

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

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};

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};

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

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<&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