◆ VECTOR DB RAG

Chroma

1.0.0 open-source

Search infrastructure for AI

source ↗ website ↗ rss ↗ last repo push Aug 19, 2026

export CHROMA_EMBED_URL=https://my-embed-service.internal/v1/embed
import chromadb

with chromadb.HttpClient(host='localhost', port=8000) as client:
    col = client.get_or_create_collection('my_collection')
    results = col.query(query_texts=['threat actor TTPs'], n_results=5)
    print(results)
import { OpenAIEmbeddingFunction } from 'chromadb';

const embedder = new OpenAIEmbeddingFunction({
  openai_api_key: process.env.OPENAI_API_KEY,
  openai_model: 'text-embedding-3-small',
  base_url: 'https://my-openai-proxy.example.com/v1'
});
const collection = await client.getCollectionByCrn('<crn>');
collection.detach()
from chromadb.api import Schema, SearchType
let client = ChromaHttpClient::new(ChromaClientOptions::chroma_cloud(
    "my-tenant-id",
    "my-api-key",
));
let col = client.get_collection("threat-embeddings").await?;
client.delete_collection("threat-embeddings").await?;
results = collection.query(
    query_texts=["network intrusion"],
    where={"id": {"$in": ["doc-001", "doc-042", "doc-099"]}},
    n_results=5
)
export CHROMA_API_KEY=your-api-key
export CHROMA_TENANT=your-tenant
export CHROMA_DATABASE=your-database
python -c "import chromadb; client = chromadb.CloudClient(); print(client.list_collections())"
const collection = await client.getCollectionById('<collection-uuid>');
results = collection.query(
    query_texts=["example query"],
    where={"source": {"$regex": "^https://.*\.pdf$"}}
)
from chromadb.utils.embedding_functions import TogetherAIEmbeddingFunction

ef = TogetherAIEmbeddingFunction(api_key="<YOUR_TOGETHER_API_KEY>", model_name="togethercomputer/m2-bert-80M-8k-retrieval")
collection = client.get_or_create_collection("my_collection", embedding_function=ef)
export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://otel-collector:4318/v1/metrics
RUST_LOG=chroma=debug ./chroma-server
chroma vacuum
import chromadb
from chromadb.utils.embedding_functions import OllamaEmbeddingFunction

client = chromadb.Client()
collection = client.get_or_create_collection(
    name="my_collection",
    embedding_function=OllamaEmbeddingFunction(model_name="llama3")
)
collection.add(documents=["Hello, world!"], ids=["doc1"])
from chromadb.utils.embedding_functions import OpenCLIPEmbeddingFunction

ef = OpenCLIPEmbeddingFunction(model_name="ViT-B-32", checkpoint="laion2b_s34b_b79k", device="cuda:1")
chroma run --host 0.0.0.0 --path ./chroma-data
collection.query(
    query_texts=["my query"],
    where={"category": {"$in": ["security", "networking", "cloud"]}}
)
collection.query(
    query_texts=["security vulnerabilities"],
    where={"category": {"$in": ["cve", "advisory", "patch"]}},
    n_results=10
)
collection.query(
    query_texts=["malware behavior"],
    where={"source": {"$nin": ["unverified", "draft"]}},
    n_results=10
)

Summary

Chroma is an open-source data infrastructure for AI, with an Apache 2.0 license. It is primarily used by application developers and engineers for building Retrieval-Augmented Generation (RAG) systems, and can be run as a Python library or via a self-hosted process. Its documentation positions it alongside vector-database capabilities. Chroma is currently available for use, with the core components being actively documented via its homepage and documentation portal.

Search infrastructure for AI

What Chroma answers

What kinds of data can I include in a collection?

document text, metadata, and unique identifiers

Can I embed my own embeddings or does the system handle it?

the system automatically handles tokenization, embedding, and indexing, but you can also add your own embeddings

What specific operations can I perform on the data?

I can create, get, update, and delete collections, and query for the most similar results

How can I ensure my data is persistent across runs?

I can set up the client in-memory for prototyping, and persistence can be added easily

Can I use it across different programming environments?

Yes, there are clients available for Python and JavaScript

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

1.0.0 Aug 20, 2026 · issue 002

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
+2 moreshow less
- ›Tenant (3 endpoints) — create, read, update
- ›Authentication (1 endpoint) — read
1.5.9 May 5, 2026 · issue -106

