Skip to content
CAI
Software that uses CAICheck a score

chroma-core/chroma

50.9

Adequate · 14 November 2026

338.4k

lines of production code

Rust

with Python

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Anthropic inference model with thinking and caching support

The agent now supports the Anthropic Messages API via a new \AnthropicAgentInferenceModel\ in \rust/agent/src/inference\. This change introduces a provider-agnostic inference interface (\AgentInferenceModel\) and concrete implementation for Anthropic, starting with the \claude-sonnet-4-5-20250929\ model. Key capabilities include support for interleaved thinking blocks (via the \interleaved-thinking-2025-05-14\ beta flag), automatic prompt caching using ephemeral markers to reduce costs, and system prompt injection. The implementation includes robust request diagnostics that redact sensitive content (prompts, reasoning, tool inputs) for safe logging, and parses responses into actions including reasoning, text, and tool calls. It also tracks detailed token usage including cache read/write tokens for billing. Only Anthropic is currently supported.

rust/agent/src/inference · high confidence

Add GCP deployment templates for Chroma

New Terraform files (main.tf and chroma.tfvars) have been added to the GCP deployment directory, enabling users to provision a Chroma server on Google Cloud Platform. The configuration sets up a Debian 11 Compute Engine instance with Docker and Docker Compose, configures firewall rules for SSH and HTTP access, and allows customization of the Chroma version (defaulting to 1.5.9), machine type, and OpenTelemetry settings via variables.

deployments/gcp · high confidence

Add Hugging Face server-side embedding example

A new example in the \examples/server\_side\_embeddings/huggingface\ directory demonstrates how to use Chroma with a Hugging Face Text Embeddings Inference server. The addition includes a \docker-compose.yml\ file that spins up both the Chroma server and the embedding server (defaulting to the \BAAI/bge-small-en-v1.5\ model), along with a \test.ipynb\ notebook showing how to connect the \HuggingFaceEmbeddingServer\ utility to a Chroma HTTP client for embedding generation.

_examples/server\_side\embeddings · high confidence

Add Node.js and Browser example applications for ChromaDB JS client

New example applications have been added to the \clients/js/examples\ directory to demonstrate how to use the ChromaDB JavaScript client in both Node.js and browser environments. The examples illustrate the two available package options: the bundled \chromadb\ package, which includes all embedding libraries as dependencies for ease of use, and the \chromadb-client\ package, which relies on peer dependencies to allow users to manage embedding library versions and keep their dependency tree lean. The provided code shows how to initialize the client, create collections, add and query documents, and list collections using both package variants.

clients/js/examples · high confidence

Add Rust frontend service entrypoint

A new Rust-based entrypoint for the frontend service has been added, initializing a Tokio multi-thread runtime with a specific thread name and stack size before invoking the core frontend service entrypoint.

rust/frontend/src/bin · high confidence

Add gRPC client for the heap tender service

A new gRPC client has been added to the S3 heap service to communicate with the heap tender service, which is colocated with the log service. This client enables pushing schedules, pruning completed tasks, and retrieving summary statistics. It uses memberlist-based service discovery to locate heap service instances and employs a RendezvousHashing assignment policy (with Murmur3) to ensure data locality by directing heap operations to the same node handling corresponding log operations.

rust/s3heap-service/src/client · high confidence

Add shared Go utility package for logging, process management, and hashing

A new \go/pkg/utils\ package has been introduced to centralize common utilities. This includes a configurable logger using Zerolog with JSON/console output and protobuf support, helpers for running processes and handling shutdown signals, Kubernetes client initialization for both test and production environments, integration test skipping logic based on environment variables, and a rendezvous hashing implementation for key distribution across members.

go/pkg/utils · high confidence

Add spanner-cli wrapper binary

A new \spanner-cli\ binary has been added to the \spanner-migrations\ crate. This wrapper attempts to execute the Google Cloud SDK's \spanner-cli\ tool located at \/opt/homebrew/share/google-cloud-sdk/bin/spanner-cli\, forwarding all command-line arguments and preserving the exit code. If the tool is not found at the expected path, the binary exits with an error message instructing the user to install it via \gcloud components install spanner-cli\.

rust/spanner-migrations/src/bin · high confidence

Added 1-bit RaBitQ quantization support

Users can now index and query vectors using 1-bit RaBitQ quantization, which significantly reduces memory usage compared to the existing 4-bit implementation. This change introduces the \Code\<1\>\ type, a specialized \QuantizedQuery\ structure for bitwise distance estimation, and optimized single-bit quantization logic in \single\_bit.rs\. The implementation includes precomputed correction factors and signed sums to accelerate query scoring, alongside documentation detailing the mathematical derivation and performance optimizations.

rust/index/src/quantization · high confidence

Added CLI tool for managing attached functions

A new command-line interface, \chroma-task-manager\, has been added to allow users to manage attached functions directly via the command line. This tool supports attaching functions to collections (specifying input/output collections, parameters, and invocation thresholds), retrieving details of specific attached functions, and detaching functions (with an option to delete the associated output collection). It communicates with the Chroma coordinator service over gRPC.

rust/sysdb/src/bin · high confidence

Added OpenTelemetry tracing and metrics initialization with gRPC interceptor

The go/shared/otel package now provides a centralized implementation for distributed tracing and metrics collection using OpenTelemetry. It introduces a gRPC server interceptor that automatically creates spans for incoming RPC requests, enriches context with remote trace/span IDs from metadata, and records error details. Additionally, it includes an initialization function that configures both trace and metric exporters to send data via OTLP/gRPC to a specified endpoint, establishing the global tracer and meter providers for the service.

go/shared/otel · high confidence

Added WAL3 benchmark and bootstrap state-space reasoner examples

Two new example programs are now available in the \rust/wal3/examples\ directory to aid in development and testing of the WAL3 subsystem. The \wal3-bench\ tool provides a configurable benchmark for measuring write throughput and garbage collection performance against an S3-compatible storage backend, allowing users to tune parameters like target throughput and task limits. Additionally, \wal3-bootstrap-reasoner\ offers a static analysis tool that exhaustively explores the state space of the WAL3 bootstrap process (fragment states, manifest initialization, and recovery) to identify potential race conditions, panics, or invalid states, helping developers verify the robustness of the initialization logic.

rust/wal3/examples · high confidence

Added official CLI installation scripts for Windows and Unix-like systems

New installation scripts (install.ps1 for Windows and install.sh for Linux/macOS) have been added to the CLI distribution. These scripts automate the download and setup of the Chroma CLI binary (version 1.4.4) from GitHub releases, handling platform-specific assets and providing guidance for adding the binary to the system PATH.

rust/cli · high confidence

Added pprof server for heap dumps

A new HTTP server has been added to expose jemalloc profiling data via two endpoints: \/debug/pprof/flamegraph\ for SVG flamegraphs and \/debug/pprof/heap\ for pprof-formatted heap profiles. The server listens on a configurable port and requires jemalloc profiling to be enabled and activated; otherwise, it returns a 403 Forbidden response.

rust/jemalloc-pprof-server · high confidence

Added s3heap benchmark example

A new benchmark example (\s3heap-benchmark.rs\) has been added to the \rust/s3heap\ examples directory. This tool allows users to measure the performance of the S3 heap writer by simulating load with configurable throughput and runtime parameters, providing insights into operation counts and task metrics under stress.

rust/s3heap/examples · high confidence

Added sparse vector benchmark with Block-Max WAND and MaxScore support

A new benchmark example (\sparse\_vector\_benchmark.rs\) has been added to evaluate sparse vector search performance. It compares the Block-Max WAND algorithm against a brute-force baseline using the Wikipedia SPLADE dataset. The benchmark supports various modes, including filtering, profiling via flamegraphs, and testing the new MaxScore reader/writer components. Users can run this example to measure search latency and throughput under different configurations such as document count, query volume, and top-k results.

rust/index/examples · high confidence

Added systemd service examples for Chroma CLI and Docker deployments

New systemd unit files and documentation have been added to the examples directory, providing ready-to-use configurations for running Chroma as a background service. Users can now deploy Chroma using either the native CLI (via \chroma-cli.service\) or Docker Compose (via \chroma-docker.service\), enabling automatic startup on boot and crash recovery without manual intervention.

examples/deployments/systemd-service · high confidence

Agent query usage is now priced and debited against the user's budget

After each agent query completes, the system now calculates the cost of the model's token usage (including input, output, and cache tokens) based on the current Foundation price card and posts a debit to the sync-frontend's budget endpoint. This process uses an in-process cache for price rates to minimize overhead and runs on a detached task so that any failures in the billing step do not impact the user's response. The debit is posted using the caller's own authentication token, ensuring accurate attribution to the user's quota.

rust/foundation-api/src/budget · high confidence

Automated API client generation and local server startup scripts

The new JavaScript client now includes build scripts to automatically generate the API client code from the server's OpenAPI specification and start a local Chroma server for development or testing. The \gen-api.ts\ script launches the server, fetches the OpenAPI JSON, generates TypeScript types and client code using \@hey-api/openapi-ts\, and applies a specific fix to the \HashMap\ type definition to correctly handle nulls and arrays. Supporting scripts (\start-chroma.ts\, \start-chroma-jest.ts\, and \start-chroma-common.ts\) handle starting the Chroma server either via a pre-built Docker image or by building the Rust binary locally, ensuring the server is ready before client generation or tests begin.

clients/new-js/packages/chromadb/scripts · high confidence

Automated Chroma deployment with Docker and authentication support

A new startup script has been added to the common deployment examples to automate the setup of a Chroma server. The script installs Docker and its dependencies, clones the Chroma repository, and configures the environment based on provided authentication variables. It supports both basic and token-based authentication by generating the necessary .env files and server credentials, then launches the service using Docker Compose.

examples/deployments/common · high confidence

CPU and I/O thread affinity support with dispatcher configuration

The system execution layer now supports pinning worker and I/O threads to specific CPU cores to reduce cache misses and improve performance. A new \DispatcherConfig\ allows users to set \cpu\_affinity\_num\_cores\ and \io\_affinity\_num\_cores\ to define how many cores are reserved for each type of task. Worker threads are pinned sequentially from core 0, while I/O threads are pinned from the highest available core downwards. The \affinity.rs\ module implements the core-pinning logic using Linux-specific syscalls, with graceful fallbacks on non-Linux platforms. This change also introduces comprehensive OpenTelemetry metrics for the dispatcher, workers, and orchestrators to monitor queue depths, latencies, and task counts.

rust/system/src/execution · high confidence

Chroma JS client library v2.1.0 with multi-tenant support and new embedding functions

