Chroma — The AI Toolchain

Chroma 1.0.0

Thu, 20 Aug 2026 10:02:06 GMT

Chroma now publishes an API — 33 endpoints across 7 areas: Record, Collection, System, … • Record (9 endpoints) — create, read • Collection (8 endpoints) — create, read, update, delete • System (5 endpoints) — create, read • Database (4 endpoints) — create, read, delete • Function (3 endpoints) — create, read • Tenant (3 endpoints) — create, read, update • Authentication (1 endpoint) — read

Chroma 1.5.9

Tue, 05 May 2026 05:55:40 GMT

Chroma 1.5.9 adds maxscore sparse search, sharded group-by, read-only failover, and a new Tilt fault-injection CLI. • Adds `maxscore` option in the collection schema, wiring a new MaxScore sparse-search index (backed by `SparsePostingBlock`) with SIMD acceleration through the metadata segment and search path for faster full-text-style scoring. • Adds `SparsePostingBlock`, a maxscore writer/reader, and a batch-loading lazy cursor as foundational components of the new sparse posting index. • Adds read-only backend failover to the Rust client (`rust-client`), enabling automatic fallback when the primary backend is unavailable. • Enables `group by` support for sharded collections. • Enables index rebuilds for sharded collections. • Adds a Tilt fault-injection CLI for chaos/fault testing of distributed deployments. • Adds a `spanner-cli` wrapper binary for interacting with Spanner from the Chroma toolchain. • Adds client-header propagation to the Gemini embedding functions. • Adds MCMR (multi-collection/multi-region) support for log garbage collection, including GC of empty MCMR collections. • Adds a workflow to build and publish service container images to both GitHub Container Registry (`:1.5.9`) and DockerHub (`:1.5.9`). • Defers Spanner initialization in the log service to first use, reducing startup latency. • Names and sizes all worker threads for improved observability in system diagnostics. • Sealing a shard now redistributes lower offset IDs to the previous active shard.

Chroma 1.5.8

Thu, 16 Apr 2026 23:35:52 GMT

Chroma 1.5.8 adds sharding-aware compaction, configurable RPC timeouts, pod anti-affinity in Helm, and new WAL read levels. • Adds `IndexAndBoundedWal` and `IndexAndAdaptiveWal` read levels to clients for finer-grained WAL read control. • Makes admin RPC timeout configurable via the config system. • Makes compaction client gRPC timeout configurable. • Adds pod anti-affinity support to StatefulSet Helm templates for improved workload distribution. • Adds a fault injection control plane for testing resilience scenarios. • Adds an optional upload fault injector for WAL3. • Supports partial manifest scans in WAL3. • Adds composite rules for tiering decisions in the compaction layer. • Adds per-tenant config in the compactor for controlling shard sizes. • Integrates the Superlinked embedding function as a new integration. • Adds a CLI I/O terminal and I/O abstraction layer, backed by the official Rust client, for interactive testing and scripting.

Chroma 1.5.7

Wed, 08 Apr 2026 07:49:29 GMT

Chroma 1.5.7 adds getCollectionById across all SDKs, streaming S3 uploads, log sharding, and stdout-only tracing. • Adds `getCollectionById` API across all client SDKs and the server, enabling collection lookup by ID directly. • Adds `put_stream` to `chroma-storage` for streaming S3 uploads. • Adds `shard_index`, `num_shards`, and `log_upper_bound_offset` parameters passed through to query and orchestrator, enabling log partitioning across active and non-active shards. • Adds `SegmentWriter` and `Flusher` abstractions over shards for internal write path. • Enables stdout-only tracing mode for simplified observability output.

Chroma 1.5.6

Tue, 07 Apr 2026 03:01:03 GMT

Chroma 1.5.6 adds 1-bit RaBitQ quantization, a bloom filter read/write path, a fork-count API endpoint, and a `CHROMA_EMBED_URL` override. • Adds `CHROMA_EMBED_URL` environment variable to override the embed endpoint at runtime. • Adds `GET /fork_count` API endpoint to retrieve the fork count of a collection. • Implements 1-bit RaBitQ quantization for vector index compression. • Introduces a generic BloomFilter abstraction wired into the `RecordSegmentWriter` and the read/materialize path for faster existence checks. • Adds CPU and IO core affinity configuration for worker threads in the system layer. • Adds timeout and threshold filtering for dirty logs in the WAL3 log service. • Adds UUID fragment cleanup to WAL3 garbage collection. • Adds Spanner index for listing databases by tenant, improving listing performance. • Adds Horizontal Pod Autoscaler (HPA) for the rust-log-service. • Publishes the Helm chart to GHCR and Artifact Hub. • Re-exports `read_level` for the Rust client. • Improves S3 client configuration options. • JavaScript client gains `get collection by ID` capability. • Improves compactor scheduler job prioritization and capacity tracking. • Adds `batch_get_collection_version_file_paths` and `batch_get_collection_soft_delete_status` endpoints for multi-collection metadata routing (MCMR). • Adds `mark_version_to_gc`, `delete_collection_versions`, and `finish_collection_deletion` operations for MCMR garbage collection lifecycle. • Adds `ClientFactory` for `CompactorClient` to support pluggable compactor backends. • Adds error logging for `Status::unknown` responses in the log service.

Chroma 1.5.5

Tue, 10 Mar 2026 09:30:59 GMT

Chroma 1.5.5 adds a GoogleGemini embedding function alias and API key warnings for JS embedding functions. • Adds a `GoogleGemini` name alias for the Google Gemini embedding function in JavaScript. • Warns at runtime when no API key is set on JavaScript embedding functions. • Improves lazy fragment fetch concurrency using `buffer_unordered`, enabling higher-throughput data retrieval.

Chroma 1.5.3

Sat, 07 Mar 2026 19:07:43 GMT

Chroma 1.5.3 adds delete-with-limit, updated Gemini embedding functions, new compactor endpoints, and OpenTelemetry metrics. • Adds `fragment_storage` config key for a dedicated fragment fetcher storage configuration. • Adds `fetch_log_concurrency` semaphore to the worker for controlling concurrent log fetch operations. • Adds `ReadLevel` support to the `count` operation in the backend. • Adds `compaction_failure_count` gauge metric in sysdb for tracking compaction failures via OpenTelemetry. • Adds `ListInProgressJobs` endpoint to the compactor for querying active compaction jobs. • Adds a compaction endpoint that returns where a collection would be assigned. • Adds pointer-based log fetch via `ScoutLogFragments` for more efficient log retrieval. • Adds tracing spans to the log fetch path for improved observability. • Adds OpenTelemetry metrics to the system crate. • Adds `ResourceExhausted` error code for log backpressure signaling. • Supports delete-with-limit in both server and clients, enabling bounded deletes. • Updates Gemini embedding functions (`EFs`) with new capabilities. • Parallelizes segment reader initialization in filter and IDF operators for faster query startup. • Skips record load when only the document ID is requested, reducing unnecessary I/O. • Removes PostHog as a dependency and makes telemetry a no-op. • Drops pydantic v1 compatibility layer, enabling Python 3.14 support. Breaking changes: • The pydantic v1 compatibility layer has been dropped; setups relying on pydantic v1 behavior will break on upgrade. • Telemetry is now a no-op and PostHog is removed as a dependency; any configuration or integrations depending on PostHog telemetry will no longer function.

Chroma 1.5.2

Fri, 27 Feb 2026 19:50:12 GMT