Chroma 1.5.9 adds maxscore sparse search, sharded group-by, read-only failover, and a new Tilt fault-injection CLI.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.9 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.9
```
- ›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.
+8 moreshow less
- ›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.
1.5.8 Apr 16, 2026 · issue -125

Chroma 1.5.8 adds sharding-aware compaction, configurable RPC timeouts, pod anti-affinity in Helm, and new WAL read levels.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.8 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.8
```
- ›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.
+6 moreshow less
- ›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.
1.5.7 Apr 8, 2026 · issue -133

Chroma 1.5.7 adds getCollectionById across all SDKs, streaming S3 uploads, log sharding, and stdout-only tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.7 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.7
```
- ›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.
1.5.6 Apr 7, 2026 · issue -134

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.6 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.6
```
└──▷ TRY IT
Override the embedding endpoint at deploy time without changing application code — useful when self-hosting a custom embedding service.
```
$ export CHROMA_EMBED_URL=https://my-embed-service.internal/v1/embed
```
- ›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.
+13 moreshow less
- ›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.
1.5.5 Mar 10, 2026 · issue -161

Chroma 1.5.5 adds a GoogleGemini embedding function alias and API key warnings for JS embedding functions.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.5 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.5
```
- ›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.
1.5.3 Mar 7, 2026 · issue -164

Chroma 1.5.3 adds delete-with-limit, updated Gemini embedding functions, new compactor endpoints, and OpenTelemetry metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.3 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.3
```
- ›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.
+11 moreshow less
- ›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 ON UPGRADE
- !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.
1.5.2 Feb 27, 2026 · issue -171

Chroma 1.5.2 adds FTS opt-out in schema, a Perplexity embedding function, Client context manager support, and quantized SPANN indexing.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.2 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.2
```
└──▷ USE IT
Ensure Chroma client connections are always released, even if an exception occurs — useful in scripts and CI pipelines.
python
```
import chromadb

with chromadb.HttpClient(host='localhost', port=8000) as client:
    col = client.get_or_create_collection('my_collection')
    results = col.query(query_texts=['threat actor TTPs'], n_results=5)
    print(results)
```
- ›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.
+9 moreshow less
- ›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.
1.5.1 Feb 19, 2026 · issue -179

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.1 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.1
```
- ›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.
+5 moreshow less
- ›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.
1.5.0 Feb 9, 2026 · issue -189

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.5.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.5.0
```
- ›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.
+11 moreshow less
- ›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.
1.4.1 Jan 14, 2026 · issue -215

Chroma 1.4.1 adds indexing status visibility across Python, TypeScript, and Rust clients, plus eventual consistency in query nodes.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.4.1 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.4.1
```
- ›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.
+8 moreshow less
- ›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.
1.4.0 Dec 24, 2025 · issue -236

Chroma 1.4.0 adds group-by search, CMEK support, and a new Rust sysdb service to Python, JS, and Rust clients.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.4.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.4.0
```
└──▷ USE IT
Use a self-hosted or Azure OpenAI-compatible endpoint with the JS client embedding function by specifying a custom base URL.
javascript
```
import { OpenAIEmbeddingFunction } from 'chromadb';

const embedder = new OpenAIEmbeddingFunction({
  openai_api_key: process.env.OPENAI_API_KEY,
  openai_model: 'text-embedding-3-small',
  base_url: 'https://my-openai-proxy.example.com/v1'
});
```
- ›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.
+1 moreshow less
- ›Adds Contextual AI as a new Chroma integration.
1.3.6 Dec 10, 2025 · issue -250

Chroma 1.3.6 adds sparse vector labels, CMEK storage support, getCollectionByCrn in JS, multi-key stats filtering, and a Python statistics wrapper API.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.3.6 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.3.6
```
└──▷ USE IT
Look up a Chroma Cloud collection by its Cloud Resource Name (CRN) from the JS client.
javascript
```
const collection = await client.getCollectionByCrn('<crn>');
```
Detach an attached function directly from a collection object in the Python client.
python
```
collection.detach()
```
- ›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.
+15 moreshow less
- ›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 ON UPGRADE
- !The store_tokens parameter is renamed to include_tokens for token storage configuration in attached functions.
1.3.5 Nov 18, 2025 · issue -272

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.3.5 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.3.5
```
- ›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.
+4 moreshow less
- ›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.
1.3.3 Nov 5, 2025 · issue -285

Chroma 1.3.3 adds a BM25 sparse embedding function to the Python client.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.3.3 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.3.3
```
- ›Adds chroma_bm25 embedding function to the Python library, enabling sparse BM25-based retrieval alongside existing dense embedding functions.
1.3.2 Nov 4, 2025 · issue -286