The @chromadb and @chromadb-client packages have been updated to v2.1.0, regenerated from the Chroma 1.0.0 OpenAPI specification. This release introduces multi-tenant capabilities, including a new AdminClient for managing tenants and databases, and automatic tenant resolution from user identity. It also adds support for Spann index configuration, collection forking, and querying on a subset of IDs. Several new embedding functions are now available, including Cloudflare Workers AI, Mistral, Together AI, and an updated Google Gemini function that supports image inputs. The client now includes a dedicated ChromaQuotaExceededError for billing limits, sends a user-agent header, and enforces mandatory embeddings on upsert operations.

clients/js/packages/chromadb-core · high confidence

ChromaDB JS client now bundles embedding libraries and CLI

The main \chromadb\ package is now a 'thick' client that bundles all embedding libraries (such as \chromadb-default-embed\) and the CLI tool directly into the distribution. This simplifies installation by removing the need for users to manage peer dependencies for embeddings, allowing them to use embedding functions like \OpenAIEmbeddingFunction\ out of the box. The package also includes a bundled CLI entry point, making command-line operations available within the same package.

clients/js/packages/chromadb · high confidence

Foundation API introduces agent query budget debiting

The foundation-api service now tracks and bills agent usage by posting budget debits to the sync-frontend after each agent query completes. This new \budget\ module fetches a cached price card from the sync-frontend, calculates the cost in micro-USD based on input and output token counts for the planner and context-1 models, and posts the debit as a fire-and-forget background task. The system is designed to be fail-open: if the price card is unavailable or the debit fails, the user's response is still streamed and the error is only logged as a warning.

rust/foundation-api/src · high confidence

Initial Azure deployment templates for Chroma

Added Terraform configuration files (main.tf and chroma.tfvars.tf) to the Azure deployment directory, enabling users to provision a Chroma instance on Azure. The setup creates the necessary infrastructure including a Resource Group, Virtual Network, Subnet, NSG, Public IP, and a Debian 11 Linux Virtual Machine with Docker and Docker Compose installed. It configures security rules for SSH and HTTP (port 8000) access and allows customization of the Chroma version, authentication credentials, and OpenTelemetry settings via variables.

deployments/azure · high confidence

Initial Spanner schema for tenants, databases, and collections

This change introduces the foundational Spanner database schema for the Rust system database (sysdb). It adds 18 migration files that create the core tables: \tenants\, \databases\, \collections\, \collection\_compaction\_cursors\, \collection\_segments\, and \collection\_metadata\. The schema includes necessary unique and list indexes for efficient querying, interleaves child tables for data locality, and sets up default tenant and database records. Additionally, it denormalizes tenant and database IDs into the compaction cursors table and creates a Change Data Capture (CDC) change stream to support multi-region replication and billing tracking.

rust/spanner-migrations/migrations · high confidence

Initial chroma-load daemon stub

A new load-generation daemon named 'chroma-load' has been added to the Rust load module. It includes a default configuration file (chroma\_load\_config.yaml) specifying the service name, OpenTelemetry endpoint, and port 3001. The executable itself is currently a stub that prints a message and sleeps for 24 hours, serving as the foundational structure for the load generation tool.

rust/load · high confidence

Initial heap tender service entry point with named worker threads

A new binary entry point for the heap tender service has been added. It initializes a Tokio multi-threaded runtime, explicitly names the worker threads 'chroma-heap-tender', and configures the thread stack size using the system's defined bytes, before launching the service's main entrypoint.

rust/s3heap-service/src/bin · high confidence

Initial release of gRPC service definitions for Chroma components

This change introduces the complete set of Protocol Buffer (proto3) definitions for the Chroma system, establishing the gRPC interfaces for core services including the Coordinator, Log Service, Compactor, Query Executor, Work Queue, and Heap Tender. These IDL files define the data structures and RPC contracts for collection and database management, log operations (push, pull, fork, seal), vector search execution with ranking and grouping, and background task scheduling, serving as the foundational API contract for the Rust-based backend implementation.

idl/chromadb · high confidence

Initial release of the distributed-chroma Helm chart

This change introduces the \distributed-chroma\ Helm chart (version 0.1.93, app version 0.4.24) for deploying Chroma in a distributed Kubernetes environment. The chart includes configuration files (\values.yaml\, \values.dev.yaml\) and templates for core services including the Rust frontend, sysdb, log service, query service, compaction service, work queue, function consumer, garbage collector, and sysdb migration. It also supports optional components like the foundation service and MDAC service, and includes metadata for publishing to Artifact Hub.

k8s/distributed-chroma · high confidence

Initial repository scaffolding and development environment setup

This change establishes the foundational structure for the Chroma project, introducing essential configuration files including \.dockerignore\, \.gitignore\, \.gitattributes\, and \.pre-commit-config.yaml\ to standardize local development, build isolation, and code quality checks. It adds \Dockerfile\ and \docker-compose.yml\ to define the containerized runtime and local deployment, alongside \Tiltfile\ and \docker-bake.hcl\ to orchestrate multi-service builds for the Rust and Go components. Documentation is also initialized with \README.md\, \DEVELOP.md\, \CLAUDE.md\, and \AGENTS.md\ to guide contributors, while \bandit.yaml\ and \RELEASE\_PROCESS.md\ set up security scanning and release procedures.

(repo-wide) · high confidence

Introduce Arrow-backed blockfile storage implementation

This change adds a new production-grade blockfile provider backed by Apache Arrow, replacing the previous storage mechanism. It introduces \ArrowBlockfileProvider\ which manages \ArrowUnorderedBlockfileWriter\ and \ArrowOrderedBlockfileWriter\ instances, utilizing a \BlockManager\ and \RootManager\ for handling data persistence. The implementation includes a new serialization format for the sparse index (migrating from V1 to V1.2) and supports configurable concurrency for block flushes and loads. It also adds specific Arrow key implementations for boolean, float, string, and unsigned integer types to enable efficient columnar storage and retrieval.

rust/blockstore/src/arrow · high confidence

Introduce Arrow-based Block storage with binary search and serialization support

The blockstore now uses a new \Block\ type backed by Apache Arrow RecordBatches to store key-value pairs, replacing previous implementations. This change introduces efficient binary search lookups for sorted data and adds native serialization/deserialization support for \RecordBatchWrapper\ via \serde\_bytes\, enabling blocks to be easily persisted and transferred.

rust/blockstore/src/arrow/block · high confidence

Introduce Foundation API with workspace initialization and wiki management endpoints

This change introduces the \foundation-api\ service, providing a new set of HTTP endpoints for managing the Foundation product. It adds \POST /api/init\ to idempotently bootstrap a tenant's workspace (creating the database, wiki, and source collections) and \POST /api/tenants/{tenant}/foundations\ to create named Foundations. The API also includes wiki management routes: \POST /api/upsert-page\ and \POST /api/apply-patch\ for creating and patching wiki pages, \POST /api/search\ for hybrid dense+sparse search, and \POST /api/read-page\ to reconstruct full pages from chunks. Additionally, it provides \GET /api/tenants/{tenant}/foundations\ and \GET /api/tenants/{tenant}/foundations/{foundation}\ for listing and describing Foundations, along with trajectory and agent-related endpoints.

rust/foundation-api/src/routes · high confidence

Introduce Go build tooling and Dockerfiles for the coordinator and migration services

This change adds the foundational build infrastructure for the Go codebase, including a Dockerfile that installs protoc v31.1 and Go gRPC plugins, a Makefile with targets for generating protobuf code, building the coordinator binary, and running tests sequentially to avoid flakiness, and a separate Dockerfile for running Atlas schema migrations. It also provides a README detailing local Postgres setup and the required Protobuf toolchain versions.

go · high confidence

Introduce Go-based SysDB coordinator model definitions

This change introduces the core data models for the SysDB coordinator in Go, replacing or supplementing previous definitions. It defines the \Collection\ struct with fields for compaction metrics (total records, size bytes, last compaction time), versioning, and lineage, alongside \CollectionToGc\ for garbage collection tracking. It adds a comprehensive \collection\_configuration.go\ that formalizes vector index settings (HNSW and SPANN), embedding functions, and schema structures, including support for quantization and full-text search (FTS) indices. New models for \Database\, \Tenant\, \Segment\, and \Notification\ are also added to support multi-tenancy, database management, segment lifecycle, and internal coordination events.

go/pkg/sysdb/coordinator/model · high confidence

Introduce Go-based SysDB metastore models and database interfaces

This change adds the Go database models and repository interfaces for the SysDB metastore, defining the schema for core entities including Collections, Databases, Tenants, Segments, Functions, Attached Functions, and Tasks. It introduces support for collection metadata, soft-delete states, garbage collection tracking (e.g., version files, lineage paths, compaction stats), and tenant-scoped resource names. The new \ICollectionDb\, \IDatabaseDb\, \ITenantDb\, and other interfaces provide the data access layer for managing these entities, laying the groundwork for the SysDB's role in coordinating vector storage state and function execution.

github.com/chroma-core/chroma/go · high confidence

Introduce Kubernetes-backed memberlist manager for cluster coordination

The \go/pkg/memberlist\_manager\ package now provides a new component that maintains a consistent list of active cluster members by watching Kubernetes pods and persisting the state in a custom resource. The manager uses a Kubernetes informer to detect pod lifecycle events, filters for ready pods, and reconciles the resulting member list against a persistent store (backed by a \chroma.cluster/v1\ Custom Resource). This ensures that the system's view of available nodes is kept up-to-date and durable, supporting features like leader election and service discovery within the coordinator.

_go/pkg/memberlist\manager · high confidence

Introduce Rust HTTP client with retry, failover, and metrics

The Rust SDK now includes a new \ChromaHttpClient\ implementation that handles HTTP communication with the Chroma server. This client adds automatic retry logic with exponential backoff and jitter, supports read-only backend failover via multiple endpoints, and provides OpenTelemetry metrics for request latency and retry counts when the \opentelemetry\ feature is enabled. Configuration is managed through \ChromaHttpClientOptions\, allowing users to specify authentication methods (including Cloud API keys), custom endpoints, and retry behavior.

rust/chroma/src/client · high confidence

Introduce Rust SysDB implementation with gRPC and SQLite backends

The Rust SysDB client now supports two storage backends: a production-ready gRPC client for connecting to the remote SysDB service and a local SQLite implementation for standalone or testing environments. Users can configure the active backend via the \SysDbConfig\ enum (selecting \grpc\ or \sqlite\), which allows the system to operate without a remote gRPC endpoint when using the SQLite mode. This change also includes a \TestSysDb\ in-memory implementation for unit and integration testing, ensuring that database, tenant, and collection operations are fully covered across all three backends.

rust/sysdb/src · high confidence

Introduce Rust agent core with provider-agnostic tool and trajectory abstractions

