Geekflare
PermissiveApache-2.0Tested by Geekflare

Chroma review

Open source vector database that runs inside a Python app or as a small server

Website GitHub Docs
Data refreshedMethodologyHow we tested
Founder of Geekflare

Chandan Kumar is a founder of Geekflare. He is a technology enthusiast and entrepreneur who loves to help businesses and people around the world. Chandan has worked at BNP Paribas, Citibank, Deutsche Bank, Motorola, and HP. He’s got an in-depth understanding of business software and IT infrastructure.

Verdict

Chroma is one of the quickest ways to add vector search to a Python prototype, since a pip install gives you a local database with a default embedding model. Self-hosting means one node with the index in RAM and no login or roles, hybrid search is Cloud only, and there has been no stable release since May 2026.

Best for

Python teams building a RAG prototype or a small internal search tool

Not for

Teams that need hybrid search, access control or multi-node scale on their own servers

Pros

  • Runs inside a Python process with no separate server
  • Default embedding model runs locally, so you can start without an API key
  • Apache 2.0, and the company says the database will stay open source
  • Official Docker image and templates for AWS, GCP and Azure

Cons

  • Hybrid search and sparse vectors are only in Chroma Cloud
  • No built-in authentication since version 1.0
  • No stable release since 1.5.9 in May 2026, only dev builds
Ask Sparkian

Is Chroma right for your project?

Describe what you need and AI will check the fit against this review.

Or try:

Chroma features and capabilities

Embedded or client-server

The same API works in memory, saved to a local folder or against a Chroma server, so a notebook prototype can move to a shared server without a rewrite.

Embeddings handled for you

Chroma embeds documents with a local Sentence Transformers model by default, or calls providers such as OpenAI, Cohere or Jina AI through built-in embedding functions.

Metadata, text and regex filters

Queries can filter on metadata and on document text with contains or regex rules, so you can narrow results to one source, customer or keyword.

Tenants and databases

Collections sit inside databases and tenants, which gives you a built-in way to keep each customer's data apart.

OpenTelemetry tracing

The server can send traces to your own OpenTelemetry collector, and since 1.5.4 it no longer sends product telemetry to Chroma.

Hybrid searchCombines keyword and vector search in one query
Paid onlyChroma Cloud only; self-hosted has text and regex filters, not ranked keyword search
Built-in embeddingsTurns text into vectors for you, so you don't call an embedding API yourself
YesLocal default model plus provider integrations
QuantizationCompresses vectors to cut memory
NoNo quantization documented for self-hosted Chroma
Disk-based indexServes indexes bigger than memory from SSD
NoSingle-node HNSW index must fit in RAM
Sharding and replicationSpreads data across nodes in the free version
PartlyDistributed code is open source, but only single-node self-hosting is documented
Multi-tenancyKeeps each customer's data apart in one database
YesTenants, databases and collection per customer
Embedded modeRuns inside your app with no separate server
YesPython only; JavaScript needs a server

At a glance

Type
Vector database
Stack
Rust / Python
SSO
No
Roles and permissions
No
Audit logs
No

Free vs paid editions

What you get when you self-host, and what needs a paid plan.

The open source version is free and runs as an embedded Python library or a single-node server, with vector search, metadata filters, full-text and regex filters and built-in embeddings. Chroma Cloud runs the distributed version and adds the Search API with sparse vectors and hybrid ranking, collection forking and syncing from S3, GitHub or websites. Cloud starts at $0 a month plus usage with $5 of free credits, and the Team plan is $250 a month plus usage.

Self-hosting Chroma

Chroma's docs advise against running it with less than 2 GB of RAM, and the vector index must fit in memory, at about 245,000 1,024-dimension vectors per GB.

New cloud server to ready

9 s

Memory in use at idle

10 MB of 4 GB

Load and index 100,000 vectors

2 min 3 s, 755 MB peak

Recall@10

98.9%

Median search

5.6 ms

Slowest 5%

7.0 ms

Version tested

1.5.9 · Oct 19, 2026

  • I used 1.5.9, the last stable release from May 2026, rather than the dev builds published since. The image was ready in 9 seconds.
  • Adding 100,000 vectors in batches of 1,000 took 2 minutes 3 seconds, with the index built as it went. Memory peaked at 755 MB, the lowest of the five.
  • It found 98.9% of the true top 10, at a median of 5.6 ms per search.
  • There is no authentication in the server, so anything that can reach port 8000 can read or delete collections. I kept it on 127.0.0.1.
Code we ran
# docker run -d -p 127.0.0.1:8000:8000 -v ./data:/data chromadb/chroma:1.5.9
import chromadb

client = chromadb.HttpClient(host="127.0.0.1", port=8000)
col = client.create_collection("dbpedia", configuration={"hnsw": {"space": "cosine"}})

for lo in range(0, 100_000, 1000):          # vectors, titles: the 100,000 DBpedia rows
    col.add(ids=[str(i) for i in range(lo, lo + 1000)],
            embeddings=vectors[lo:lo + 1000],
            metadatas=[{"title": t} for t in titles[lo:lo + 1000]])

hits = col.query(query_embeddings=[query], n_results=10)
OutputPassed1.5.9 · 100,000 vectors · same top 5 as an exact search
Request: col.query(query_embeddings=[<embedding of the held-out "Apache Tomcat" article>], n_results=5, include=["metadatas", "distances"]), distances rounded
{
 "ids": [["1004", "99963", "20767", "20383", "396"]],
 "distances": [[0.1209, 0.1388, 0.1433, 0.1463, 0.1474]],
 "metadatas": [[{"title": "Apache HTTP Server"}, {"title": "Web container"}, {"title": "Java servlet"}, {"title": "JavaServer Pages"}, {"title": "Apache Software Foundation"}]]
}

What you can do with Chroma

RAG prototype

Load your docs into a local Chroma folder with the default embedding model and test retrieval before choosing production infrastructure.

Memory for AI agents

Store past conversations or notes in a Python agent's own process and recall them by meaning, with no database server to run.

Small internal search

Run the Docker image on one server for a team knowledge base or support search with metadata filters per source.

Chroma alternatives

QdrantVector database written in Rust, with payload filtering, hybrid search and quantizationMilvusDistributed vector database that runs from a single container up to a Kubernetes clusterpgvectorPostgres extension that adds vector types and nearest neighbour search to your existing databaseWeaviateVector database that stores objects and vectors, with built-in vectorizer modules and hybrid searchLanceDBEmbedded vector database on the Lance columnar format, with vector, full-text and hybrid searchOpenSearchDistributed search engine with k-NN vector search, hybrid queries and a free security plugin