Chroma 1.3.2 adds Qwen to the JavaScript embedding package list.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.3.2 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.3.2
```
- ›Adds Qwen to the list of supported JS embedding packages.
1.3.0 Oct 29, 2025 · issue -292

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.3.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.3.0
```
└──▷ USE IT
Import schema or search types directly from the top-level chromadb.api package instead of internal paths.
python
```
from chromadb.api import Schema, SearchType
```
- ›Exports schema and search types directly from chromadb.api, making them importable without reaching into internal modules.
- ›Adds true.into::<Where>() 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.
+3 moreshow less
- ›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.
1.2.2 Oct 26, 2025 · issue -295

Chroma 1.2.2 ships a major Rust client expansion with new collection methods, BM25 support, and a chroma_cloud() constructor.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.2 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.2.2
```
└──▷ USE IT
Connect to Chroma Cloud from Rust without manually constructing all client options.
rust
```
let client = ChromaHttpClient::new(ChromaClientOptions::chroma_cloud(
    "my-tenant-id",
    "my-api-key",
));
```
Fetch and then delete a collection by name using the new Rust client methods.
rust
```
let col = client.get_collection("threat-embeddings").await?;
client.delete_collection("threat-embeddings").await?;
```
- ›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.
+12 moreshow less
- ›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<pod> 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 ON UPGRADE
- !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.
1.1.1 Oct 5, 2025 · issue -316

Chroma 1.1.1 adds BM25 embedding function, schema types, headless CLI login, RRF support, and per-tenant BM25 override
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.1 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.1.1
```
- ›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.
+5 moreshow less
- ›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.
1.1.0 Sep 16, 2025 · issue -334

Chroma 1.1.0 adds a search API with BM25/SPLADE support, id filters in where clauses, GC control interface, and mem0 integration.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.1.0
```
└──▷ USE IT
Filter query results by specific document IDs inside a where clause, combining ID and metadata filters.
python
```
results = collection.query(
    query_texts=["network intrusion"],
    where={"id": {"$in": ["doc-001", "doc-042", "doc-099"]}},
    n_results=5
)
```
- ›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.
+5 moreshow less
- ›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.
1.0.21 Sep 11, 2025 · issue -339

Chroma 1.0.21 adds sparse vector support with a new search endpoint, AVX512-accelerated distance calculations, and HNSW index loading without disk intermediary.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.21 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.21
```
- ›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.
+9 moreshow less
- ›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.
1.0.18 Aug 18, 2025 · issue -363

Chroma 1.0.18 adds AVX-accelerated distance calculations, a garbage collection CLI, CloudClient auto-tenant, and collection-by-CRN lookup.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.18 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.18
```
- ›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.
+5 moreshow less
- ›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.
1.0.17 Aug 14, 2025 · issue -363

Chroma 1.0.17 adds an update_tenant API, AVX512 Docker support, WordPress integration, and configurable concurrent block flushes.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.17 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.17
```
- ›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.
+2 moreshow less
- ›Reduces peak memory usage of the compactor.
- ›Enables scorecarding of fork collection by collection or tenant.
1.0.16 Aug 8, 2025 · issue -363

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.16 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.16
```
- ›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.
+23 moreshow less
- ›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 ON UPGRADE
- !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.
1.0.15 Jul 2, 2025 · issue -364

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.15 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.15
```
└──▷ TRY IT
Authenticate the Python CloudClient using environment variables instead of hardcoded values — useful in CI pipelines and containerised deployments.
```
$ export CHROMA_API_KEY=your-api-key
export CHROMA_TENANT=your-tenant
export CHROMA_DATABASE=your-database
python -c "import chromadb; client = chromadb.CloudClient(); print(client.list_collections())"
```
- ›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.
+20 moreshow less
- ›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.
1.0.13 Jun 18, 2025 · issue -365