The \rust/agent\ crate now provides the foundational agent driver, replacing the previous Python-based implementation with a Rust-native state machine that manages the infer-act-observe loop. This change introduces a composable behavior system via \AgentBehavior\ hooks, allowing middleware to intercept and modify inference contexts, tool calls, and observations without subclassing. It includes a provider-agnostic tool abstraction (\Tool\/\DynTool\) that automatically generates JSON schemas for model parameters and renders tool definitions into provider-specific formats (currently Anthropic only). The trajectory system records actions and observations, supporting reasoning blocks and tool results, and renders the full history into the Anthropic Messages API format. A dummy \GetWeatherTool\ is included to exercise the full pipeline, and error handling is centralized via \AgentError\ with specific variants for tool failures, HTTP errors, and configuration issues.

rust/agent/src · high confidence

Introduce Rust cache crate with Foyer-backed hybrid caching and partitioned concurrency

The \rust/cache\ crate now provides the core caching infrastructure, introducing a \Cache\ trait and a \PersistentCache\ trait that supports disk-backed storage via the Foyer library. Users can configure memory-only, disk-only, or hybrid caches through \CacheConfig\, with the hybrid option leveraging Foyer's multi-tier storage. The implementation includes an \AsyncPartitionedMutex\ to handle concurrent access efficiently, deterministic hashing by default for stable cache keys across restarts, and utility binaries (\cops-disk-cache-config-writer\, \cops-memory-cache-config-writer\) to generate YAML configurations. This change establishes the foundation for persistent, high-performance caching in the Rust backend.

rust/cache · high confidence

Introduce Rust client library with collection and conditional transaction support

The Rust client library now provides a comprehensive API for interacting with Chroma, centered around the \ChromaCollection\ handle for managing vector embeddings and metadata. Users can perform standard CRUD operations (add, get, query, update, delete) and manage collection metadata. A key addition is support for conditional (optimistic) transactions via \ConditionalCollectionTransaction\, allowing scoped read-check-write operations with automatic retry logic for conflict resolution. The client also exposes functionality for attached functions, including adding inputs to async attached functions, and supports various indexing configurations and search operators.

rust/chroma/src · high confidence

Introduce Rust configuration crate with Spanner connection settings and dependency registry

The new \rust/config\ crate provides a centralized configuration system for the Rust backend, introducing a \Registry\ service locator for dependency injection and a \Configurable\ trait for struct initialization. It adds detailed configuration structs for Google Cloud Spanner connections, including \SpannerSessionPoolConfig\ (tuned for production with 400 max sessions) and \SpannerChannelConfig\ (with gRPC channel and keep-alive settings), as well as a \SpannerEmulatorConfig\ for local development. A helper module adds serde utilities for serializing and deserializing \std::time::Duration\ as seconds.

rust/config/src · high confidence

Introduce Rust execution plan and operator types for search queries

The Rust frontend now defines the core types for query execution plans and operators in \rust/types/src/execution\. This adds structured representations for \Scan\, \Filter\, \Knn\, \Count\, and \Get\ plans, along with a \SearchPayload\ builder for constructing hybrid search requests. These types include serialization and deserialization logic for converting between internal Rust structures and the protobuf wire format, enabling the frontend to construct and transmit query plans to workers.

rust/types/src/execution · high confidence

Introduce Rust frontend with configurable caching, schema support, and transaction gates

The Rust frontend now includes a comprehensive configuration system (\FrontendServerConfig\) that allows operators to tune core behaviors. Users can enable or disable the new schema system via the \enable\_schema\ flag, control conditional transaction support with \enable\_transactions\, and manage tenant-specific features like quantization (\tenants\_with\_quantization\_enabled\), max-score (\tenants\_with\_maxscore\_enabled\), and token-based FTS (\tenants\_with\_token\_bitmap\_fts\_enabled\). The \CollectionsWithSegmentsProvider\ introduces a cache with configurable TTL (\cache\_ttl\_secs\) and invalidation retry policies to manage sysdb lookups, while the server exposes standard HTTP settings (port, listen address, CORS origins) and distributed tracing options.

rust/frontend/src · high confidence

Introduce Rust log service implementation with gRPC and SQLite backends

This change adds a new Rust-based log service implementation located in \rust/log\, providing a unified \Log\ abstraction that can operate via gRPC against a remote log service or locally via SQLite. The implementation includes configuration for connection timeouts, message size limits, and memberlist-based client assignment, along with a local compaction manager that handles backfilling and purging dirty logs using SQLite and HNSW segments. An in-memory log variant is also provided for testing purposes.

rust/log · high confidence

Introduce Rust worker service binaries and configuration files

The rust/worker directory now includes the entry-point binaries for the query service, compaction service, function consumer, and work queue service, along with a CLI tool for interacting with the work queue. Configuration files (chroma\_config.yaml, chroma\_mcmr.yaml, chroma\_mcmr2.yaml) are added to define settings for these services, including S3 storage, block cache, and gRPC endpoints. A compaction client binary is also added to manage compaction jobs.

rust/worker · high confidence

Introduce Rust-based Chroma CLI with profile management and interactive commands

The CLI is now implemented in Rust, providing a native binary with version 1.4.4. This release adds a comprehensive set of commands including Browse, Copy, Db, Install, Login, Profile, Run, Update, and Vacuum, along with helpers for Docs and Support. Users can now manage Chroma Cloud profiles via a new config store that persists credentials in TOML and settings in JSON within the \~/.chroma directory. The interface features an interactive terminal with colored output, password masking, and clipboard integration, while also supporting local server management via the Run command.

rust/cli/src · high confidence

Introduce Rust-based Python bindings for Chroma

This change adds a new Rust implementation of the Python bindings (located in \rust/python\_bindings\), exposing core Chroma components such as the \Bindings\ class, \ConditionalTransaction\, and \ConditionalCommitPayload\ to Python via PyO3. The bindings integrate with the Rust frontend, SQLite storage, and logging systems, providing a native Rust-backed interface for collection operations, conditional transactions, and configuration management, while mapping Rust errors to corresponding Python exceptions.

_rust/python\bindings · high confidence

Introduce Rust-based SPANN index with quantization and fast writing

The SPANN vector index implementation has been rewritten in Rust, introducing a new fast writer and a quantized index variant to improve write performance and storage efficiency. This change adds support for 1-bit RABITQ quantization, configurable garbage collection policies for both posting lists and HNSW centroids, and granular locking to reduce contention during concurrent writes. Users benefit from faster indexing speeds, reduced memory footprint through quantization, and more robust handling of data updates and deletions via improved garbage collection and versioning mechanisms.

rust/index/src/spann · high confidence

Introduce Rust-based SQLite persistence layer with schema migrations

This change adds a new Rust implementation for the SQLite storage backend, including the database connection logic, a migration system, and table definitions. It introduces a comprehensive set of SQL migrations for the sysdb (collections, segments, tenants, databases), metadb (embeddings, metadata, full-text search), and embeddings\_queue (log) subsystems. The schema supports scalar and array metadata, full-text search via FTS5, and multi-tenant database isolation. The Rust code handles migration application and validation, configuration via \SqliteDBConfig\, and provides helper functions for metadata upserts and deletions.

rust/sqlite · high confidence

Introduce Rust-based distributed and local executors with tiered routing

The Rust frontend now includes a new executor module that supports both distributed and local execution modes. The distributed executor routes requests to query service nodes using configurable assignment policies, manages gRPC client connections, and enforces tier-based routing rules (matching tenant, database, collection, or size) with capacity limits. The local executor handles in-process operations using SQLite for metadata and local HNSW for vector search, including backfilling from logs and purging. Configuration is unified under ExecutorConfig, allowing users to select the mode and tune parameters like timeouts, replication factors, and tier capacities.

rust/frontend/src/executor · high confidence

Introduce S3-backed WAL3 storage interfaces

Added S3-specific implementations for the WAL3 log system, including \S3FragmentPuller\ and \S3FragmentUploader\ for reading and writing fragment data, and \ManifestManager\ and \ManifestReader\ for managing log metadata and snapshots. These components implement the \FragmentConsumer\, \FragmentUploader\, \ManifestPublisher\, and \ManifestConsumer\ traits, enabling the system to persist and retrieve WAL data and manifests in S3 storage.

rust/wal3/src/interfaces/s3 · high confidence

Introduce S3-backed distributed heap for task scheduling

Added the \s3heap\ crate, providing a distributed, persistent heap data structure backed by S3 storage to enable scheduling and processing of tasks at scale. The implementation organizes tasks into one-minute time-based buckets stored as Parquet files, supporting concurrent writes via optimistic concurrency control (ETag-based retries) and automatic deduplication. Key components include \HeapWriter\ for adding tasks, \HeapReader\ for retrieval, and a configurable \HeapScheduler\ trait that allows users to define task completion logic, making it a foundational service for future task scheduling capabilities.

rust/s3heap · high confidence

Introduce S3-based metastore implementation with GCS interoperability support

This change adds a new S3 metastore implementation for SysDB, enabling the storage of collection version and lineage files in S3-compatible object stores. The implementation upgrades the AWS SDK to v2 and includes specific middleware to ensure compatibility with Google Cloud Storage (GCS) by recalculating V4 signatures, addressing header signing issues. It also introduces a new file path structure for version and lineage files organized by tenant, database, and collection, and provides test utilities using a pinned MinIO container for local development and testing.

go/pkg/sysdb/metastore/s3 · high confidence

Introduce configurable blockfile provider abstraction

The blockstore module now exposes a unified \BlockfileProvider\ enum that abstracts over different storage backends, specifically supporting both Arrow-based persistent storage and an in-memory HashMap implementation. This change introduces a new configuration system (\BlockfileProviderConfig\) that allows users to select the provider type (Arrow or Memory) via configuration, with Arrow being the default. The provider handles reading, writing, clearing, and prefetching data through a common interface, delegating to the specific backend implementation, and supports configurable concurrency limits for block flushes and loads when using the Arrow backend.

rust/blockstore/src · high confidence

Introduce dedicated Rust API types module with OCC read tokens and error handling

A new \chroma-api-types\ crate has been added to the Rust codebase, consolidating API data structures into a separate module. This includes support for Optimistic Concurrency Control (OCC) transactional reads via \OccReadToken\ and \OccReadMode\, allowing clients to capture and pin reads to specific log snapshots. The module also defines error types for conditional write conflicts and stale reads, a payload structure for collection forking, a heartbeat response with nanosecond precision, and a user identity response exposing tenant and database access.

rust/api-types · high confidence

Introduce in-memory blockfile storage for testing

The blockstore module now includes a new in-memory implementation (\MemoryBlockfileProvider\, \MemoryBlockfileReader\, \MemoryBlockfileWriter\) backed by \HashMap\ and \BTreeMap\ structures. This allows the system to use RAM-based blockfiles for testing purposes, supporting operations like \set\, \delete\, \get\, \get\_range\, \count\, \contains\, and \rank\ for various data types including strings, byte arrays, and custom records. This change is explicitly noted as not intended for production use and serves to facilitate local development and testing workflows.

rust/blockstore/src/memory · high confidence

Introduce in-memory frontend implementation for local development