Chroma 1.5.2 adds FTS opt-out in schema, a Perplexity embedding function, Client context manager support, and quantized SPANN indexing. • Adds close() method and context manager (`with` statement) support to the Python `Client` class for deterministic resource cleanup. • Allows users to disable full-text search (FTS) per collection via a new field in the collection schema. • Promotes the Advanced Search API out of beta (beta label removed). • Adds a Perplexity embedding function (`Pplx EF`) as a new built-in integration. • Introduces a quantized SPANN segment writer and reader, wired into the compaction and query orchestration pipelines for more memory-efficient ANN indexing. • Adds garbage collection for usearch index files to reclaim disk space. • Adds balanced split logic for SPANN segments, with configurable recursion depth control. • Enables `delete_collection` support in the multi-collection/multi-region (MCMR) architecture. • Adds `ignore_dirty` column to the WAL3 manifests table for improved compaction control. • Adds separate concurrency limit for manifest loads in the log-service. • Adds configuration for the `fetch_log` semaphore to tune log-fetch concurrency. • Allows `rebuild` operations to specify individual segments as targets. • Batches sysdb queries during collection enrichment in the scheduler for improved throughput. • Uses cluster average as SPANN center, improving index quality.

Chroma 1.5.1

Thu, 19 Feb 2026 20:01:23 GMT

Chroma 1.5.1 adds quantized SPANN indexing, FTS opt-out in schema, Advanced Search API goes GA, and new concurrency controls for log-service. • Enables users to disable full-text search (FTS) per collection via the schema — keeps index overhead away from collections that don't need text search. • Adds a `fetch_log` semaphore configuration to control concurrency when fetching logs, preventing resource exhaustion under high compaction load. • Adds a separate concurrency limit for manifest loads in log-service, independently capping the number of in-flight manifest operations. • Promotes the Advanced Search API out of beta — now considered stable and no longer carries the beta label. • Introduces a quantized SPANN segment writer and reader, wired into compaction and query orchestration — enables quantized approximate nearest-neighbor search for reduced memory and faster queries. • Adds garbage collection for usearch index files, reclaiming disk space from stale vector index segments. • Adds `delete_collection` support for multi-collection multi-region (MCMR) deployments. • Rejects `fork_collection` calls targeting multi-region databases with an explicit error rather than silently misbehaving. • Makes the `dirty_log_collections` metric MCMR-aware for accurate observability in multi-region setups. • Moves the compaction cursor into the WAL3 manifest as an intrinsic cursor, improving consistency of log compaction state.

Chroma 1.5.0

Mon, 09 Feb 2026 08:47:05 GMT

Chroma 1.5.0 adds multi-bit RabitQ quantization, a USearch index wrapper, SPANN fast writer, S3 runtime options with `head_object`, and disk-eviction caching. • Adds `S3Storage` runtime options and `head_object` support to `chroma-storage`, enabling richer object-storage introspection. • Exports the `search_options` parameter so callers can pass search-time configuration directly to query calls. • Introduces multi-bit RabitQ quantization for approximate nearest-neighbor search, improving recall/speed trade-offs. • Adds a USearch index wrapper and provider as an alternative HNSW backend. • Introduces a SPANN fast writer for faster indexing of large vector collections. • Adds tiered memberlist assignment and per-tier rules for workload routing. • Switches HNSW cache eviction to write-to-disk on eviction (instead of on insertion), reducing write amplification. • Adds prefetch-to-disk capability in the storage layer to accelerate cold reads. • Introduces per-topology configuration and type-transformation methods for multi-region deployments. • Adds `database_name` to the log-service protocol, enabling per-database log isolation. • Implements `FlushCompaction` and `get_last_compaction_time` endpoints in the Rust sysdb. • Wires up `s3_*` metrics for object storage observability. • Adds Spanner migration DML support and default tenant migrations. • Adds Spanner migration checksum validation to the PR workflow. • Adds Tokio runtime metrics for internal performance visibility. • Preallocates S3 read buffers based on `content-length` header, reducing allocations on large object reads.

Chroma 1.4.1

Wed, 14 Jan 2026 19:19:18 GMT

Chroma 1.4.1 adds indexing status visibility across Python, TypeScript, and Rust clients, plus eventual consistency in query nodes. • Adds indexing status support to the Python client, enabling callers to inspect whether a collection has finished indexing. • Adds indexing status support to the TypeScript and Rust clients, bringing parity across all three client SDKs. • Introduces eventual consistency in query nodes, allowing reads to proceed without waiting for full replication to complete. • Adds eventual consistency support in the frontend layer. • Adds a `clap`-based CLI to `spanner-migrations` with support for multiple migration directories. • Adds a `quorum_writer` to `wal3` for parallel future coordination. • Adds replicated interfaces to `wal3`. • Introduces multi-region, multi-cloud configuration support. • Adds the schema for Rust Log Service in Spanner. • Adds a dead-letter queue globalization mechanism in SysDB. • Adds a purge threshold for cursors that have been reinserted a suspicious number of times. • Adds Spanner collection and segments schemas. • Adds frontend logic and metering for indexing status.

Chroma 1.4.0

Wed, 24 Dec 2025 02:59:03 GMT

Chroma 1.4.0 adds group-by search, CMEK support, and a new Rust sysdb service to Python, JS, and Rust clients. • Adds `group_by` operator to collection search in the Python and JS clients, with quota enforcement, enabling faceted or clustered retrieval in a single query. • Adds CMEK (Customer-Managed Encryption Key) support in the Python and JS clients. • Adds `base_url` specification support in the JS client OpenAI embedding function, allowing custom or self-hosted OpenAI-compatible endpoints. • Adds `count_collections` to the Rust client (released as Rust client 0.10.0). • Introduces a new Rust sysdb service with a gRPC server, config file support, Spanner emulator integration, schema migration runner, checksummed migration manifests, and a feature-flag-gated migration service. • Adds Contextual AI as a new Chroma integration.

Chroma 1.3.6

Wed, 10 Dec 2025 05:26:15 GMT

Chroma 1.3.6 adds sparse vector labels, CMEK storage support, `getCollectionByCrn` in JS, multi-key stats filtering, and a Python statistics wrapper API. • Adds `getCollectionByCrn` API to the JS client, enabling collection lookup by Cloud Resource Name. • Adds `key` parameter to `get_statistics` for filtering stats, and extends it to accept multiple filter keys simultaneously. • Adds Python wrapper API for the statistics function, with a required output collection argument. • Adds `get_attached_function` HTTP endpoint for retrieving attached function details. • Adds `detach` as a method directly on the `Collection` object in the Python client. • Adds `include_tokens` option (previously `store_tokens`) for token storage in Chroma Cloud SPLADE sparse vectors. • Adds sparse vector label support in the Python client for sparse vector tokens stored in metadata values. • Adds CMEK (Customer-Managed Encryption Key) support across storage, the compactor, log service, and the collection schema. • Adds a collection blacklist capability to restrict which collections can run attached functions. • Enforces a one-attached-function-per-collection limit, preventing duplicate function attachments. • Adds `blank_task` support for the `ChromaCloudQwenEmbeddingFunction`. • Enables Chroma Cloud embedding functions to retrieve the API key from the client or from the request header automatically. • Exposes `host` and `port` parameters to the `CloudClient` constructor. • Makes cache types configurable in server deployments. • Adds ASAN (AddressSanitizer) support to the OSS build. • Adds GCS support via `aws-sdk-go-v2`, enabling unified SDK access to Google Cloud Storage. • Improves schema error handling on the read/write path, returning HTTP 400 for user errors and HTTP 500 for internal errors. • Adds prefetch-on-materialize optimization to improve read performance. • Deletes SPANN empty posting lists during cleanup to reduce index bloat. • Automatically deletes an attached function when its output collection is deleted, and cascades soft-deletes from the input collection. Breaking changes: • The `store_tokens` parameter is renamed to `include_tokens` for token storage configuration in attached functions.

Chroma 1.3.5

Tue, 18 Nov 2025 10:09:22 GMT