Chroma 1.0.13 ships a new JS client, GCv2 grace period, WAL3 garbage collection, and new GetCollections parameters.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.13 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.13
```
└──▷ USE IT
Fetch a specific collection directly by its ID using the new JS client method, instead of listing all collections.
javascript
```
const collection = await client.getCollectionById('<collection-uuid>');
```
- ›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.
+14 moreshow less
- ›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.
1.0.12 May 31, 2025 · issue -366

Chroma 1.0.12 adds a Mistral embedding function, per-tenant exclusions, garbage-collector hard deletes, and block prefetch by prefix.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.12 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.12
```
- ›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.
+4 moreshow less
- ›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.
1.0.10 May 22, 2025 · issue -366

Chroma 1.0.10 adds SPANN metrics, quota-exceeded error handling, log sealing in Go, and WAL3 bootstrap from existing content.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.10 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.10
```
- ›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.
+9 moreshow less
- ›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.
1.0.9 May 13, 2025 · issue -366

Chroma 1.0.9 adds $regex metadata filtering, automatic retries for writes, and lets the Python client delete metadata fields.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.9 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.9
```
└──▷ USE IT
Filter collection records whose metadata field matches a regular expression — useful for fuzzy document retrieval without exact-match constraints.
python
```
results = collection.query(
    query_texts=["example query"],
    where={"source": {"$regex": "^https://.*\.pdf$"}}
)
```
- ›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.
+6 moreshow less
- ›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 ON UPGRADE
- !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.
1.0.8 May 5, 2025 · issue -366

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.8 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.8
```
└──▷ USE IT
Use the Together AI embedding function when creating a collection.
python
```
from chromadb.utils.embedding_functions import TogetherAIEmbeddingFunction

ef = TogetherAIEmbeddingFunction(api_key="<YOUR_TOGETHER_API_KEY>", model_name="togethercomputer/m2-bert-80M-8k-retrieval")
collection = client.get_or_create_collection("my_collection", embedding_function=ef)
```
- ›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).
+6 moreshow less
- ›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).
1.0.6 Apr 22, 2025 · issue -367

Chroma 1.0.6 adds collection config support with SPANN tuning, expanded Jina embedding models, and collection lineage tracking.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.6 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.6
```
- ›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.
+3 moreshow less
- ›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.
1.0.5 Apr 16, 2025 · issue -367

Chroma 1.0.5 adds image support in Cohere embeddings, request priority in storage, query retries, and wal3 re-enablement.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.5 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.5
```
- ›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.
+7 moreshow less
- ›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 ON UPGRADE
- !The page, page_size, and sort arguments on get have been removed.
1.0.4 Apr 10, 2025 · issue -367

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.4 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.4
```
└──▷ TRY IT
Route Chroma's OpenTelemetry metrics to a custom collector endpoint without touching Chroma-specific config.
```
$ export OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://otel-collector:4318/v1/metrics
```
- ›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.
+2 moreshow less
- ›Adds graceful shutdown for the garbage collection (GC) system.
- ›Limits the maximum number of collections processed in a single GC run.
1.0.3 Apr 7, 2025 · issue -367

Chroma 1.0.3 adds metrics for garbage collection and improves sysdb S3 configuration parity.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.3 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.3
```
- ›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.
1.0.0 Apr 3, 2025 · issue -367

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 1.0.0
```
- ›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.
+16 moreshow less
- ›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.
0.6.3 Jan 14, 2025 · issue -370

Chroma 0.6.3 adds list/delete database APIs, a GC service, async rate limiting, and raises the default ef_search to 100.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.3 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.6.3
```
- ›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.
+1 moreshow less
- ›Adds concurrency and stream-processing flags to the Go binary.
0.6.2 Jan 7, 2025 · issue -370

Chroma 0.6.2 adds Voyage AI embedding integration and parallelized log materialization for faster segment writes.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.2 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.6.2
```
- ›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.
0.6.1 Jan 3, 2025 · issue -370

Chroma 0.6.1 adds MPS-accelerated OpenCLIP embeddings, HNSW integrity validation on load, and OpenTelemetry foyer metrics export.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.1 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.6.1
```
- ›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.
0.6.0 Dec 30, 2024 · issue -371

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.6.0
```
- ›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.
+10 moreshow less
- ›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.
0.5.23 Dec 5, 2024 · issue -371