Added an in-memory implementation of the frontend service (\InMemoryFrontend\) to support local development and testing without requiring external infrastructure. This implementation provides a lightweight, stateful backend that manages tenants, databases, and collections in memory, exposing the same API surface as the production \ServiceBasedFrontend\. The module structure now exposes both the service-based and in-memory variants, with the in-memory version serving as a drop-in replacement for local environments.

rust/frontend/src/impls · high confidence

Introduce mdac-service for provider token bucket rate limiting

A new internal HTTP service (\mdac-service\) is added to enforce rate limits on foundation-model providers (Baseten, Fireworks, Anthropic, OpenAI) using a token-bucket algorithm. The service exposes a \POST /api/v1/token-bucket/put-back-and-drain\ endpoint that accepts both single objects and arrays of requests, allowing callers to refund excess tokens and request new allowances in a single call. It is configured via YAML and environment variables, supports OpenTelemetry tracing, and is deployed via Tilt and Modal.

rust/mdac-service · high confidence

Introduce new JavaScript/TypeScript client package

Adds the new JS/TS client package for Chroma, providing a JavaScript interface to interact with the Chroma DB backend over REST. This release includes the core source files, build configuration via tsup (supporting both ESM and CJS outputs), Jest testing setup, and updated documentation with examples for Chroma Cloud and local development.

clients/new-js/packages/chromadb · high confidence

Introduce new Rust-based SysDb service with multi-region Spanner backend

Adds a new Rust implementation of the SysDb service located in \rust/rust-sysdb/src\, providing a gRPC server that handles system database operations (tenants, databases, collections) via Google Cloud Spanner. The service introduces a \BackendFactory\ abstraction that routes requests to specific Spanner backends based on topology prefixes in database names, enabling multi-cloud multi-region (MCMR) support. It includes configuration loading via YAML and environment variables, OpenTelemetry tracing integration, and a complete set of internal request/response types that bridge protobuf definitions to the Spanner backend logic.

rust/rust-sysdb/src · high confidence

Introduce procedural macro for defining custom metering capabilities and contexts

The \chroma-metering-macros\ crate now provides a procedural macro, \initialize\_metering\, that allows users to define custom metering capabilities and contexts via attributes. By annotating traits with \\#\[capability\]\ and structs with \\#\[context\]\, the macro generates the necessary trait implementations, marker methods, and runtime support code (such as thread-local context management and async future instrumentation) within the user's project. This enables developers to create type-safe, extensible metering systems that integrate with the existing \chroma\_system\ components.

rust/metering-macros · high confidence

Introduce replicated fragment and manifest management for multi-region storage

The WAL3 module now includes a new \repl\ interface that enables writing and reading fragments across multiple storage regions and persisting manifest metadata in Spanner. Users can configure replication behavior via \ReplicatedFragmentOptions\, which controls the minimum replication factor, read-repair concurrency, and fault tolerance settings. The \ManifestManager\ handles manifest initialization and updates in Spanner, supporting multi-region consistency and intrinsic cursors for garbage collection. This change adds the infrastructure for replicated log storage but does not yet enable end-to-end replication without additional wiring in other components.

rust/wal3/src/interfaces/repl · high confidence

Introduce shared common package with core types, constants, and error definitions

A new \go/pkg/common\ package has been added to centralize shared system definitions. This includes a \Component\ interface for lifecycle management, standard constants such as \DefaultTenant\ and the \SourceAttachedFunctionIDKey\ schema field, and a comprehensive set of typed error variables for tenants, databases, collections, segments, and attached functions. Additionally, a \UniqueID\ type wrapping UUIDs with parsing and serialization helpers is now available in \go/pkg/types\ to standardize identifier handling across the system.

go/pkg/common · high confidence

Introduce sparse vector index with Block-Max WAND and MaxScore algorithms

Users can now store and query sparse vectors (commonly used in text search) using a new index module in \rust/index/src/sparse\. This feature implements the Block-Max WAND algorithm for efficient top-k retrieval, utilizing a dual-blockfile layout (\sparse\_max\ for block/dimension maximums and \sparse\_offset\_value\ for actual vector values) to enable aggressive pruning. The module includes a \SparseWriter\ for incremental updates, a \SparseReader\ for query execution, and a \MaxScore\ implementation that partitions query terms into essential and non-essential groups to optimize scoring performance via windowed accumulators and bitmap-guided cleanup.

rust/index/src/sparse · high confidence

Introduce standalone Spanner migration library and CLI

The \rust/spanner-migrations\ crate now provides a self-contained library and CLI binary for managing Spanner schema migrations. It supports applying or validating migrations for \spanner\_sysdb\ and \spanner\_logdb\ across multiple topologies, configurable via YAML and environment variables. The tool automatically bootstraps the Spanner emulator (creating instance and database) when needed, handles legacy hash mappings for backward compatibility, and allows filtering migrations by slug or topology via CLI arguments.

rust/spanner-migrations/src · high confidence

Introduce tiered client assignment and Kubernetes-based memberlist provider

The memberlist module now supports tiered client assignment, allowing gRPC clients to be distributed across priority tiers to isolate high-priority workloads. It also introduces a new CustomResourceMemberlistProvider that watches Kubernetes Custom Resources to dynamically maintain the list of active members, replacing previous static or manual discovery methods. This change includes the necessary configuration structures and assignment logic to map nodes to clients based on these new tiers.

rust/memberlist · high confidence

Introduce typed metadata index writers for string, integer, float, and boolean fields

The metadata module now exposes a \MetadataIndexWriter\ enum that dispatches to specific implementations for String, U32, F32, and Bool metadata types. This allows the system to maintain in-memory RoaringBitmaps for efficient filtering and indexing of these specific metadata value types, handling read-then-write semantics via optional readers and mutex-protected state maps.

rust/index/src/metadata · high confidence

Introduce wal3, a new Rust-based Write-Ahead Log implementation

This change introduces the wal3 crate, a new Rust-based Write-Ahead Log (WAL) implementation. It provides core log management capabilities including manifest and snapshot handling, fragment storage, and a three-phase garbage collection system. The implementation features a custom exponential backoff algorithm for retries, a cursor store for tracking compaction offsets, and a quorum writer for coordinated writes. It also includes utilities for copying logs, destroying log instances, and constructing garbage patches from manifests.

rust/wal3/src · high confidence

Introduce word-based full-text bitmap index

Added a new full-text search implementation in the \rust/index/src/fulltext\ module that uses a word-based tokenizer and roaring bitmaps for efficient substring and word matching. The new architecture includes a \WordAnalyzer\ for linguistic processing (tokenization, lowercasing, filtering), a \FullTextBitmapWriter\ for accumulating and persisting token, trigram, and transition bitmaps to a blockfile, and a \FullTextBitmapReader\ for executing a multi-stage query pipeline (candidate resolution, bitmap intersection, and verification). This replaces the previous trigram-based approach with a more precise and performant word-boundary-aware index.

rust/index/src/fulltext · high confidence

Introduces a unified blockfile type system with configurable write ordering

The blockstore now exposes a standardized set of types for managing data persistence, including \BlockfileReader\, \BlockfileWriter\, and \BlockfileFlusher\ enums that abstract over both in-memory and Arrow-backed storage implementations. A key behavioral addition is the \BlockfileWriterOptions\ configuration, which allows users to specify \ordered\_mutations\ or \unordered\_mutations\ when creating writers, enabling performance optimizations for pre-sorted data. The module also defines the \Key\ and \Value\ traits with implementations for common types (such as \f32\, \u32\, \Vec\<f32\>\, \RoaringBitmap\, and \DataRecord\) and introduces specific error types like \BlockfileError\ to handle cases such as missing keys or blocks.

rust/blockstore/src/types · high confidence

Introduces configurable rendezvous hashing for member assignment

The assignment module now supports configurable assignment policies, defaulting to rendezvous hashing using the Murmur3 algorithm. Users can define assignment rules via configuration, which determines how keys are distributed across a set of members (e.g., database nodes or workers). This change provides a standardized, configurable mechanism for data placement that mirrors existing implementations in other language services.

rust/config/src/assignment · high confidence

Introduces shared database model interfaces and built-in function constants

This change adds the \dbmodel\ package to define core database interfaces (\IMetaDomain\, \ITransaction\) and constants for built-in functions (such as \record\_counter\, \statistics\, \http\_generate\, and \revision\_history\). The \constants.go\ file provides UUIDs and names for these functions, including a \GetFunctionNameByID\ helper to resolve names without database lookups, ensuring consistency between the Go metastore, Rust types, and database migrations.

go/pkg/sysdb/metastore/db/dbmodel · high confidence

Introduces wal3 batch management and fault injection interfaces

The \rust/wal3/src/interfaces\ module now includes a \BatchManager\ that groups appends into batches, enforces admission predicates, and manages fragment pinning to ensure conditional writes and generation consistency. It also exposes traits for fragment and manifest publishing, along with a \FragmentUploadFaultInjector\ mechanism that allows optional fault injection (such as delays or unavailability) during fragment uploads to support testing and resilience verification.

rust/wal3/src/interfaces · high confidence

Introduction of Rust sysdb service binary

A new Rust-based sysdb service binary has been added, serving as the entry point for the system database service. The executable initializes a Tokio multi-threaded runtime, configures the thread name to 'chroma-rust-sysdb', and applies a specific stack size setting before invoking the service's main entrypoint.

rust/rust-sysdb/src/bin · high confidence

Introduction of Rust-based Garbage Collector v2 service

The garbage collection system has been rewritten in Rust, replacing the previous implementation with a new v2 architecture. This change introduces a dedicated service that manages collection lifecycle cleanup through a modular orchestrator system, including specific handlers for version graph construction, log-only hard deletes, and attached function cleanup. The new service supports configurable cleanup modes (such as soft-delete grace periods and tenant-specific overrides), integrates with multi-cloud multi-region (MCMR) storage topologies via Google Cloud Spanner, and exposes a gRPC interface for manual garbage collection kickoffs. It also includes built-in observability with OpenTelemetry tracing and jemalloc pprof profiling.

_rust/garbage\collector/src · high confidence

Introduction of a lightweight HTTP-only Python client

Users can now install a separate, minimal package (chromadb-client) that provides only the HTTP client functionality for connecting to a remote Chroma server, without requiring the full local database or embedding dependencies. This 'thin client' is configured via a new build script and a dedicated flag file, allowing users to interact with Chroma via standard HTTP operations like creating collections and adding documents.

clients/python · high confidence

Introduction of a new quota enforcement system for API actions

A new quota module has been added to the Rust frontend to enforce usage limits on various API operations. This system defines a comprehensive set of actions—including CreateDatabase, CreateCollection, Add, Get, Update, Upsert, Query, Search, and ForkCollection—and provides a structured payload builder to pass context (such as metadata, embeddings, and query parameters) to the quota enforcer. This change introduces the foundational infrastructure for limiting resource consumption and preventing abuse across the service.

rust/frontend/src/quota · high confidence

