Chroma

By Chroma

Open-source embedding database for RAG — store vectors and query by similarity in a few lines.

Website ↗ Repository ↗ Docs ↗

v1.5.92026-05-05PythonApache-2.0

#vector-db #embeddings #rag #python

28.9k Open source Free tier Paid

Doc version 1.0 · Updated June 28, 2026

Related tools

Sentence Transformers

Embedding Models

pgvector

Vector Databases

Overview

Chroma is an open-source embedding database: add documents and it stores their vectors, then answers similarity queries — the retrieval layer for RAG and agent memory.
It runs in-process (in-memory or on disk) with no separate server to operate, and offers a managed cloud when you need to scale.

flowchart LR
  docs[documents] --> col[(Chroma collection)]
  q[query text] --> col
  col --> top[nearest docs]

The Code samples tab shows the built-in embedder and a bring-your-own embedding function — pick from the selector to compare.

When to use it

Choose Chroma when you want a lightweight, embedded vector store you can start with in one line — and bring your own embedding model when you outgrow the default.

Pricing

Open source (Apache-2.0), free to self-host. Chroma Cloud is usage-based.

Plan	Price	Notes
Free	$0	1M embeddings, $5 credits
Cloud (usage)	Usage-based	Pay for storage and queries.

Source ↗ · as of 2026-06-27

Example

Python · add & query

When to use

Reach for Chroma when you want a dead-simple local vector store for RAG.

How it flows

add embeds and stores documents (with a built-in embedder by default); query embeds the query and returns nearest neighbours.

Structure

flowchart LR
  docs[documents] --> col[(Chroma collection)]
  q[query text] --> col
  col --> top[nearest docs]

import chromadb

client = chromadb.Client()  # in-memory; use PersistentClient to save to disk
collection = client.create_collection("memories")

# Chroma embeds the documents with a built-in model by default.
collection.add(
    ids=["1", "2", "3"],
    documents=["cats are great pets", "the market fell", "kittens love to play"],
)

res = collection.query(query_texts=["tell me about cats"], n_results=1)
print(res["documents"][0])  # -> a cat-related document

When to use

Plug in your own embedding function (e.g. sentence-transformers) when you want control over the model.

How it flows

Chroma calls the embedding function on add and query; PersistentClient keeps the vectors on disk.

Structure

flowchart LR
  ef[embedding fn] --> col[(Chroma)]
  docs[documents] --> col
  q[query] --> col
  col --> top[nearest docs]

import chromadb
from chromadb.utils import embedding_functions

# Use any embedding model — here a local sentence-transformers model.
ef = embedding_functions.SentenceTransformerEmbeddingFunction("BAAI/bge-m3")

client = chromadb.PersistentClient(path="./chroma")  # persists to disk
col = client.get_or_create_collection("memories", embedding_function=ef)

col.add(ids=["1"], documents=["how do I reset my password?"])
print(col.query(query_texts=["password help"], n_results=1)["documents"])

Example

Chroma — vector similarity search (no server, no key)

A real, runnable mini-project. Download it and run with Docker.

View samples/chroma_1 on GitHub ↗

June 28, 2026

Chroma — vector similarity search (no server, no key)

A tiny Chroma demo: it stores a few documents — Chroma embeds them with a built-in model — then runs a nearest-neighbour query. Swap the toy docs for your own and it is a RAG retriever. No API key.

Run with Docker

cd samples/chroma_1
docker build -t aas-chroma .
docker run --rm aas-chroma "tell me about young cats"

The first query downloads Chroma's built-in embedding model (all-MiniLM-L6-v2, ~80 MB), so the run needs internet once.

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the attached docker run may print nothing even though it ran — the live attached stream drops output over the VM boundary. Run detached and read the logs:

cd samples/chroma_1
docker build -t aas-chroma .
docker logs -f "$(docker run -d aas-chroma "tell me about young cats")"

Run locally

cd samples/chroma_1
pip install -r requirements.txt
python app.py "tell me about young cats"

Example run

Embeddings are deterministic (fixed model + input), so the ranking is the same every run — only the first run downloads the model.

nearest to 'tell me about young cats' by distance:
  kitten     0.8413
  cat        1.0233
  rocket     1.8533

Files

app.py

"""Chroma: vector similarity search with no server and no API key.

Stores a few documents in an in-memory Chroma collection (Chroma embeds them
with a built-in model), then runs a nearest-neighbour query. Swap the toy docs
for your own and it is a RAG retriever.

Run:
    docker build -t aas-chroma .
    docker run --rm aas-chroma "tell me about young cats"
"""

import sys

import chromadb

DOCS = {
    "cat": "Cats are independent pets that purr and chase laser pointers.",
    "kitten": "A kitten is a young cat that loves to play and nap.",
    "airplane": "An airplane is a powered flying vehicle with fixed wings.",
    "rocket": "A rocket is propelled by ejecting exhaust gas at high speed.",
}


def main() -> None:
    query = " ".join(sys.argv[1:]) or "tell me about young cats"

    client = chromadb.Client()  # in-memory; built-in embedding model
    col = client.create_collection("docs")
    col.add(ids=list(DOCS), documents=list(DOCS.values()))

    res = col.query(query_texts=[query], n_results=3)

    print(f"nearest to {query!r} by distance:")
    for label, dist in zip(res["ids"][0], res["distances"][0]):
        print(f"  {label:10s} {dist:.4f}")


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the Chroma sample. No API key — Chroma runs in-process and
# downloads its built-in embedding model on first query.
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

ENTRYPOINT ["python", "app.py"]