Chroma 0.5.23 introduces SPANN segment/index, hybrid read workload support, and Kubernetes query replicas.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.23 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.23
```
- ›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.
+1 moreshow less
- ›Adds Kubernetes support for query replicas via Helm chart.
0.5.16 Oct 29, 2024 · issue -373

Chroma 0.5.16 adds rate limiting across all operations, tenant/database scoping for collection ops, and RUST_LOG-driven tracing configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.16 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.16
```
└──▷ TRY IT
Configure Chroma's Rust tracing verbosity at startup to observe cache and query internals.
```
$ RUST_LOG=chroma=debug ./chroma-server
```
- ›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.
+5 moreshow less
- ›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.
0.5.13 Oct 10, 2024 · issue -373

Chroma 0.5.13 brings persistent block/sparse index caches and binary search for range filter operators.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.13 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.13
```
- ›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.
0.5.12 Oct 8, 2024 · issue -373

Chroma 0.5.12 delivers 21x faster full-text queries, unified filter-operator semantics, and a new disk/memory-backed cache.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.12 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.12
```
- ›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.
+1 moreshow less
- ›Makes Chroma available in early access on hosted infrastructure.
└──▷ BREAKING ON UPGRADE
- !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.
0.5.7 Sep 20, 2024 · issue -374

Chroma 0.5.7 adds WAL pruning/vacuuming, a vacuum CLI command, Network Admission Control, multipart S3 uploads, and weighted LRU HNSW cache.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.7 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.7
```
└──▷ TRY IT
Manually vacuum the WAL to reclaim disk space after heavy write workloads.
```
$ chroma vacuum
```
- ›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.
+19 moreshow less
- ›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.
0.5.4 Jul 11, 2024 · issue -376

Chroma 0.5.4 adds configurable block size, HNSW cache reads, S3 retries, collection config storage, and faster JSON via orjson.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.4 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.4
```
- ›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.
+7 moreshow less
- ›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.
0.5.0 Apr 23, 2024 · issue -379

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.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.5.0
```
└──▷ USE IT
Run local embeddings via an Ollama model without sending data to an external API.
python
```
import chromadb
from chromadb.utils.embedding_functions import OllamaEmbeddingFunction

client = chromadb.Client()
collection = client.get_or_create_collection(
    name="my_collection",
    embedding_function=OllamaEmbeddingFunction(model_name="llama3")
)
collection.add(documents=["Hello, world!"], ids=["doc1"])
```
Target a specific GPU when using the OpenCLIP embedding function for faster throughput on multi-GPU hosts.
python
```
from chromadb.utils.embedding_functions import OpenCLIPEmbeddingFunction

ef = OpenCLIPEmbeddingFunction(model_name="ViT-B-32", checkpoint="laion2b_s34b_b79k", device="cuda:1")
```
- ›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.
+11 moreshow less
- ›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 ON UPGRADE
- !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.
0.4.24 Feb 28, 2024 · issue -381

Chroma 0.4.24 adds metadata indices, blockstore-based full-text search, and server-side log pull with gRPC error handling.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.24 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.24
```
- ›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.
0.4.23 Feb 22, 2024 · issue -381

Chroma 0.4.23 adds Amazon Bedrock embeddings, SSL client verification, FIPS compliance, CLI log path support, and a Rust-based worker backend.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.23 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.23
```
- ›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.
+8 moreshow less
- ›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.
0.4.22 Jan 3, 2024 · issue -382

Chroma 0.4.22 adds an Amazon Bedrock embedding function for generating embeddings via AWS.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.22 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.22
```
- ›Adds Amazon Bedrock embedding function, enabling Bedrock-hosted models to generate embeddings directly within Chroma.
0.4.20 Dec 15, 2023 · issue -383

Chroma 0.4.20 adds Gemini and Jina embedding integrations, CloudClient support, and collection pagination.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.20 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.20
```
- ›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.
0.4.19 Dec 13, 2023 · issue -383

Chroma 0.4.19 adds Jina AI and Hugging Face embedding functions, a $not_contains filter, cloud client, and OpenTelemetry tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.19 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.19
```
- ›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.
+8 moreshow less
- ›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.
0.4.18 Nov 21, 2023 · issue -384