JS client bundles native bindings and CLI entry points

The JavaScript client now includes native platform-specific bindings (for macOS, Linux, and Windows) and a bundled CLI command. Users can now run the \chromadb\ CLI directly from the package, which supports an \update\ subcommand to check for newer versions via npm registry, and the client automatically loads the correct native binary based on the operating system and architecture.

clients/js/packages/chromadb/src · high confidence

JS client now bundles the CLI for standalone distribution

The JavaScript client package now includes a bundled version of the CLI, allowing it to be distributed and executed as a single unit. This change is supported by the addition of a Cargo configuration that enables static CRT linking on Windows (x86\_64-pc-windows-msvc) to ensure the binary is self-contained, along with standard Node.js and macOS/Windows gitignore patterns to clean up the build environment.

_rust/js\bindings · high confidence

Leader election for SysDB

The SysDB service now supports leader election within Kubernetes clusters. A new leader election mechanism has been added to ensure high availability by allowing only one instance to act as the leader at a time. The service name is automatically extracted from the pod name, and the leader lock is configured with a 15-second lease duration, 10-second renewal deadline, and 2-second retry period.

go/pkg/leader · high confidence

New 'Chat with your documents' example using Chroma and OpenAI

Added a new self-contained example in the \examples/chat\_with\_your\_documents\ directory that demonstrates how to build a chat application over local documents. The example uses Chroma for vector storage and retrieval, and OpenAI's API for response generation. It includes sample State of the Union addresses (2022 and 2023) in the \documents\ folder, a \load\_data.py\ script to ingest text files into a Chroma collection, and a \main.py\ interactive chat interface. The chat interface now prompts the user to select a model (defaulting to gpt-4o-mini) and displays source document citations alongside the generated responses.

_examples/chat\_with\_your\documents · high confidence

New /api/agent endpoint for streaming agent-driven research

A new \POST /api/agent\ route has been added to the Foundation API, allowing users to initiate an agent-driven research loop that streams results via Server-Sent Events (SSE). The agent uses the Anthropic API to execute a sequence of inference steps, tool calls (such as search, read page, and sub-agent search), and observations, emitting structured events for reasoning, tool usage, and final answers. The endpoint supports custom system prompts and model selection, handles tenant and database scoping, and integrates with the existing metering system to track usage and debit queries.

rust/foundation-api/src/routes/agent · high confidence

New AWS EC2 deployment example using Terraform

Added a new example deployment for AWS EC2 using Terraform that provisions an Ubuntu 22 instance with Docker Compose, including an attached EBS data volume for persistence. The configuration supports both token and basic authentication, automatically generating credentials and configuring the Chroma server accordingly, while allowing users to specify the Chroma release version, region, and instance type.

examples/deployments/aws-terraform · high confidence

New Arrow serialization implementations for blockstore value types

The blockstore now includes dedicated Arrow serialization and deserialization logic for a wide range of value types, including DataRecord, f32, Vec\<f32\>, String, u32, Vec\<u32\>, RoaringBitmap, SparsePostingBlock, SpannPostingList, and QuantizedCluster. These new modules implement the ArrowWriteableValue and ArrowReadableValue traits, enabling the blockstore to efficiently write and read these types using Apache Arrow's columnar format, which supports optimized storage and retrieval for embeddings, metadata, and sparse structures.

rust/blockstore/src/arrow/block/value · high confidence

New CI tooling for test sharding, runtime reporting, and model caching

The CI infrastructure in bin/ci now includes several new scripts to improve build efficiency and observability. Test execution is optimized via pytest sharding (bin/ci/pytest-shard.py) and a path-based test selection script (bin/ci/determine-tests-to-run.sh) that runs specific language suites only when their code changes. Runtime observability is enhanced with a GitHub Actions runtime report generator (bin/ci/gha-runtime-report.sh) and a converter to Prometheus metrics (bin/ci/gha-runtime-prometheus.sh). Additionally, the default ONNX embedding model is now preloaded and cached in CI (bin/ci/preload\_default\_onnx\_model.py) to speed up embedding-dependent tests, and Python test inventory shards are merged (bin/ci/merge\_python\_test\_inventory.py).

bin/ci · high confidence

New CLI tools for log service cache management and fault injection

Added the \chroma-log-service-purge-cache-entry\ binary to allow administrators to manually evict specific cache entries (cursors, manifests, or fragments) from the Rust log service, and introduced the \chroma-fault\ CLI to inject controlled faults (delays or unavailability) into the log service for testing and debugging purposes.

rust/log-service · high confidence

New DigitalOcean Terraform deployment example

Added a new example deployment blueprint for DigitalOcean using Terraform, which provisions a Droplet with Ubuntu 22.04, mounts a persistent data volume, and configures a firewall for SSH and HTTP access. The configuration supports deploying Chroma via Docker Compose with optional authentication (token or basic auth) and allows users to customize instance size, region, and Chroma release version.

examples/deployments/do-terraform · high confidence

New Foundation MCP endpoint with OAuth and scoped access

A new Model Context Protocol (MCP) server is now available at \/mcp/foundation\ and \/mcp/tenants/{tenant}/foundations/{foundation}\. The bare path uses OAuth bearer tokens for tenant-scoped access, while the scoped path accepts Chroma API keys for direct access to specific Foundations. The endpoint supports search and page-reading tools, with OAuth discovery served at \/.well-known/oauth-protected-resource/mcp/foundation\.

rust/foundation-api/src/routes/mcp · high confidence

New Gemini document chat example

Added a self-contained example in the \examples/gemini\ directory that demonstrates how to build a chat application using Google Gemini and Chroma. The example includes a \load\_data.py\ script to ingest text documents into a Chroma collection and a \main.py\ script to query the collection and generate responses via the Gemini API, along with sample State of the Union addresses and documentation.

examples/gemini · high confidence

New Google Cloud Compute deployment example with authentication and external volumes

Added a new Terraform-based deployment example for Google Cloud Compute that provisions a VM with an attached persistent data volume. The example supports enabling authentication via either token or basic auth, automatically generating credentials and configuring the Chroma server accordingly, and includes instructions for SSH access and public IP retrieval.

examples/deployments/google-cloud-compute · high confidence

New JS embedding packages for BM25, Chroma Cloud Qwen, Chroma Cloud Splade, and Cloudflare Workers AI

The \@chroma-core/ai-embeddings\ workspace introduces four new embedding function packages for the JavaScript client. The \chroma-bm25\ package provides a local, Rust-compatible BM25 sparse embedding implementation with configurable tokenization and stopwords. The \chroma-cloud-qwen\ and \chroma-cloud-splade\ packages enable sparse and dense embeddings via Chroma's hosted cloud service, supporting the Qwen3 and Splade models respectively, with API key hydration from the Chroma client. The \cloudflare-worker-ai\ package adds support for Cloudflare's embedding models. All new packages are re-exported via the new \@chroma-core/all\ umbrella package for convenient installation.

clients/new-js/packages/ai-embeddings · high confidence

New JavaScript client introduces conditional transactions and administrative capabilities

The new JavaScript client adds support for collection-scoped conditional transactions, allowing users to perform read-modify-write operations with automatic conflict retrying via the \collection.conditional().run()\ API or manual commit workflows. It also introduces an \AdminClient\ for managing tenants and databases, and a \CloudClient\ for simplified authentication to hosted Chroma instances. Additionally, the client now supports Customer-Managed Encryption Keys (CMEK) for GCP, configurable read levels (INDEX\_AND\_WAL, INDEX\_ONLY, INDEX\_AND\_BOUNDED\_WAL) for controlling data visibility and latency, and a Next.js webpack helper to handle bundling compatibility.

clients/new-js/packages/chromadb/src · high confidence

New Movies sample app with chat and search capabilities

The sample\_apps/movies directory now contains a complete Next.js application featuring a dual-mode interface for interacting with a movies dataset. Users can switch between a 'Search' tab for direct keyword/hybrid queries and a 'Chat' tab for conversational assistance powered by the AI SDK. The chat interface utilizes a 'searchMovies' tool to perform hybrid retrieval (dense embeddings and BM25) via Chroma, displaying relevant movie results directly within the conversation stream. The app includes dedicated API routes for chat and search, UI components for tabs and input groups, and a library module for handling Chroma client connections and search logic.

_sample\apps/movies · high confidence

New Render.com Terraform deployment example with authentication and SQLite fixes

Added a new Terraform-based deployment example for Render.com that provisions a Chroma web service with persistent disk storage and configurable authentication (token-based by default). The example includes a patch to the Chroma source code to automatically handle older SQLite versions by swapping in pysqlite3-binary, ensuring compatibility on environments like Render where system SQLite may be outdated.

examples/deployments/render-terraform · high confidence

New Rust CLI with comprehensive command set

The CLI has been rewritten in Rust, introducing a full suite of new commands for managing Chroma instances and data. Users can now authenticate via \chroma login\ (supporting both browser-based and API-key flows) and manage multiple user profiles with \chroma profile\. Database administration is handled through \chroma db\ (create, delete, list, and connect with language-specific snippets). Data operations include \chroma copy\ for transferring collections between local and cloud environments, \chroma browse\ for interactive collection inspection, and \chroma vacuum\ for local storage optimization. The CLI also supports installing sample apps (\chroma install\), running a local server (\chroma run\), and self-updating (\chroma update\).

rust/cli/src/commands · high confidence

New Rust client examples for search, embeddings, and conditional transactions

Added three new examples in the Rust client library: \collection\_search.rs\ demonstrates comprehensive search operations including hybrid search with BM25 sparse vectors, filtered queries, and pagination; \embeddings.rs\ shows how to use Chroma Cloud embedding functions (Qwen for dense, Splade for sparse) to create collections and perform searches; and \conditional\_transactions.rs\ illustrates collection-scoped conditional transactions with automatic retry logic and manual commit support.

rust/chroma/examples · high confidence

New Rust segment implementation with sharded writers, bloom filters, and local HNSW support

The \rust/segment\ crate introduces a new Rust-based segment layer that replaces the previous Python-backed implementation. This change adds sharded record and metadata writers (\RecordSegmentWriter\, \blockfile\_metadata\) that support concurrent shard operations and integrate with a new \BloomFilter\ abstraction for efficient existence checks. It also introduces dedicated writers and readers for distributed HNSW (\DistributedHNSWSegmentWriter\) and Spann (\SpannSegmentWriterShard\) indices, as well as a \LocalSegmentManager\ that manages an in-memory HNSW index pool and handles legacy \max\_seq\_id\ migration from pickle files for local Chroma deployments.

rust/segment/src · high confidence

New Rust vector index library with HNSW, SPANN, and USearch providers

This change introduces a new Rust-based vector indexing library (\rust/index\) that provides a unified \VectorIndex\ trait and \VectorIndexProvider\ interface for managing dense vector indexes. It includes specific implementations for HNSW (via \hnswlib\), SPANN, and USearch (with optional quantization support), along with configuration structures for garbage collection policies, cache settings, and search parameters. The library also exposes utility functions for merging sorted vectors and a test helper for the HNSW provider.