Chroma 1.3.5 adds Nomic and Google GenAI embedding functions, Transformers.js EF, GCS storage, keepalive/max-conn controls, and non-prefixed EF env vars. • Adds support for non-prefixed embedding-function environment variables in the Python client, so EF config env vars no longer require a prefix. • Adds keepalive and maximum connections configuration to the Python client for tuning long-lived gRPC/HTTP connections. • Adds a Nomic embedding function to the Python client via the `[ENH] Add nomic embedding function` integration. • Adds a Google GenAI embedding function to the Python client. • Adds a Transformers.js embedding function to the JavaScript client, with compatibility maintained with the Python client. • Adds auto-loading of the embedding-function package if it is already installed, removing the need to manually import it. • Adds a GCS (Google Cloud Storage) client as a storage backend. • Adds schema validation for embedding functions defined in a collection schema, with client-side validation that a sparse source key requires an explicit embedding function. • Garbage-collects soft-deleted attached functions to reclaim storage over time.

Chroma 1.3.3

Wed, 05 Nov 2025 02:09:06 GMT

Chroma 1.3.3 adds a BM25 sparse embedding function to the Python client. • Adds `chroma_bm25` embedding function to the Python library, enabling sparse BM25-based retrieval alongside existing dense embedding functions.

Chroma 1.3.2

Tue, 04 Nov 2025 04:57:47 GMT

Chroma 1.3.2 adds Qwen to the JavaScript embedding package list. • Adds Qwen to the list of supported JS embedding packages.

Chroma 1.3.0

Wed, 29 Oct 2025 03:08:08 GMT

Chroma 1.3.0 adds a BM25 embedding function for JS, exports schema/search types from `chromadb.api`, and enforces `source_key`/`ef` pairing rules. • Exports schema and search types directly from `chromadb.api`, making them importable without reaching into internal modules. • Adds true.into::() helper to the Rust client for ergonomic `Where` clause construction. • Enforces a validation error when `source_key` is set without an `ef` parameter, preventing silent misconfiguration. • Adds BM25 embedding function to the JavaScript client. • Adds local support for schema, including recognizing and flushing new metadata keys to schema on local compaction. • Integrates task operators into compaction and implements `create_task` with two-phase commit (2PC) and idempotency. • Limits concurrency on operators spawned by garbage collection to improve resource control. • Adds the Rust client to the official list of supported clients.

Chroma 1.2.2

Sun, 26 Oct 2025 22:10:11 GMT

Chroma 1.2.2 ships a major Rust client expansion with new collection methods, BM25 support, and a chroma_cloud() constructor. • Adds get_collection() and delete_collection() methods to the Rust client. • Adds collection.modify() method to the Rust client for updating collection properties. • Adds chroma_cloud() constructor for `ChromaClientOptions` to simplify connecting to Chroma Cloud from the Rust client. • Renames `ChromaClient` to `ChromaHttpClient` in the Rust client. • Renames config field `default_database_name` to `database_name` in the Rust client. • Makes get_database_name() and get_tenant_id() public accessors on the Rust client. • Adds BM25 sparse retrieval support to the Rust client. • Adds `Where` clause serialization to the Rust client, enabling filtered queries. • Adds builder pattern for `SearchPayload` in the Rust client. • Adds schema helpers and `Key` object support to the Rust client schema API. • Supports `From` conversions for `UpdateMetadataValue` in the Rust client. • Exports top-level options and types from the `chroma` crate for easier downstream use. • Adds schema support (`config` -> `schema` on create_collection()) to the JavaScript client. • Adds query-string embedding support in the search API, enabling text queries without pre-embedding. • Adds `SysDB` functionality and a Rust task client with execution operators for `TaskRunner` support. • Adds stateful quota enforcement for the number of functions. • Controls how far into the future the s3heap scans, improving storage scheduling flexibility. Breaking changes: • `ChromaClient` is renamed to `ChromaHttpClient` in the Rust client — any code referencing the old name will fail to compile. • The `default_database_name` field in `ChromaClientOptions` is renamed to `database_name` — existing Rust client configurations using the old key will break. • The `config` parameter on create_collection() is renamed to `schema` in the Rust client — call sites using the old name must be updated.

Chroma 1.1.1

Sun, 05 Oct 2025 02:52:47 GMT

Chroma 1.1.1 adds BM25 embedding function, schema types, headless CLI login, RRF support, and per-tenant BM25 override • Adds `bm25` embedding function to the Fastembed integration, alongside additional parameters for the existing Fastembed embedding function. • Introduces schema types support via new schema type definitions for collections. • Adds headless login mode to the Chroma CLI, enabling non-interactive authentication flows. • Implements Reciprocal Rank Fusion (RRF) helper expression for combining ranked search results. • Supports per-tenant override for BM25 configuration. • Allows `dict` as search args in query calls. • Supports `nodeSelector` and `tolerations` configuration for the sysdb component in Kubernetes deployments. • Adds a read-only mode for the Rust log service. • Enables the Rust log service to start without requiring a dirty log. • Improves AWS S3 SDK usage for object storage interactions.

Chroma 1.1.0

Tue, 16 Sep 2025 21:23:50 GMT

Chroma 1.1.0 adds a search API with BM25/SPLADE support, id filters in where clauses, GC control interface, and mem0 integration. • Adds `query_config` on collection configuration supporting `splade` and `bm25` EFS settings for configurable full-text search behavior. • Supports id filter in `where` clause, enabling document-ID-based filtering alongside metadata filters in queries. • Implements IDF modifier for the BM25 index, improving relevance scoring for full-text search. • Makes rank expressions operational in the search API, enabling custom ranking logic at query time. • Adds quota enforcement to the search API to cap resource usage per request. • Adds validation for metadata and sparse vectors submitted to the search API. • Adds new methods to `ClientManager` for expanded programmatic client lifecycle control. • Adds a control interface for garbage collection (GC), enabling operational management of compaction cleanup. • Integrates Chroma with mem0 for persistent memory layer support. • Increases cloud quotas and updates defaults, expanding the operational envelope for hosted deployments.

Chroma 1.0.21

Thu, 11 Sep 2025 22:34:58 GMT

Chroma 1.0.21 adds sparse vector support with a new search endpoint, AVX512-accelerated distance calculations, and HNSW index loading without disk intermediary. • Adds `get_collection_by_crn` to the JS client for retrieving collections by cloud resource name. • Adds new internal SPANN config `nreplica_count` to limit the number of centers considered on write. • Adds AVX512 support to distance calculations, accelerating nearest-neighbor search on compatible hardware. • Implements sparse vector support, integrating a sparse index into the metadata segment. • Implements a new `search` endpoint supporting sparse vector queries, with updated auth and metering. • Implements `search` for the Python client, enabling sparse vector queries directly from Python. • Allows adding annotations to the SysDb deployment in the Helm chart. • Loads HNSW index without a disk intermediary, reducing I/O overhead on the write path. • Auth hooks now return user identity, enabling identity-aware authorization logic. • Adds the requesting tenant as a `requester:UUID` scorecard tag for improved observability. • Adds metrics for the log client and compactor. • Manifest and etag caching added to the log layer to reduce redundant fetches. • Improves Python client write throughput via internal optimizations. • Optimizes block decoding performance.

Chroma 1.0.18

Mon, 18 Aug 2025 08:09:35 GMT

Chroma 1.0.18 adds AVX-accelerated distance calculations, a garbage collection CLI, CloudClient auto-tenant, and collection-by-CRN lookup. • Adds a garbage collection CLI command for manual garbage collection of collections. • Adds a config parameter to the garbage collector controlling how many collections are fetched from SysDb. • Enables getting a collection by CRN (Cloud Resource Name) via `CloudClient`. • Auto-sets tenant and scoped database in the Python `CloudClient`, removing manual configuration. • Adds support for a default space in the create-collection config. • Adds AVX-accelerated distance calculations, with a build flag to enable AVX in Rust, unlocking faster nearest-neighbor queries on supported hardware. • Adds a metric for component queue depth and changes dispatcher queue depth metric buckets. • Adds NAC metrics for the write half, expanding observability coverage. • Optimizes `GetCollections` query performance by removing raw GORM usage. • Changes `get_range` to return an iterator, reducing memory pressure for large range scans.

