Chroma

An open-source vector database for AI apps that runs inside a Python or JavaScript process, as a single server, or as a distributed service on object storage.

What it is: Vector databases
Type: Open source
Made by: Chroma
License: Apache 2.0; Chroma Cloud is a paid hosted service
Facts checked: 9 October 2026

What it is

Chroma stores collections of records, each with an id, an embedding, optional metadata and a document. You can pass your own embeddings or let a collection embed text for you: the default embedding function runs the all-MiniLM-L6-v2 sentence-transformers model locally. A query returns the nearest records by squared L2 distance (the default), cosine or inner product, and can filter on metadata (where) and on document text (where_document), including full-text and regex search. Collections sit in databases, and databases in tenants.

The same API runs in three shapes. As a library, chromadb.PersistentClient keeps data in SQLite and index files in a local folder; chroma run starts a single server for workloads Chroma puts at typically fewer than 10 million records. Both use an HNSW index. Distributed Chroma, which Chroma Cloud runs on AWS and GCP, splits the work into a gateway, a write-ahead log, query executors and compactors: writes are acknowledged once the log persists them, compactors build new index versions in the background, and the log and indexes live in object storage with local SSDs as caches. There the vector index is SPANN, which clusters vectors and searches only the nearest clusters, combined with SPFresh for updates. Version 1.0 in March 2025 rewrote much of Chroma in Rust.

Why teams pick it

Starts with pip install chromadb and no server: the in-process client is a handful of calls (create a collection, add, query), and the same code later talks to a server or Chroma Cloud
Embeds documents for you if you want, with a local default model or integrations for hosted embedding APIs
Vector, full-text, regex and metadata filtering in one query, plus sparse vectors (BM25, SPLADE) for hybrid search in Chroma Cloud
Chroma Cloud bills usage, not instances: $2.50 per GiB written, $0.33 per GiB-month stored, and reads at $0.0075 per TiB queried plus $0.09 per GiB returned, with $5 of free credits (checked October 9, 2026)
Apache 2.0, with no product telemetry since version 1.5.4

Watch out for

Single-node Chroma is one machine, which Chroma sizes for typically fewer than 10 million records across a handful of collections; scaling out means Chroma Cloud or its bring-your-own-cloud option
Chroma Cloud caps collections at 5 million records, 4,096 embedding dimensions, 300 results per query and 300 records per write by default; most quotas can be raised on request
Cold collections in Chroma Cloud are loaded from object storage, so the first query is slower; Chroma suggests sending a warm-up query
SPANN settings in distributed Chroma can’t be tuned, and since 1.0 Chroma ships no built-in authentication, so a self-hosted server needs its own auth in front

Alternatives

What all vector databases have in common →

PineconeCommercialA managed, serverless vector database that keeps its indexes in object storage and serves dense-vector, sparse-vector and BM25 full-text search from the same index.

VectorizeCommercialCloudflare’s serverless vector database for Workers, which stores embeddings in R2-backed indexes and bills only for vector dimensions stored and queried.

How it fits with other technologies

What Chroma uses

A persistent local collection with cosine distance and a metadata filter · python

import chromadb

client = chromadb.PersistentClient(path="./chroma-data")  # SQLite + index files on disk
docs = client.get_or_create_collection(
    "docs", configuration={"hnsw": {"space": "cosine"}}
)

# Your embedding model makes these; 3 dimensions keep the example short.
docs.add(
    ids=["refund", "shipping", "returns"],
    embeddings=[[0.9, 0.1, 0.0], [0.1, 0.9, 0.1], [0.8, 0.2, 0.1]],
    documents=["Refunds take 5 days", "We ship in 2 days", "Return within 30 days"],
    metadatas=[{"lang": "en"}, {"lang": "en"}, {"lang": "de"}],
)

hits = docs.query(
    query_embeddings=[[0.85, 0.15, 0.05]],  # "how do I get my money back?"
    n_results=2,
    where={"lang": "en"},  # metadata filter
)
print(hits["ids"][0])  # ['refund', 'shipping']
print([round(d, 3) for d in hits["distances"][0]])  # [0.004, 0.714]

Three ways to run Chroma#

The client API is the same in all three; what changes is where data lives and which vector index answers queries.

	Local (in-process)	Single node	Distributed and Chroma Cloud
Start it with	`chromadb.PersistentClient(path=...)`	`chroma run --path ...` or Docker	Chroma Cloud, or single-tenant in your own VPC (BYOC)
Vector index	HNSW	HNSW	SPANN with SPFresh
Storage	SQLite and index files in a folder	SQLite and index files on the server’s disk	Write-ahead log and indexes in object storage, SSD caches
Sized for	Prototypes and notebooks	Typically fewer than 10 million records	Large workloads and millions of collections
Index tuning	`space`, `ef_construction`, `ef_search`, `max_neighbors`	Same as local	`space` only; other SPANN settings are ignored

See it in a real stack

No architecture uses Chroma yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2022–2026

Chroma was started by Jeff Huber, previously a co-founder of the computer vision company Standard Cyborg, and Anton Troynikov; its repository opened in October 2022 and the first packages reached PyPI in February 2023. The pitch was the gap many developers described as “ChatGPT but for my data”: Chroma would be the “for my data” bridge, storing embeddings of a team’s documents so a language model could retrieve the relevant ones. In April 2023 the company raised an $18 million seed round led by Quiet Capital.

Version 1.0, released in March 2025, rewrote much of Chroma in Rust. In August 2025 Chroma launched Chroma Cloud, a distributed version built on object storage with a SPANN-based index, its own object-storage write-ahead log (wal3), and collection forking. In March 2026, version 1.5.4 stopped collecting product telemetry.

Why it’s built this way

Embedded first, server later: The README’s first example runs in memory “for easy prototyping”, and Chroma keeps one API across local, single-node and distributed deployments, so a prototype can become a service without a rewrite.
Lean on SQLite and object storage: Chroma says it delegates to “durable, well-understood subsystems such as SQLite and cloud object storage” so its own code can focus on retrieval.
Separate the log from index building: In distributed Chroma a write is acknowledged as soon as the write-ahead log persists it. Compactors build new vector, full-text and metadata index versions later, and queries consult the log to stay consistent.
Clustered index for the cloud: SPANN splits vectors into broad clusters and builds small indexes inside each, which, in Chroma’s words, makes it practical to search billions of vectors stored on hard drives or separate machines.

Timeline

2022
chroma-core/chroma repository created in October
2023
First PyPI releases in February; $18M seed led by Quiet Capital in April
2025
Chroma 1.0 in March rewrites much of the system in Rust
2025
Chroma Cloud launches in August with a distributed SPANN index
2026
Version 1.5.4 drops product telemetry in March

Sources14 · facts checked 9 October 2026

Improve this page on GitHub