rust/index/src · high confidence

New SysDB coordinator implementation with async function support and heap service integration

The \go/pkg/sysdb/coordinator\ package introduces a new \Coordinator\ component that manages system catalog operations, including database, tenant, and collection lifecycle. This implementation adds support for asynchronous attached functions, featuring a repair flow for completion offsets and a status checking mechanism. It also integrates with a heap service for scheduling, using gRPC and memberlist-based discovery, and exposes metrics for compaction dead-letter queues.

go/pkg/sysdb/coordinator · high confidence

New admission control and rate-limiting primitives in the MDAC library

The \rust/mdac\ crate now exposes core building blocks for managing system load: a \CircuitBreaker\ that rejects requests when saturation is detected, a \TokenBucket\ for precise GCRA-based rate limiting with token refunds, a \Scorecard\ for multi-dimensional traffic tracking and limiting based on labeled rules, and a \Pattern\ utility for glob-style matching used by the scorecard. These components provide the foundational logic for admission control and rate limiting within the MDAC service.

rust/mdac · high confidence

New agent tools for searching and reading wiki pages

The foundation-api now exposes \search\, \read\_page\, and \subagent\_search\ tools for use by AI agents. These tools allow agents to perform hybrid dense+sparse retrieval against the wiki, fetch full page content by slug, and delegate deep research to an external subagent, all while reusing the same underlying retrieval cores as the standard HTTP routes to ensure consistent results.

_rust/foundation-api/src/agent\tools · high confidence

New benchmark infrastructure with multi-dataset support

The benchmarking suite has been restructured to support a modular, extensible dataset system. A new \RecordDataset\ trait and associated utilities handle the asynchronous download, caching, and streaming of data from various sources, including vector datasets (Sift1M, Gist), text corpora (Wikipedia, SciDocs, Microsoft MARCO), and code repositories (The Stack Dedup). The suite now includes specific dataset loaders for these sources, a utility for managing cached dataset files with safe file-renaming, and a \FrozenQuerySubset\ mechanism to pre-compute and cache valid query-corpus pairs for consistent benchmarking.

rust/benchmark · high confidence

New deep-research subagent search endpoint

A new \POST /api/subagent\_search\ route has been added to the Foundation API. It accepts a research query and streams results back via Server-Sent Events (SSE). The endpoint forwards the request to an external deep-research dependency, parsing the raw agent events into typed progress updates (\action\, \observation\) and a final structured \result\ containing ranked documents with justifications. It handles authentication via the caller's Chroma token and tenant scope, and ensures that empty results are treated as valid outcomes rather than errors.

_rust/foundation-api/src/routes/subagent\search · high confidence

New example notebooks for authentication, embedding providers, and filtering

The examples/basic\_functionality directory now includes several new Jupyter notebooks that demonstrate key Chroma capabilities. The auth notebook provides a comprehensive guide to setting up and using basic and token-based authentication in client/server deployments. The alternative\_embeddings notebook shows how to integrate third-party embedding providers like OpenAI, Cohere, and Instructor models. The in\_not\_in\_filtering notebook demonstrates the new $in and $not\_in metadata filtering operators, including their interaction with logical operators like $and and $or. Additionally, new notebooks cover local persistence with PersistentClient, basic embedding retrieval using the SciQ dataset, and retrieving collections by ID.

_examples/basic\functionality · high confidence

New examples for conditional transactions, attached functions, and work queue configuration

The examples folder now includes three new demonstration files: \conditional\_transactions.py\ shows how to use the new \collection.conditional()\ API for atomic create-or-update operations and manual transaction commits; \task\_api\_example.py\ demonstrates the new \attach\_function\ and \detach\_function\ methods for automatically processing collections with attached functions like \RECORD\_COUNTER\_FUNCTION\; and \work\_queue\_config.yaml\ provides a sample configuration for the new work queue service, including storage paths, persistence thresholds, and S3 settings.

examples · high confidence

New forking example and hardware-optimized image documentation

The examples/advanced directory now includes a new forking.ipynb notebook that demonstrates how to fork a ChromaDB collection to chunk and embed a GitHub repository, apply diffs to a new branch, and use custom code chunking with tree-sitter. Additionally, a hardware-optimized-image.md guide explains how to rebuild the hnswlib from source with AVX support for Intel-based CPUs by setting the REBUILD\_HNSWLIB build argument during Docker image creation.

examples/advanced · high confidence

New gRPC server utility package with mTLS and distributed tracing support

A new \go/pkg/grpcutils\ package has been introduced to centralize gRPC server configuration and lifecycle management. This utility allows services to configure connection limits via \MaxConcurrentStreams\ and \NumStreamWorkers\, and enables mutual TLS (mTLS) authentication when certificate paths are provided. It also integrates optional distributed tracing via the OpenTelemetry interceptor, activated by the \OPTL\_TRACING\_ENDPOINT\ environment variable, and provides standardized helpers for building gRPC error responses.

go/pkg/grpcutils · high confidence

New gRPC service layer for SysDB collection, segment, task, and tenant management

This change introduces the Go gRPC server implementation for the SysDB coordinator, exposing RPC endpoints for managing collections, segments, attached functions (tasks), and tenants/databases. The \collection\_service.go\ and \segment\_service.go\ files handle creation, retrieval, and deletion of vector collections and their internal segments, including metadata conversion and error mapping. The \task\_service.go\ file adds RPCs for attaching functions, managing inputs, and handling async invocation lifecycles. The \tenant\_database\_service.go\ file provides endpoints for CRUD operations on tenants and databases, including soft-delete completion and resource name management. Supporting files include \proto\_model\convert.go\ for bidirectional conversion between protobuf and internal models, and comprehensive test suites (\\\_test.go\) for these services and memberlist configuration.

go/pkg/sysdb/grpc · high confidence

New garbage collection operators for version and file management

The garbage collector now includes a suite of new operators to handle version graph analysis and file cleanup. \ComputeVersionsToDeleteOperator\ and \ComputeVersionsToDeleteFromGraphOperator\ determine which collection versions are eligible for deletion based on cutoff times, minimum version retention, and attached function completion offsets. \ComputeUnusedFilesOperator\ and \ComputeUnusedBetweenVersionsOperator\ identify unused storage files by comparing segment information between versions. \DeleteUnusedFilesOperator\ performs the actual hard or soft deletion of these files, while \DeleteVersionsAtSysDbOperator\ cleans up version metadata in the system database. Additionally, \DeleteUnusedLogsOperator\ manages garbage collection for WAL3 logs, and \FetchLineageFileOperator\ retrieves collection lineage data.

_rust/garbage\collector/src/operators · high confidence

New garbage collector service and CLI tool

The garbage collector now includes a dedicated service binary and a comprehensive CLI tool. The service binary initializes a Tokio multi-threaded runtime with a custom thread stack size and Jemalloc allocator to run the garbage collection entrypoint. The CLI tool provides commands for manual garbage collection (with options for log GC, dry-run/delete modes, and version cutoffs), exporting and importing collection metadata from the system database, and downloading associated storage files with configurable concurrency.

_rust/garbage\collector/src/bin · high confidence

New generative benchmarking sample app for evaluating embedding models

A new sample application located in \sample\_apps/generative\_benchmarking\ provides a toolkit for generating custom benchmarks and comparing embedding model performance. The app includes a configuration file (\config.json\) specifying required environment variables (such as \OPENAI\_API\_KEY\) and startup commands for pip, poetry, and conda. It provides a \compare.ipynb\ notebook that allows users to load and compare metrics (e.g., Recall@3) from different embedding providers like OpenAI, Jina, and Voyage, alongside a \generate\_benchmark.ipynb\ for creating custom benchmarks based on user data. The sample also ships with example data (\chroma\_docs.json\) to immediately test the notebooks.

_sample\apps · high confidence

New integration examples for Cohere, Jina, Ollama, and Roboflow

Added usage examples in the \examples/use\_with\ directory for integrating Chroma with external embedding services. This includes JavaScript and Python notebooks for Cohere (covering basic, multilingual, and multimodal image embedding), a Python notebook for Jina AI demonstrating late chunking, a Markdown guide for local Ollama embedding, and a Python notebook for Roboflow image embeddings using CLIP.

_examples/use\with · high confidence

New interactive TUI collection browser in the CLI

The CLI now includes a new \collection\_browser\ module under \rust/cli/src/tui\ that provides an interactive terminal UI for browsing Chroma collections. This feature introduces a table-based view of records (ID, Document, Metadata) with keyboard navigation, support for dark/light themes and true-color/ansi256 palettes, and a query editor for filtering by IDs, document content, and metadata operators. Users can expand individual cells to inspect full content, paginate through results, and submit searches, with the UI handling async record loading and error states.

rust/cli/src/tui · high confidence

New internal regex engine with literal expression optimization

The regex module now uses a custom internal representation (ChromaHir) to parse and validate patterns, explicitly excluding unsupported features like byte patterns and lookaheads. This change introduces a new literal expression engine that optimizes matching by leveraging n-gram lookups and prefix/suffix tables, allowing for more efficient filtering of documents based on regex patterns.

rust/types/src/regex · high confidence

New local development environment with observability and storage services

The \k8s/test\ directory now provides a comprehensive set of Kubernetes manifests to run a local testing and debugging stack on top of production configurations. This includes deployments and services for Grafana (with a pre-configured 'foyer' dashboard), Jaeger (configured with Badger storage to prevent OOMs), Prometheus, MinIO, and a Spanner emulator. It also introduces a custom Postgres deployment that supports multiple databases (\sysdb\, \log\) via a custom entrypoint script, with resource limits tuned to handle connection storms. Additionally, an OpenTelemetry collector is included to bridge traces to Jaeger and metrics to Prometheus, and initial Custom Resource definitions for a distributed 'memberlist' feature are added.

k8s/test · high confidence

New mdac-service with token bucket rate limiter and Modal deployment

Adds the mdac-service, a new Rust-based HTTP service implementing a token bucket rate limiter. The build system includes a dedicated Dockerfile (rust/Dockerfile.mdac) to compile the token\_bucket\_service binary, and a Python deployment script (rust/deploy\_mdac.py) that packages the service for deployment on Modal, exposing it as a web server on port 8000.

rust · high confidence

New metering library with request timing and detailed context tracking

The \rust/metering\ crate has been introduced to centralize usage tracking, providing structured contexts for collection operations (fork, read, write) and search agent usage. This change adds request timing capabilities by capturing start and finish instants to calculate execution time in milliseconds, and enriches metering events with specific metrics such as FTS query length, metadata predicate count, query embedding count, and data transfer sizes (pulled and returned bytes). The library also includes a dedicated receiver mechanism for submitting meter events and exports the necessary types and contexts for integration with the rest of the system.