Chroma 1.0.17

Thu, 14 Aug 2025 22:52:05 GMT

Chroma 1.0.17 adds an update_tenant API, AVX512 Docker support, WordPress integration, and configurable concurrent block flushes. • Adds `update_tenant` API endpoint for modifying tenant configuration. • Adds a Dockerfile flag to enable AVX512 instruction set for accelerated vector operations. • Makes the number of concurrent block flushes configurable in the compactor. • Adds WordPress (AI Engine Pro) as an officially listed Chroma integration. • Adds an index on collections with `created_at` as sort key, improving collection query performance. • Reduces peak memory usage of the compactor. • Enables scorecarding of fork collection by collection or tenant.

Chroma 1.0.16

Fri, 08 Aug 2025 00:26:25 GMT

Chroma 1.0.16 adds Morph embeddings, adaptive SPANN search, dead-letter compaction queuing, SysDB leader election, and a batch of new operational metrics and tooling. • Adds delete_many() method to the storage API, enabling bulk deletion of storage objects in a single call; the garbage collector and `DeleteUnusedFiles` operator now consume it. • Bumps GC delete batch size from 100 to 1,000 for faster garbage collection throughput. • Adds counter metrics for S3 `put`, `delete`, and `delete_many` operations. • Adds block-level metrics for deeper storage observability. • Adds NAC and dispatcher metrics. • Adds hostname to cache metrics. • Adds an index on `database_id, name` on the `collections` table in sysdb to accelerate collection lookups. • Adds config to enable log GC on a per-tenant basis, with GC config extractable under a specific key when present. • Adds leader election for SysDB. • Adds dead-letter queuing for compaction jobs to handle persistently failing jobs. • Adds query affinity enforcement so repeated queries route to the same node. • Adds adaptive `nprobe` selection for SPANN index searches based on collection size. • Adds Morph embedding functions. • Adds a tool for patching logs deleted before a new manifest was installed. • Adds a tool to purge the cache. • Adds an endpoint and tool to roll back a collection log offset after disaster recovery. • Adds auto-repair when the log offset is behind sysdb. • Adds cache mount and tolerations support to the garbage collector template in the Helm chart. • Limits the number of concurrent get_all_block_ids() calls when using buffer_unordered() to reduce resource exhaustion. • Deduplicates inserts to the same key in the foyer cache layer. • Optimizes literal matching in metadata filtering. • Parallelizes block fetching for brute-force regex queries. • Prefetches segments during `get` and `query` operations. • Adds a `pprof` server to both the query service and compaction service. • Enforces a default limit on `get` when none is supplied. • Allows users to define null EFs (HNSW `ef_search`/`ef_construction`) on collection creation. • Changes `ResourcesExhausted` gRPC status into a backoff/429 response for the log client. • The `/add` and `/upsert` endpoints now return an error when embeddings are not provided, and `/add` enforces a minimum embedding dimension. Breaking changes: • The `/add` endpoint now returns an error if embeddings are not provided (previously accepted adds without embeddings). • The `/upsert` endpoint now returns an error if embeddings are not provided. • The `/add` endpoint now enforces a minimum embedding dimension. • `GenericQuotaError` HTTP status code changed from 429 to 422.

Chroma 1.0.15

Wed, 02 Jul 2025 17:07:55 GMT