Chroma 0.4.18 adds Jina AI embeddings, FastAPI tracing, OpenAI default headers, and a SHA-256 migration hashing option.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.18 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.18
```
- ›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.
0.4.17 Nov 10, 2023 · issue -384

Chroma 0.4.17 adds OpenAI v1.x support and a new system-catalog-provider for simpler deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.17 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.17
```
- ›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.
0.4.16 Nov 8, 2023 · issue -384

Chroma 0.4.16 adds authorization (authz) support and multimodal embedding functions.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.16 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.16
```
- ›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.
0.4.15 Oct 25, 2023 · issue -385

Chroma 0.4.15 adds multitenancy, OTel tracing, gRPC coordinator, and a --host flag to the CLI run command.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.15 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.15
```
└──▷ TRY IT
Bind the Chroma server to all interfaces (e.g., in a container or remote host) instead of the default localhost.
```
$ chroma run --host 0.0.0.0 --path ./chroma-data
```
- ›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.
+1 moreshow less
- ›Adds Python 3.11 support.
└──▷ BREAKING ON UPGRADE
- !Python 3.7 support is removed; the minimum supported version is now higher.
0.4.14 Oct 9, 2023 · issue -385

Chroma 0.4.14 adds gRPC segments, a distributed segment manager, and new Terraform deployment blueprints for AWS, Render, and DigitalOcean.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.14 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.14
```
- ›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.
0.4.13 Sep 25, 2023 · issue -386

Chroma 0.4.13 adds $in/$nin metadata filters, Pulsar messaging support, and exports IncludeEnum for query/get calls.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.13 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.13
```
└──▷ USE IT
Filter collection results to only documents whose metadata field matches one of several values — or explicitly excludes them.
python
```
collection.query(
    query_texts=["my query"],
    where={"category": {"$in": ["security", "networking", "cloud"]}}
)
```
- ›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.
0.4.10 Sep 11, 2023 · issue -386

Chroma 0.4.10 adds auth and external volume support for GCP deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.10 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.10
```
- ›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.
0.4.9 Sep 6, 2023 · issue -386

Chroma 0.4.9 adds collection filtering, $in/$nin metadata operators, JS auth, and AWS deployment support.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.9 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.9
```
└──▷ USE IT
Filter query results to only documents whose 'category' field matches one of several values — useful for multi-tenant or tagged collections.
python
```
collection.query(
    query_texts=["security vulnerabilities"],
    where={"category": {"$in": ["cve", "advisory", "patch"]}},
    n_results=10
)
```
Exclude documents from specific sources in a query — useful for suppressing noisy or untrusted data from results.
python
```
collection.query(
    query_texts=["malware behavior"],
    where={"source": {"$nin": ["unverified", "draft"]}},
    n_results=10
)
```
- ›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.
+2 moreshow less
- ›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 ON UPGRADE
- !The JavaScript client upgrades to OpenAI npm package v4, which contains breaking changes — existing JS code using the OpenAI embedding function may require updates.
0.4.8 Aug 29, 2023 · issue -387

Chroma 0.4.8 adds a Static API Token auth provider for securing hosted instances.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.8 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.8
```
- ›Adds Static API Token authentication provider, enabling token-based access control for Chroma server deployments.
0.4.7 Aug 23, 2023 · issue -387

Chroma 0.4.7 adds auth provider support, batch size warnings, and delete safeguards.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.7 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.7
```
- ›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.
0.4.6 Aug 15, 2023 · issue -387

Chroma 0.4.6 adds top-level type imports, SQLite FTS indexing, and batched embedding writes for faster vector operations.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.6 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.6
```
- ›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 ON UPGRADE
- !The JavaScript client API removes increment_index, createIndex, and rawSql — any JS code calling these methods will break on upgrade.
0.4.4 Aug 1, 2023 · issue -387

Chroma 0.4.4 adds boolean metadata filtering and an api_version param for Azure OpenAI embeddings.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.4 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.4
```
- ›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 ON UPGRADE
- !raw_sql and pandas support have been removed from the library.
- !create_index has been removed.
- !The increment_index method has been removed.
0.4.0 Jul 17, 2023 · issue -388

Chroma 0.4.0 adds custom header and direct URL support for the HTTP client, plus a new SQLite backend.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.0 https://github.com/chroma-core/chroma.git
# already have the repo? check out this version:
$ git checkout 0.4.0
```
- ›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.

Chroma

Summary

What Chroma answers

Examples

Command line

Release history