rust/metering · high confidence

New multimodal retrieval example notebook

Added a new example notebook in the \examples/multimodal\ directory that demonstrates how to create and query a Chroma collection containing both text and images. The notebook installs the \open-clip-torch\ library and shows how to use Chroma's built-in multimodal features to embed and retrieve data across these two modalities.

examples/multimodal · high confidence

New operational tooling for testing, deployment, and CI

This change introduces a suite of new scripts and utilities in the bin directory to support Chroma's testing, deployment, and continuous integration workflows. It adds entrypoint scripts (docker\_entrypoint.sh, docker\_entrypoint.ps1) that standardize server startup and enforce environment variables like CHROMA\_SERVER\_NOFILE. New integration test runners (python-integration-test, rust-integration-test.sh, ts-integration-test.sh, test-remote) allow running tests against local, remote, or containerized instances, including specific support for Rust client backward compatibility and TypeScript client generation checks. Deployment is supported by a CloudFormation generator (generate\_cloudformation.py) for single-instance AWS EC2 setups. CI is enhanced with scripts for Windows SQLite upgrades, log collection (get-logs.sh), and operator constant generation, alongside a version helper and a basic sanity check script.

bin · high confidence

New reasoning trajectory persistence module with Chroma storage

A new \trajectories\ module has been added to the \foundation-api\ to persist user-facing reasoning projections as structured records in Chroma. This module introduces a dedicated data model that prunes raw producer metadata (tools, parameters, observations) down to visible reasoning text, derived page-write facts, and citation attribution. It provides an API for creating open trajectories, appending entries with optimistic concurrency checks, finalizing trajectories, and loading them back. The implementation handles storage details such as chunking large JSON payloads, generating stable base36 identifiers, and managing citation sub-trees, exposing these capabilities through the \foundation-api::trajectories\ public interface.

rust/foundation-api/src/trajectories · high confidence

New search expression DSL for the JavaScript client

The JavaScript client now includes a new expression-based DSL in the execution layer, allowing users to construct complex search queries using a fluent API. This addition introduces typed classes for where clauses (supporting comparison, logical, and regex operators), ranking expressions (enabling arithmetic and mathematical operations on scores), grouping (with min/max aggregation), and result selection. Users can now build search payloads programmatically with strong typing and validation, replacing or supplementing raw JSON objects for query construction.

clients/new-js/packages/chromadb/src/execution · high confidence

New shared OpenTelemetry tracing and configuration library

The \rust/tracing\ crate now provides a centralized library for OpenTelemetry integration, introducing a shared \OpenTelemetryConfig\ struct for managing service names and trace filters. It includes \GrpcClientTraceLayer\ and \GrpcServerTraceLayer\ to automatically propagate trace and span IDs via \chroma-traceid\ and \chroma-spanid\ headers across gRPC boundaries, and a Tower middleware for HTTP services that extracts W3C trace context and records request details. The library also initializes global tracing with a Rustls crypto provider, exports Tokio runtime metrics, and adds a utility to log operations that exceed a specified duration threshold.

rust/tracing · high confidence

New system crate with component lifecycle, scheduling, and OpenTelemetry metrics

The \rust/system\ crate introduces a new component execution model that manages component lifecycles (start, stop, and graceful shutdown with timeouts), message scheduling, and dedicated thread execution. It adds comprehensive OpenTelemetry metrics to track component queue depth, handler latency, message counts, and scheduler performance, while also implementing panic handling for message handlers to prevent crashes from propagating uncaught.

rust/system/src · high confidence

New wiki page upsert flow with tree-sitter chunking and SPLADE sparse embeddings

The foundation-api wiki module now supports a new \/upsert-page\ flow that processes wiki content using a tree-sitter-based markdown chunker (splitting pages into chunks capped at 4096 bytes) and generates SPLADE sparse embeddings for each chunk via Chroma Cloud. Page metadata is enriched with author and last-written-by stamps, and source IDs are distributed across chunks to stay within storage limits.

rust/foundation-api/src/wiki · high confidence

New xAI integration example for document-based chat

Added a new example in the \examples/xai\ directory demonstrating how to use Chroma with the xAI SDK. This example implements a Retrieval-Augmented Generation (RAG) workflow where users can add PDF documents to a \docs\ folder, which are then chunked, embedded, and stored in a Chroma collection. The application allows users to chat with their documents by querying the collection for relevant context to answer questions via the xAI API.

examples/xai · high confidence

Python client version 1.5.9 with Search API and conditional transaction support

The Python client is updated to version 1.5.9. This release exposes the new Search API components (including \Search\, \Key\, \Knn\, and \Rrf\) at the top-level \chromadb\ namespace for hybrid search capabilities. It also introduces support for conditional HTTP transactions via the \ConditionalHttpTransaction\ class, allowing users to perform atomic read-modify-write operations with conflict detection. Additionally, the \BaseHTTPClient\ now supports configurable HTTP keepalive and connection limits through settings.

chromadb · high confidence

Rust client adds BM25 sparse embeddings and Ollama integration

The Rust client now supports sparse vector embeddings via a new BM25 implementation (using a configurable tokenizer and MurmurHash3 hasher) alongside existing dense embedding capabilities. Users can generate BM25 sparse vectors locally or use the new Ollama embedding function to connect to a local Ollama instance for dense embeddings. Additionally, the module introduces an \EmbeddingFunction\ trait to standardize text-to-vector conversion and includes Chroma Cloud embedding functions for Qwen (dense) and Splade (sparse) models.

rust/chroma/src/embed · high confidence

Rust types module introduces foundational data models and conditional transaction support

The \rust/types/src\ module has been reorganized into distinct files to define the core data structures for the Rust frontend and sysdb. This includes new types for collections (\Collection\, \CollectionUuid\), database names (\DatabaseName\), and collection configurations (\InternalCollectionConfiguration\, \VectorIndexConfiguration\ for HNSW and SPANN). A new \conditional\_transaction.rs\ file implements the state machine for conditional (optimistic concurrency control) transactions, including buffered writes and read tokens. Additionally, \base64\_decode.rs\ adds support for decoding base64-encoded embeddings, and \collection\_schema.rs\ defines the schema model with validation errors for indexing and configuration conflicts.

rust/types/src · high confidence

Spanner schema for Rust Log Service manifests and fragments

The Spanner database schema for the Rust Log Service has been established with a set of migrations defining the core data structures. This includes the \manifests\ table to track log metadata, the \fragments\ table (interleaved under manifests) to store file segment details, and supporting \manifest\_regions\ and \fragment\_regions\ tables for region tracking. Subsequent migrations refine this structure by dropping the \collected\ column from manifests, adding \initial\_offset\ and \intrinsic\_cursor\ fields to region tables, introducing an \ignore\_dirty\ flag for manifests, adding an \updated\_at\ timestamp, and creating a specific index on fragments to optimize queries by position limit.

_rust/spanner-migrations/log\migrations · high confidence

Unified storage backend with admission-controlled S3 and GCS support

The storage layer now provides a unified interface that supports S3, local filesystem, and Google Cloud Storage (GCS) via a generic object-store backend. A new admission-controlled S3 implementation (\AdmissionControlledS3Storage\) is introduced as the default storage configuration, featuring rate limiting, request coalescing, and priority-based handling to manage load. The system now includes comprehensive OpenTelemetry metrics for all storage operations (get, put, delete, copy, rename, list) and introduces a shared \Stopwatch\ utility for consistent latency tracking across the codebase.

rust/storage · high confidence

Vector distance calculations now use hardware-accelerated SIMD implementations

The \rust/distance\ module now provides optimized distance metrics (cosine, inner product, and Euclidean) using AVX, AVX512, NEON, and SSE instruction sets, falling back to scalar implementations when hardware support is unavailable. This change significantly improves vector search performance on supported CPUs by leveraging SIMD parallelism, with automatic feature detection ensuring compatibility across different processor architectures.

rust/distance · high confidence

Architecture

Extract shared frontend-core library crate

The \frontend-core\ library crate has been created to house shared scaffolding and logic previously located in the \chroma-frontend\ binary, enabling reuse by other HTTP servers like \foundation-api\. This extraction consolidates common HTTP route handlers (system endpoints like healthcheck, heartbeat, and version, plus the auth identity endpoint), server configuration primitives (port, listen address, circuit breaker, scorecard rules), error handling and response formatting, and middleware (JSON content-type enforcement, JSON error conversion) into a single reusable module. Additionally, it centralizes core business logic for collection creation planning (validating segment types, reconciling schemas, applying tenant feature flags) and attached function lifecycle management (idempotent creation, adding input collections, retrying transient sysdb failures), ensuring these rules are defined in one place rather than duplicated across frontends.

rust/frontend-core · high confidence

Behavioural changes

Automated generation of Rust operator constants from Go source

The build process for the \rust/types\ crate now automatically generates Rust constants for task operators by parsing the Go source file \go/pkg/sysdb/metastore/db/dbmodel/constants.go\ at compile time. This change introduces a new \build.rs\ script and an \operator\_codegen.rs\ module that extract operator UUIDs and names from the Go definitions and produce corresponding Rust \pub const\ declarations. This ensures that the Rust type definitions remain in sync with the Go database model without requiring manual updates or separate commit steps for the generated Rust code.

rust/types · high confidence

Introduce configurable coordinator binary with service memberlist and storage flags

The Go coordinator is now a standalone command-line tool that exposes granular configuration flags for its internal services and infrastructure. Users can now explicitly configure the names and pod labels for the query, compaction, garbage collection, log, and function consumer memberlists, allowing for flexible deployment topologies. The binary also supports database connection tuning (including separate read addresses), S3 storage options (such as bucket creation, region, and GCS interop), and heap service settings, providing a unified entry point to manage the coordinator's behavior via CLI arguments.

go/cmd · high confidence

Introduces Rust frontend validation error types

The Rust frontend now defines a \ValidationError\ enum in \src/types/errors.rs\ to handle specific validation failures such as invalid collection IDs, inconsistent or mismatched embedding dimensions, base64 decoding errors, and collection configuration parsing issues. These errors implement the \ChromaError\ trait to map to appropriate error codes, providing structured feedback to users when input validation fails during operations like adding or updating collections.

rust/frontend/src/types · high confidence

Introduces a unified error handling framework with standardized error codes

The \rust/error\ crate now provides a centralized system for managing errors across the application. It defines 17 standard error codes (aligned with gRPC status codes) plus two custom codes (\VersionMismatch\ and \UnprocessableEntity\), and implements conversions between these codes, HTTP status codes, and gRPC/tonic codes. This ensures consistent error responses for API consumers. The crate also introduces the \ChromaError\ trait and specific wrappers for SQLx, Tonic, and validator errors, allowing internal database and validation failures to be mapped to appropriate, user-facing error codes.

rust/error · high confidence

JS client restructured into a monorepo with separate bundled and peer-dependency packages