Chroma 1.0.15 adds CLI env-var config, Python CloudClient env-var support, per-blockfile block sizes, S3 prefix separation, and three-phase WAL3 garbage collection. • Adds CLI support for setting Chroma environment variables directly via the CLI (`CLI 1.1.3`/`1.1.4` release). • Enables the Python `CloudClient` to read connection arguments from environment variables, reducing hardcoded credentials in scripts. • Adds ability to set different block sizes for different blockfiles via config (`sanketkedia` PR #4948). • Supports writing data to separate prefixes in S3, allowing control and data plane storage isolation. • Adds config to disable log GC entirely for operators who need to suppress background garbage collection. • Implements three-phase garbage collection for WAL3, wiring the garbage collector to a safer, staged delete process. • Enforces a maximum limit of 100 on `get_collections` calls. • Returns `database_id` in the `get_collections` call from sysdb, exposing more collection metadata. • Adds a scrubbing tool that supports limits, enabling bounded scrub operations. • Adds log-slicing capability when pulling logs to narrow down problems during diagnostics. • Pipelines compactions for different collections concurrently, improving throughput under multi-collection workloads. • Makes IO accesses parallel for improved read performance. • Upgrades foyer cache library to `0.17.3`. • Adds granular locking for the posting list, reducing contention during concurrent writes. • Adds more concurrent blockfile writer support. • Applies `TracedJson` to `/upsert` and `/update` endpoints for improved distributed tracing coverage. • Adds request timing to metering instrumentation. • Migrates metering functionality to a new metering library. • Makes S3 tracing spans less verbose by default, reducing observability noise. • Improves `ListCollectionsToGc` with a filter for minimum alive versions. • Skips log GC in dry-run mode, allowing safe rehearsal of GC operations. • Purges dirty log in the background at the end of scheduled compaction. • Moves Log GC to an operator model. • Batches delta conversion for increased speed (`PERF` #4551). • Improves JS client error messaging for clearer failure diagnosis.

Chroma 1.0.13

Wed, 18 Jun 2025 22:16:05 GMT

Chroma 1.0.13 ships a new JS client, GCv2 grace period, WAL3 garbage collection, and new GetCollections parameters. • Adds `include soft deleted` and `collection IDs` parameters to `GetCollections` API, enabling filtered collection lookups by ID and soft-deleted state. • Adds `getCollectionById` method to the new JS client. • Adds `truncation` and `input_type` fields to the VoyageAI embedding integration. • Adds `num_records_before_backpressure` configuration for the log service to control backpressure thresholds. • Adds `resource_name` column to the SysDB tenants table. • Adds a Copy API to Chroma storage, backed by scan/AWS S3 native copy for WAL3. • Adds `list_prefix` operations support for S3 and AC/S3 storage backends. • Adds garbage collection for WAL3 logs. • Adds a grace period for transitioning soft-deleted collections to hard-deleted state in GCv2. • Defaults to garbage collection delete v2 mode when running locally. • Adds a tool to purge a collection from the dirty log. • Adds a tool to inspect the contents of the log. • Enables WAL3 for the default tenant. • Adds a log client healthcheck capability. • Adds a `nac` delay histogram metric for observability. • Bumps the AWS Go S3 SDK to v2. • Removes CoreML as a provider for the default embedding function. • Improves HTTP client with base64 encoding on requests. • New JS client release with updated documentation.

Chroma 1.0.12

Sat, 31 May 2025 02:41:46 GMT

Chroma 1.0.12 adds a Mistral embedding function, per-tenant exclusions, garbage-collector hard deletes, and block prefetch by prefix. • Adds `FinishDatabaseDeletion` gRPC method to support soft-delete of databases and hard-delete via the garbage collector. • Adds a readiness probe for the garbage collector service. • Adds validation when multiple embedding functions are set on the client. • Adds Mistral embedding function across clients. • Adds per-tenant exclusions support demonstrated and tested in the MDAC layer. • Adds prefetch-block-by-prefixes capability to improve data loading performance. • Moves collection hard deletes from sysdb inline path to the garbage collector (GC v2), including new cleanup modes wired to `FinishDatabaseDeletion`. • Adds a Rust log service memberlist component for distributed log coordination. • Adds explicit seal/migrate calls for the log service.

Chroma 1.0.10

Thu, 22 May 2025 03:00:45 GMT

Chroma 1.0.10 adds SPANN metrics, quota-exceeded error handling, log sealing in Go, and WAL3 bootstrap from existing content. • Adds `ChromaQuotaExceededError` handling so applications can catch and respond to quota limit violations explicitly. • Adds SPANN metrics instrumentation for observability into the SPANN index layer. • Adds log sealing to the Go log service. • Emits `log_uncompacted_record_count` metric from the Rust log service for monitoring uncompacted record accumulation. • Adds a safety cutoff to the Rust log service to bound runaway growth. • Bootstraps a WAL3 log from existing content, enabling migration/initialization from pre-existing data. • Exposes `may_contain` for the disk cache and uses it in prefetch to reduce unnecessary I/O. • `ListCollectionsToGc` now returns lineage file path, groups results by fork tree, and accepts an optional tenant parameter for filtering. • SysDb now returns lineage, version file paths, and root collection ID on collection responses. • Improves local query execution by using subqueries for full-text search and unions for integer and float metadata expressions. • Adds named labels to various foyer caches for easier cache-level observability. • Supports custom datasets for Chroma load testing. • Bumps the JS client to v2.4.5. • Releases CLI version 1.1.2.

Chroma 1.0.9

Tue, 13 May 2025 03:40:00 GMT

Chroma 1.0.9 adds `$regex` metadata filtering, automatic retries for writes, and lets the Python client delete metadata fields. • Introduces `$regex` metadata filter operator (renamed from `$matches`) for filtering collection records by regular expression patterns in queries. • Adds `NUM_REGEX_PREDICATES` quota and a quota on regex pattern length to bound regex filter usage. • Adds automatic retry logic for `add`, `update`, and `upsert` operations on transient failures. • Makes metadata optional in the Python client's update/upsert calls, enabling deletion of metadata fields by omitting them. • Disallows empty string IDs during `add`, returning an error immediately rather than silently storing invalid records. • Writes the embedding function to the collection config when one is provided at collection creation. • When SPANN is enabled, HNSW configuration is now automatically routed to SPANN; removes the `enable_set_index_params` flag. • Adds a route and tool to inspect the dirty log for operational debugging. • Adds caching (persistent cache) to the Rust log service, with configurable `hostPath` and `mountPath`. • Allows collections to shunt to an alternate log per tenant. • `QuotaExceededError` now includes an optional human-readable message field for more actionable quota error responses. Breaking changes: • The `$matches` metadata filter operator is renamed to `$regex`; queries using `$matches` will break on upgrade. • The `enable_set_index_params` flag is removed; HNSW configuration is now routed automatically when SPANN is enabled.

Chroma 1.0.8

Mon, 05 May 2025 09:26:52 GMT

Chroma 1.0.8 adds collection forking, Together AI and Cloudflare Worker AI embeddings, pandas export, regex filters, and subset-ID queries in Python and JS. • Adds `query` support for filtering on a subset of IDs in both Python and JS clients. • Adds Together AI embedding function in Python and JS clients. • Adds Cloudflare Worker AI embedding function. • Adds to_pandas() (or equivalent) conversion of `Get`/`QueryResult` to pandas DataFrames. • Adds collection forking to the JS client (JS client v2.3.0 / v2.4.0). • Wires up regex filter from client through to the query node. • Adds authorization support for the HuggingFace Embedding Server. • Enables authentication for collection forking operations. • Turns on SPANN (sparse approximate nearest-neighbor) index by default. • Adds a `browse` subcommand to the CLI (CLI v1.1.0). • Refactors the CLI client (CLI v1.1.0).

Chroma 1.0.6

Tue, 22 Apr 2025 05:44:20 GMT

Chroma 1.0.6 adds collection config support with SPANN tuning, expanded Jina embedding models, and collection lineage tracking. • Adds SPANN index configuration to collection config, letting users tune the SPANN ANN index parameters per collection. • Exposes collection configuration in server responses and via gRPC, enabling clients to read and update collection config through the API. • Adds collection config support to the JavaScript client. • Updates the Jina embedding function to support all Jina models and their configurations, not just a fixed subset. • Adds root collection ID and lineage file name fields to the collection table for provenance tracking. • Sets up a Grafana dashboard for the Foyer cache layer, enabling operational visibility into cache metrics. • Adds user-agent propagation to Rust frontend traces for improved distributed tracing context. • Improves backoff and throttling behavior for WAL3 and adds dynamic priority adjustment for S3 GET operations.

Chroma 1.0.5

Wed, 16 Apr 2025 17:36:11 GMT

Chroma 1.0.5 adds image support in Cohere embeddings, request priority in storage, query retries, and wal3 re-enablement. • Adds image support to the Cohere embedding function, enabling multimodal embedding workflows. • Introduces request priority in the storage layer, allowing differentiated handling of storage I/O. • Re-enables `wal3`, the next-generation write-ahead log implementation. • Adds `scout-logs` function to find the max log position in `wal3`. • Adds TTL to the sysdb cache on RFE (read-for-existence) paths. • Sets up rendezvous hashing for collection-to-garbage-collector node mapping in Kubernetes deployments. • Allows specifying environment variables for the garbage collector Kubernetes template. • Enables automatic retry of query paths on transport errors. • Adds prefetching of posting lists during query and compaction to improve throughput. • Makes snapshot operations recursive. • Adds OpenTelemetry export error logging for observability into telemetry pipeline failures. • Garbage collector logs now emitted to stdout. Breaking changes: • The `page`, `page_size`, and `sort` arguments on `get` have been removed.

Chroma 1.0.4

Thu, 10 Apr 2025 01:05:37 GMT

Chroma 1.0.4 adds a Baseten integration, bundles the CLI in the JS client, and supports `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` for metrics routing. • Supports overriding the metrics endpoint via the standard `OTEL_EXPORTER_OTLP_METRICS_ENDPOINT` environment variable. • Adds Baseten as a new embedding provider integration. • Bundles the Chroma CLI inside the JS client package. • Switches CLI login to server-side token verification. • Adds frontend metrics attributes for improved observability. • Adds graceful shutdown for the garbage collection (GC) system. • Limits the maximum number of collections processed in a single GC run.

Chroma 1.0.3

Mon, 07 Apr 2025 22:34:04 GMT

Chroma 1.0.3 adds metrics for garbage collection and improves sysdb S3 configuration parity. • Adds metrics for garbage collection to enable observability into collection cleanup operations. • Improves sysdb S3 config to achieve parity between local development and deployed environments, including necessary additional parameters.

Chroma 1.0.0

Thu, 03 Apr 2025 20:35:38 GMT

Chroma 1.0.0 ships a Rust frontend with full CRUD routes, multi-dimensional admission control, round-robin gRPC load balancing, and a garbage-collection orchestrator. • Adds `/add`, `/upsert`, `/update`, `/delete`, `/reset`, and collection read/write routes to the new Rust frontend, making the Rust service a full API peer to the Python FastAPI layer. • Adds push_logs() to the log interface in the Rust frontend, exposing programmatic log ingestion. • Implements multi-dimensional admission control (mdac) with a circuit-breaker scorecard wired to config-supplied default rules, plus Prometheus metrics for the circuit breaker. • Implements a garbage-collection orchestrator with a `Fetch version file` operator and a background poller in the sysdb client crate, enabling automated GC of deleted collection data from S3. • Adds `get_collection_size` to the Python SysDB client and exposes `GetCollectionSize` on the SysDB read replica, letting callers query live record counts without hitting the primary. • Adds `num_records_last_compaction` field to sysdb and updates the compactor to flush total record counts on each compaction cycle. • Adds a `collection_id` parameter to QuotaEnforcer.enforce() calls, enabling per-collection quota enforcement. • Implements a partitioned mutex for HNSW index loading, reducing contention when loading multiple segments concurrently. • Switches the Python Ollama embedding function to the official `ollama` Python client and switches the JS Ollama embedding function to the official `ollama` JS client. • Adds round-robin gRPC connection balancing across N query nodes and balances gRPC channels for frontend-to-query retries, improving query-node throughput. • Changes the dispatcher task queue from LIFO to FIFO ordering and bounds the maximum number of enqueued tasks, aborting tasks that exceed the limit. • Adds block prefetching for the fulltext index writer, reducing I/O latency during compaction. • Creates version files in S3 from SysDB, enabling object-level GC tracking. • Adds gRPC endpoints in SysDB to support garbage collection workflows. • Adds route-level tracing to the Rust frontend and propagates tracing spans through intermediate methods between SysDB and FastAPI, with dynamic span names visible in Jaeger. • Implements `get_collections_with_segments` deduplication on the SysDB RPC path, reducing redundant calls from the frontend. • Adds Rust–Python proxy calls, allowing the Rust frontend to call back into Python handlers during the migration period. • Adds a no-invalidation collection cache and a nop cache variant to the Rust frontend, with `RwLock`-protected memberlist access. • Serializes `Where` clause filters and full query plans to/from ProtoBuf in the Rust frontend, enabling typed query dispatch to query nodes. • Implements request validators in the Rust frontend for collection-level operations. • Increases the SysDB gRPC max concurrent streams limit to improve throughput under high collection-metadata load.

Chroma 0.6.3

Tue, 14 Jan 2025 22:21:19 GMT

Chroma 0.6.3 adds list/delete database APIs, a GC service, async rate limiting, and raises the default `ef_search` to 100. • Updates `ef_search` default value to 100, improving out-of-the-box HNSW recall. • Adds API to list all databases for a tenant, with both single-node and distributed implementations. • Adds method to delete a database, with both single-node and distributed implementations. • Introduces a GC (garbage collection) tool and service for distributed deployments. • Adds a simple async rate limiter for async request handling. • Adds concurrency and stream-processing flags to the Go binary.

Chroma 0.6.2

Tue, 07 Jan 2025 06:46:56 GMT

Chroma 0.6.2 adds Voyage AI embedding integration and parallelized log materialization for faster segment writes. • Adds Voyage AI embedding integration via the `[ENH] Voyage Integration` feature, enabling Voyage models as an embedding function. • Parallelizes applying materialized log to segment writers, improving write throughput for high-volume ingestion workloads. • Pipelines segment committing and flushing to reduce latency during compaction.

Chroma 0.6.1

Fri, 03 Jan 2025 05:18:45 GMT

Chroma 0.6.1 adds MPS-accelerated OpenCLIP embeddings, HNSW integrity validation on load, and OpenTelemetry foyer metrics export. • Exports foyer metrics via OpenTelemetry (`otel`), enabling observability of Chroma's internal cache layer. • Validates HNSW index integrity on load, catching corrupted index state at startup rather than at query time. • Supports MPS (Apple Silicon GPU) accelerated OpenCLIP embeddings, improving embedding throughput on macOS devices.

Chroma 0.6.0

Mon, 30 Dec 2024 22:03:23 GMT

Chroma 0.6.0 ships SPANN vector index with full query/update/delete, HNSW query pushdown, full-text-search mixins, and a 30% deserialization speedup. • Adds `GetCollectionWithSegments` endpoint to SysDB and propagates segment information from the frontend to the query node, enabling query pushdown. • Implements the SPANN (Space Partition Approximate Nearest Neighbor) index with a full read/write path: K-Means clustering, append, update, delete, segment reader, posting list fetch, brute-force distance computation, merge operator, and query orchestrator. • Implements rank() for blockfile, replacing the deprecated get_at_index() method. • Adds full garbage collection and batched GC for the SPANN index. • Adds NAC (Neighborhood Access Control) to the write path. • Supports full-text-search mixins for query composition. • Exports the `Collection` type directly from the Python client library. • Delivers a ~30% query performance improvement by fixing a double-deserialization issue in the Python layer. • Publishes the Helm chart to ECR. • Adds sinusoid and sawtooth load patterns to `chroma-load` for realistic traffic simulation. • Enables `chroma-load` to save and restore running workloads across restarts. • Adds support for delayed workloads in `chroma-load-start`. • Adds parameterized query support to `chroma-load`. • Adds metrics-only support to `chroma-load`. • `list_collections` client methods now return a list of `Collection` objects instead of raw data.

Chroma 0.5.23

Thu, 05 Dec 2024 06:36:17 GMT

Chroma 0.5.23 introduces SPANN segment/index, hybrid read workload support, and Kubernetes query replicas. • Introduces SPANN segment and index with append, commit, and flush operations for scalable approximate nearest-neighbor search. • Adds support for RI-4 and RI-5 hybrid read workloads in `chroma-load`. • Adds delay support on workloads in `chroma-load`. • Adds figment-based configuration for `chroma-load`. • Adds a `chroma-load` Dockerfile for containerized load testing. • Adds Kubernetes support for query replicas via Helm chart.

Chroma 0.5.16

Tue, 29 Oct 2024 00:33:51 GMT

Chroma 0.5.16 adds rate limiting across all operations, tenant/database scoping for collection ops, and `RUST_LOG`-driven tracing configuration. • Adds `RUST_LOG` environment variable support to configure tracing verbosity for Chroma's Rust components. • Introduces rate limiting via `@rate_limit` applied to all collection operations, including `add` and `query`. • Adds tenant and database scoping to Collection operations, threading `tenant`/`database` identifiers through the full request path. • Overhauled HTTP API routes for the Chroma server. • Adds a count index to the blockfile layer, improving internal data structure capabilities. • Flushes blocks in parallel, improving write throughput for large datasets. • Enables distributed tracing instrumentation (`tracing::instrument`) for foyer cache calls. • Adds typed UUIDs (`IndexUuid`, `CollectionUuid`) to distinguish index and collection identifiers in the Rust codebase. • Introduces a Sparse Index Reader/Writer split, separating read and write paths for the sparse index. • Disables PostHog profile telemetry collection.

Chroma 0.5.13

Thu, 10 Oct 2024 23:05:42 GMT

Chroma 0.5.13 brings persistent block/sparse index caches and binary search for range filter operators. • Switches block and sparse index caches to a persistent type, improving cache durability across restarts. • Accelerates `gt`, `gte`, `lt`, and `lte` metadata filter operations using binary search, reducing lookup time on large indexes.

Chroma 0.5.12

Tue, 08 Oct 2024 21:42:36 GMT

Chroma 0.5.12 delivers 21x faster full-text queries, unified filter-operator semantics, and a new disk/memory-backed cache. • Changes the semantics of `$ne`, `$nin`, and `$not_contains` operators for local Chroma to align with hosted Chroma behavior. • Delivers 21x faster full-text querying via internal index improvements. • Adds disk- and memory-backed caching powered by Foyer 0.10, enabling larger-than-RAM working sets. • Adds tenant, database, and collection IDs to distributed traces when available, improving observability. • Introduces a `RateLimitEnforcer` abstract class for implementing rate-limiting policies. • Makes Chroma available in early access on hosted infrastructure. Breaking changes: • The semantics of `$ne`, `$nin`, and `$not_contains` for local Chroma have changed — queries relying on the previous local behavior may return different results after upgrading.

Chroma 0.5.7

Fri, 20 Sep 2024 17:27:30 GMT

Chroma 0.5.7 adds WAL pruning/vacuuming, a vacuum CLI command, Network Admission Control, multipart S3 uploads, and weighted LRU HNSW cache. • Adds `vacuum` CLI command for manual WAL vacuuming of the database. • Adds config fields `max partition size` and `max compaction size` in the compactor for tuning compaction behavior. • Adds `replicaCount` and `nodeSelector` Helm config fields for the log service, and `replicaCount` for the compaction service. • Adds `nodeSelector` support for pods as an alternative to tolerations in the Helm chart. • Adds `tenant` parameter to the JS `CloudClient`. • Returns `chroma-trace-id` header in API responses and includes trace ID in thrown errors for easier distributed tracing. • Adds automatic WAL pruning and vacuuming via .clean_log() on Producers, removing the need for manual log maintenance. • Introduces Network Admission Control (NAC) APIs that rate-limit block manager and HNSW provider requests. • Supports multipart S3 uploads (automatically used only when object size exceeds part size), improving large-object storage reliability. • Adds a weighted LRU cache for the HNSW provider, evicting older index versions when a newer version of a collection is fetched. • Adds garbage collection for the log service. • Adds metadata column indices to speed up metadata queries. • Adds a metric for the total number of uncompacted log records. • Enables gRPC retries on all channels and lifts frontend gRPC retry logic to the application layer with tracing. • Adds timeouts to frontend gRPC clients. • Adds CPU/memory requests and limits for SysDB to the Helm chart. • Adds frontend toleration and replica count support to the Helm chart. • Fetches S3 blocks in parallel, improving blockfile load performance. • Skips brute-force search when the log is empty, reducing unnecessary computation. • Skips querying `MetadataSegmentReader` for empty `where` clauses. • Uses jemalloc allocator for the compactor service to reduce memory usage. • Prefetches APIs for Record segment and blockfile, dispatched as an I/O operator for improved query throughput. • Purges block cache after compaction to reclaim memory. • `GET /databases` now returns HTTP 404 instead of 500 when a database is not found.

Chroma 0.5.4

Thu, 11 Jul 2024 02:31:06 GMT

Chroma 0.5.4 adds configurable block size, HNSW cache reads, S3 retries, collection config storage, and faster JSON via orjson. • Adds configurable block size via `[ENH] Configurable block size`, letting operators tune storage layout for their workloads. • Introduces `Collection Configuration Storage` to persist per-collection configuration alongside data. • Switches the Python client HTTP layer from `requests` to `httpx` for improved async and timeout support. • Adds timeouts to the log client, S3 storage layer, and sysdb client to bound hung operations in distributed deployments. • Enables reading directly from the HNSW cache, reducing redundant index loads during queries. • Adds automatic S3 retry logic to improve resilience against transient object-storage failures. • Supports metadata updates where the new value is a different type than the existing value. • Uses `orjson` in the Python client for faster JSON serialization/deserialization. • Uses binary search in the positional posting list for improved query performance. • Adds a `__repr__` to the `Collection` object for clearer interactive inspection. • Improves OpenAPI type definitions for better client code generation. • Adds panic capture in query-service handlers and task operators to prevent silent worker crashes.

Chroma 0.5.0

Tue, 23 Apr 2024 23:10:39 GMT

Chroma 0.5.0 adds Ollama and Roboflow embedding functions, LangChain EF support, rate limiting, gRPC interceptors, and a new Arrow-backed blockfile storage engine. • Adds `device` param to the `OpenCLIP` embedding function, letting callers specify CPU or GPU at initialisation time. • Adds optional `kwargs` passthrough when initialising the `SentenceTransformerEmbeddingFunction` class. • Adds `$not_contains` operator for `WhereDocument` filters. • Adds `end_timestamp` parameter to the `PullLog` API. • New `OllamaEmbeddingFunction` embedding function for locally-hosted Ollama models. • New `RoboflowEmbeddingFunction` embedding function for Roboflow-hosted vision models. • Adds support for LangChain embedding functions as first-class Chroma embedding functions. • Adds rate limiting and quota enforcement at the server layer. • Adds gRPC client and server interceptors (Python and Go) for distributed deployments. • New Arrow-backed blockfile storage engine with block builder, block iterator, block delta, sparse index, and segment interfaces — foundation for the new distributed query path. • New compaction service with membership propagation, compaction manager, scheduler, and flush API. • New query-service server in Rust with push-based operators, centralised dispatch, and a hardcoded query-plan state machine including a brute-force operator. • Adds a system scheduler enabling tasks to run on a configurable schedule. • Improves server-side serialisation performance using `orjson` and async I/O. • New Helm chart for deploying Chroma on Kubernetes. • Publishes official container images at `ghcr.io/chroma-core/chroma:0.5.0` and `chromadb/chroma:0.5.0`. Breaking changes: • `SubmitEmbeddingRecord` is renamed to `OperationRecord` and the Topic concept is removed from Segment and Collection. • `EmbeddingRecord` is renamed to `LogRecord`; the term `log_offset` replaces `id` throughout the record and result types. • `seq_id` is removed from protos, record types, and result types. • Pulsar is removed from the Python codebase.

Chroma 0.4.24

Wed, 28 Feb 2024 00:39:11 GMT

Chroma 0.4.24 adds metadata indices, blockstore-based full-text search, and server-side log pull with gRPC error handling. • Adds metadata indices to accelerate metadata filtering queries. • Introduces blockstore-based full-text search engine, replacing the prior in-memory approach. • Adds server-side pull logs capability with gRPC error handling for more robust log ingestion. • Makes `PositionalPostingListBuilder` incremental, improving indexing performance for large datasets.

Chroma 0.4.23

Thu, 22 Feb 2024 22:37:28 GMT

Chroma 0.4.23 adds Amazon Bedrock embeddings, SSL client verification, FIPS compliance, CLI log path support, and a Rust-based worker backend. • Adds `[ENH][SEC]: CIP-01022024 SSL Verify Client Config` — TLS client certificate verification support for the Chroma server. • Adds `[ENH]: CLI log path parameter support` — a new CLI parameter to control the log output path. • Adds Amazon Bedrock embedding function, enabling use of AWS Bedrock models for embedding generation. • Adds FIPS compliance mode to the Python client. • Adds exponential backoff with jitter to embedding API calls, reducing failures under rate limits. • Adds `orjson` serialization to the Chroma Python client for faster JSON encoding/decoding. • Adds runtime validation of embedding function response format, catching malformed outputs early. • Adds a default embedding function for the JavaScript client. • Adds Python 3.12 support in tests and releases. • Adds Rust-based worker components including hnswlib bindings, Pulsar topic management, gRPC server, S3 storage backend, SysDB, ingest dispatcher, and a basic blockfile implementation — foundational pieces of the distributed backend. • Adds a quota component to the distributed backend. • Adds segment cache and memory management improvements to the distributed backend. • Adds a FastAPI shutdown hook for cleaner server teardown.

Chroma 0.4.22

Wed, 03 Jan 2024 17:16:25 GMT

Chroma 0.4.22 adds an Amazon Bedrock embedding function for generating embeddings via AWS. • Adds Amazon Bedrock embedding function, enabling Bedrock-hosted models to generate embeddings directly within Chroma.

Chroma 0.4.20

Fri, 15 Dec 2023 06:29:13 GMT

Chroma 0.4.20 adds Gemini and Jina embedding integrations, CloudClient support, and collection pagination. • Adds `CloudClient` support for connecting directly to Chroma Cloud. • Adds `JinaEmbedding` embedding function to the TypeScript client. • Adds Gemini embedding integration. • Adds pagination support for `count_collections`, enabling traversal of large collection lists. • Adds Rust-based rendezvous hashing and assignment policy with config management for the distributed backend.

Chroma 0.4.19

Wed, 13 Dec 2023 00:25:46 GMT

Chroma 0.4.19 adds Jina AI and Hugging Face embedding functions, a `$not_contains` filter, cloud client, and OpenTelemetry tracing. • Adds `$not_contains` filter operator to `where` clause queries, enabling exclusion-based metadata filtering. • Adds `AdminClient` to the Python API and tenancy support to the JavaScript client. • Adds Jina AI embedding function for use as a drop-in embedding provider. • Adds Hugging Face Text Embedding Server embedding function. • Allows default headers to be passed through to the OpenAI API in the OpenAI embedding function. • Passes `input_type` parameter to Cohere embedding models. • Adds a cloud client (`CloudClient`) for connecting to Chroma Cloud. • Adds FastAPI instrumentation and a local observability stack with OpenTelemetry and Zipkin for distributed tracing. • Supports numpy data types natively for embeddings. • Adds create/delete collection event notifications in the Go coordinator. • Adds rendezvous hashing-based worker topic assignment and proxy assignment policies. • Allows auth layer to overwrite request tenant and database, enabling auth-driven multi-tenancy enforcement. • Verifies HTTP clients use HTTP 1.1 or higher.

Chroma 0.4.18

Tue, 21 Nov 2023 18:27:38 GMT

Chroma 0.4.18 adds Jina AI embeddings, FastAPI tracing, OpenAI default headers, and a SHA-256 migration hashing option. • Adds a new setting for configuring the DB migration hashing algorithm, including `sha256` support. • Allows default headers to be passed to the OpenAI API via the OpenAI embedding function. • Passes `input_type` to Cohere embedding models for more precise embedding requests. • Adds a new Jina AI embedding function. • Adds FastAPI instrumentation for improved traceability of server requests.

Chroma 0.4.17

Fri, 10 Nov 2023 21:26:02 GMT

Chroma 0.4.17 adds OpenAI v1.x support and a new system-catalog-provider for simpler deployments. • Supports OpenAI Python package v1.x.x in `utils.OpenAIEmbeddingFunction`, alongside a new `deployment_id` parameter for the v0.x.x API. • Adds `system-catalog-provider` configuration option to simplify distributed/multi-node deployment setup.

Chroma 0.4.16

Wed, 08 Nov 2023 05:34:42 GMT

Chroma 0.4.16 adds authorization (authz) support and multimodal embedding functions. • Adds authorization (authz) framework with resource attribute extraction for tenant, database, and `list_collections` operations, mapping identity attributes to `AuthzUser`. • Adds multimodal embedding functions, enabling embeddings to be generated from multiple modalities (e.g., image and text) within Chroma. • Improves `HTTPClient` connection error messages to surface clearer diagnostics when the server is unreachable.

Chroma 0.4.15

Wed, 25 Oct 2023 16:38:23 GMT

Chroma 0.4.15 adds multitenancy, OTel tracing, gRPC coordinator, and a `--host` flag to the CLI run command. • Adds `--host` option (default: `localhost`) to the `chroma run` CLI command, letting operators bind the server to a specific interface. • Adds OpenTelemetry (OTel) tracing throughout the codebase for distributed observability. • Adds multitenancy support via a new `CollectionAssignmentPolicy` in the system database. • Adds a gRPC-backed Coordinator/SysDB, enabling gRPC communication between Chroma's distributed components. • Adds a CRD-backed `SegmentDirectory` for Kubernetes-native segment management. • Adds Python 3.11 support. Breaking changes: • Python 3.7 support is removed; the minimum supported version is now higher.

Chroma 0.4.14

Mon, 09 Oct 2023 22:21:23 GMT

Chroma 0.4.14 adds gRPC segments, a distributed segment manager, and new Terraform deployment blueprints for AWS, Render, and DigitalOcean. • Adds gRPC-based segments and a distributed segment manager, enabling horizontally scaled Chroma deployments. • Adds a Render.com Terraform blueprint for one-click cloud deployment of Chroma. • Adds an improved AWS Terraform blueprint for deploying Chroma on AWS infrastructure. • Adds a DigitalOcean Terraform deployment blueprint for Chroma.

Chroma 0.4.13

Mon, 25 Sep 2023 17:58:47 GMT

Chroma 0.4.13 adds $in/$nin metadata filters, Pulsar messaging support, and exports IncludeEnum for query/get calls. • Adds `$in` and `$nin` operators to metadata filters, enabling set-membership queries on collection metadata in `#get` and `#query` calls. • Exports `IncludeEnum` from the client library, which is required when specifying include parameters for `#get` and `#query`. • Adds Apache Pulsar producer and consumer support as a messaging backend.

Chroma 0.4.10

Mon, 11 Sep 2023 20:01:03 GMT

Chroma 0.4.10 adds auth and external volume support for GCP deployments. • Adds authentication and external volume support for GCP deployments. • Publishes official Docker images to DockerHub at `chromadb/chroma:0.4.10` in addition to the existing GitHub Container Registry image.

Chroma 0.4.9

Wed, 06 Sep 2023 05:41:26 GMT

Chroma 0.4.9 adds collection filtering, `$in`/`$nin` metadata operators, JS auth, and AWS deployment support. • Adds `$in` and `$nin` metadata filter operators (CIP-4) so queries can match documents where a field's value is in or not in a given list. • Adds collection-level filtering (CIP-1), allowing clients to filter the list of collections returned. • Adds authentication support to the JavaScript client, bringing JS client auth parity with the Python client. • Adds ONNX runtime session providers, enabling hardware-accelerated inference backends for embedding functions. • Adds AWS deployment support for self-hosting Chroma on AWS infrastructure. • Improves `HttpClient` URL handling to accept a broader range of URL formats. • Publishes multi-platform Docker release builds (e.g. `ghcr.io/chroma-core/chroma:0.4.9`), supporting multiple CPU architectures. Breaking changes: • The JavaScript client upgrades to OpenAI npm package v4, which contains breaking changes — existing JS code using the OpenAI embedding function may require updates.

Chroma 0.4.8

Tue, 29 Aug 2023 06:16:23 GMT

Chroma 0.4.8 adds a Static API Token auth provider for securing hosted instances. • Adds Static API Token authentication provider, enabling token-based access control for Chroma server deployments.

Chroma 0.4.7

Wed, 23 Aug 2023 23:46:31 GMT

Chroma 0.4.7 adds auth provider support, batch size warnings, and delete safeguards. • Introduces CIP-2 Auth Providers, adding pluggable authentication provider support to the Chroma server. • Adds a warning when the number of embeddings in a single operation exceeds the maximum batch size. • Adds conditional exports support in the JavaScript client for improved module compatibility.

Chroma 0.4.6

Tue, 15 Aug 2023 05:49:35 GMT

Chroma 0.4.6 adds top-level type imports, SQLite FTS indexing, and batched embedding writes for faster vector operations. • Chroma types are now available as top-level imports, removing the need to import from deep submodules. • Adds SQLite full-text-search (FTS) index support, enabling the index to correctly leverage FTS for metadata filtering. • Batches SQLite embeddings queue writes, improving write throughput for local persistence. • Improves performance of the duplicate ID validator, reducing overhead on large upsert operations. Breaking changes: • The JavaScript client API removes `increment_index`, `createIndex`, and `rawSql` — any JS code calling these methods will break on upgrade.

Chroma 0.4.4

Tue, 01 Aug 2023 01:24:02 GMT

Chroma 0.4.4 adds boolean metadata filtering and an `api_version` param for Azure OpenAI embeddings. • Adds `api_version` parameter to the Azure OpenAI embedding function, enabling version-pinned calls to the Azure OpenAI API. • Supports metadata filtering on boolean values in queries, extending the existing `where` filter to handle boolean fields. • Adds PEP-561 compliance via a `py.typed` marker file, enabling downstream type checkers to use Chroma's inline type annotations. • Adds LRU cache for file-descriptor management, improving performance under high collection counts. Breaking changes: • `raw_sql` and `pandas` support have been removed from the library. • `create_index` has been removed. • The `increment_index` method has been removed.

Chroma 0.4.0

Mon, 17 Jul 2023 23:31:50 GMT

Chroma 0.4.0 adds custom header and direct URL support for the HTTP client, plus a new SQLite backend. • Adds custom HTTP header and direct URL support when connecting to a Chroma server, enabling authenticated and proxy-friendly client configurations. • Introduces a SQLite-backed storage engine as a new persistence option.