The JavaScript client library has been reorganized into a monorepo structure containing three packages: an internal core package (\@internal/chromadb-core\) and two public packages. Users can now choose between the \chromadb\ package, which bundles all embedding library dependencies for a simpler setup, and the \chromadb-client\ package, which uses peer dependencies to keep the dependency tree lean and allow custom embedding library versions. Both packages provide identical functionality and support Node.js and browser environments. The build system now uses pnpm workspaces, and the client code is regenerated from the OpenAPI specification using a new transformation script that handles null types and endpoint response formats.

clients/js · high confidence

New JavaScript client SDK generated from OpenAPI spec

The JavaScript client SDK in \clients/new-js/packages/chromadb/src/api\ has been replaced with a new implementation auto-generated by \@hey-api/openapi-ts\. This introduces a fresh set of TypeScript types and SDK classes (such as \CollectionService\ and \AuthenticationService\) that map directly to the server's OpenAPI specification. For users, this means the client now exposes a comprehensive set of API methods—including collection management, attached functions, and conditional transactions—based on the latest server schema, replacing the previous manual implementation.

clients/new-js/packages/chromadb/src/api · high confidence

New Rust-based CLI client implementation

The CLI now uses a new Rust-based client implementation located in \rust/cli/src/client\. This introduces a \DashboardClient\ that handles authentication flows (including CLI token login and verification) and API interactions for fetching teams and API keys, replacing the previous client logic. The implementation includes utility functions for sending HTTP requests and handling JSON serialization/deserialization.

rust/cli/src/client · high confidence

Refactored block delta storage with optimized ordered writing and precise size tracking

The block delta module has been reorganized to introduce specialized storage backends and improved performance for ordered mutations. A new \OrderedBlockDelta\ type now leverages a \VecBuilderStorage\ for mutations that arrive in sorted order, avoiding the overhead of tree-based structures, while \BTreeBuilderStorage\ remains for unordered data. The system now includes dedicated size trackers (such as \DataRecordSizeTracker\ and \SpannPostingListSizeTracker\) that accurately calculate Arrow buffer sizes—including padding and offsets—during incremental updates, enabling more efficient block splitting and memory management.

rust/blockstore/src/arrow/block/delta · high confidence

S3heap service disabled and nonce logic removed

The s3heap-service module has been disabled and nonce-related logic has been removed. The code structure is retained with unused code allowances to support potential future reimplementation, but the service is currently non-functional.

rust/s3heap-service/src · high confidence

Support for read replicas and optimized collection queries

The database core layer now supports connecting to a separate read replica via the new \ReadAddress\ configuration field, enabling read operations to be routed to a dedicated instance. Additionally, a feature flag (\EnableOptimizedCollectionQueries\) has been introduced to allow enabling optimized collection queries using Common Table Expressions (CTEs), which is disabled by default.

go/pkg/sysdb/metastore/db/dbcore · high confidence

SysDB schema evolution and function runner support

This update applies a comprehensive series of database migrations to the SysDB metastore, evolving the schema to support a robust function execution system and improved collection management. The schema introduces a new 'functions' entity (replacing the previous 'operators' concept) and 'attached\_functions' to manage function invocations, including columns for tracking failures, readiness, and asynchronous execution modes. Built-in functions such as 'record\_counter', 'statistics', 'http\_generate', 'revision\_history', and 'http\_currents' are seeded into the database. The 'collections' table is expanded with metadata for compaction tracking (size, record counts, timestamps), versioning history, lineage, and schema storage, while 'databases' and 'tenants' gain resource naming and improved pagination indexes. Additionally, legacy tables like 'record\_logs' and 'notifications' are removed, and primary key constraints on 'attached\_functions' are adjusted to support composite keys.

go/pkg/sysdb/metastore/db/migrations · high confidence

Tenant-scoped Foundation management and reasoning trajectory support

The Foundation API now supports creating, listing, and describing Foundations within a specific tenant context using new scoped paths (e.g., \/api/tenants/{tenant}/foundations/{foundation}\), while retaining existing unprefixed paths for default Foundations. It introduces a new reasoning trajectory module that allows saving, appending, and finalizing trajectory records in Chroma, along with example tools to load and verify these trajectories. Additionally, a configuration flag (\foundation.provisioning\_paused\) has been added to temporarily block Foundation creation during catalog migrations.

rust/foundation-api · high confidence

Fixes

Fixes for local HNSW index resource management and deletion reliability

This change improves the stability and reliability of local HNSW vector indexes. It introduces a semaphore to limit concurrent file operations, preventing file descriptor exhaustion on systems with low limits (like Windows). It also adds proper cleanup of deleted index resources, ensuring that indexes are correctly removed from disk when segments are deleted, and fixes issues with rejecting writes to invalid or deleted indexes. Additionally, it improves the backfill process to handle failures more robustly and adds validation for index integrity. Also in this area: Fixes stale compaction backpressure rejections in log service.

_rust/segment/src/local\hnsw · high confidence

Test coverage

Add scripts to validate thin client package installation; Added basic integration tests for ChromaClient initialization; Added benchmark for OrderedBlockfileWriter; Added benchmark suite for worker query operators and orchestrators; Added comprehensive test suite for the MaxScore sparse index; Added full-text search and regex benchmarking infrastructure; Added integration and unit tests for the s3heap scheduling service; Added integration tests for Chroma Cloud embedding functions; Added integration tests for the S3Heap service's HeapTender component; Added k8s integration tests for conditional transactions; Added migration validation test script; Added property-based tests for blockfile writer correctness; Added proptest state-machine tests for the Rust frontend against SQLite; Added regression test cases for garbage collection property tests; Added regression test for HNSW reload failure; Added test coverage for the new JavaScript client; Added test utilities for PostgreSQL container and migration execution; Added test utilities for creating sparse index files; Added tests for HNSW configuration repair validation; Added tests for collection operations, delete limits, and fork counts; Added tests for the Foundation API agent route; Added tests for worker configuration loading and validation; Initial test suite for the wal3 replicated log implementation; Refactored SysDB metastore DAO layer with comprehensive test coverage; Regenerated SysDB database mock implementations.

Dependencies

Initial commit of Rust workspace and JavaScript client dependency manifests

This change introduces the foundational dependency configuration for the project's Rust backend and JavaScript clients. It adds a \Cargo.lock\ and a comprehensive \Cargo.toml\ workspace definition for the Rust codebase, establishing the initial set of crates and their versions. Simultaneously, it adds \package.json\ and \pnpm-lock.yaml\ files for the JavaScript client ecosystem (including \chromadb\, \chromadb-client\, and \chromadb-core\), defining the Node.js dependencies and peer dependencies for embedding providers.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 52 → 51 (-1.0)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 61 → 48 (-12.6)
  • Architecture 80 → 79 (-0.8)
  • Maturity 74 → 79 (+4.1)
  • Readiness 58 → 57 (-0.5)
  • Security 40 → 43 (+2.5)
  • Accessibility 67 → 79 (+12.1)
  • Performance 71 → 71 (-0.2)

Resolved (132)

  • Change coupling: memberlist_provider.rs ↔ executor.rs (rust/memberlist/src/memberlist_provider.rs)
  • Critical CVE: [GHSA redacted] (clients/new-js/pnpm-lock.yaml)
  • Duplicated block (10 lines × 2) (rust/frontend/src/server.rs)
  • Duplicated block (10 lines × 2) (rust/index/src/spann/fast_writer.rs)
  • Duplicated block (10 lines × 2) (rust/log-service/src/lib.rs)
  • Duplicated block (10 lines × 2) (rust/types/src/collection_configuration.rs)
  • Duplicated block (10 lines × 2) (rust/types/src/collection_schema.rs)
  • Duplicated block (10 lines × 2) (rust/worker/src/compactor/compaction_manager.rs)
  • Duplicated block (10 lines × 3) (rust/distance/src/distance_avx.rs)
  • Duplicated block (10 lines × 3) (rust/distance/src/distance_avx.rs)
  • Duplicated block (10 lines × 3) (rust/distance/src/distance_avx512.rs)
  • Duplicated block (10 lines × 3) (rust/distance/src/distance_avx512.rs)
  • Duplicated block (10 lines × 3) (rust/distance/src/distance_sse.rs)
  • Duplicated block (10 lines × 3) (rust/segment/src/blockfile_record.rs)
  • Duplicated block (10 lines × 3) (rust/segment/src/sqlite_metadata.rs)
  • Duplicated block (10 lines × 8) (rust/frontend/src/server.rs)
  • Duplicated block (10–11 lines × 3) (rust/distance/src/distance_sse.rs)
  • Duplicated block (10–11 lines × 4) (rust/index/src/metadata/types.rs)
  • Duplicated block (11 lines × 2) (rust/blockstore/src/arrow/block/delta/quantized_cluster_delta.rs)
  • Duplicated block (11 lines × 2) (rust/distance/src/distance_neon.rs)
  • …and 112 more

New (564)

  • Critical CVE: [GHSA redacted] (clients/new-js/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (clients/new-js/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (rust/js_bindings/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (clients/new-js/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (examples/chat_with_your_documents/requirements.txt)
  • Critical CVE: [GHSA redacted] (examples/gemini/requirements.txt)
  • Critical CVE: [GHSA redacted] (sample_apps/movies/package-lock.json)
  • Critical CVE: [GHSA redacted] (clients/js/examples/node/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (clients/js/examples/node/pnpm-lock.yaml)
  • Critical CVE: [GHSA redacted] (Cargo.lock)
  • Critical CVE: [GHSA redacted] (Cargo.lock)
  • Critical CVE: [GHSA redacted] (clients/js/examples/node/pnpm-lock.yaml)
  • Documentation: no build, run or usage example (rust/js_bindings/npm/darwin-arm64/README.md)
  • Documentation: no build, run or usage example (rust/js_bindings/npm/darwin-x64/README.md)
  • Documentation: no build, run or usage example (rust/js_bindings/npm/linux-arm64-gnu/README.md)
  • Documentation: no build, run or usage example (rust/js_bindings/npm/linux-x64-gnu/README.md)
  • Documentation: no build, run or usage example (rust/js_bindings/npm/win32-arm64-msvc/README.md)
  • Documentation: no build, run or usage example (rust/js_bindings/npm/win32-x64-msvc/README.md)
  • Duplicated block (10 lines × 2) (rust/frontend/src/server.rs)
  • Duplicated block (10 lines × 2) (rust/log-service/src/lib.rs)
  • …and 544 more

Changes since last survey

  • 1 commits — 1 feature/other, 0 fixes

By area

  • docs/mintlify — 1 commit

Notable commits

  • change: [DOC] Remove the retired BYOC option from the Cloud docs (#7945)

Architecture

  • Unchanged — 0 containers · 2 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

chroma-core/chroma was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 1a3ac2c7c623adbd03ed2508dc27b98cdf26016d — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.