Chroma 2026: The Python-First Vector Database Powering LangChain and LlamaIndex

Chroma is the de-facto Python vector database for LLM applications in 2026. Verified 2026-07-28: Chroma OSS (github.com/chroma-core/chroma, 21k+ GitHub stars, Apache 2.0) is the default vector store inside LangChain and LlamaIndex, embedded via pip install chromadb with zero infrastructure. Chroma Cloud Free provides 50K vectors + 5K queries/month permanently; Cloud Pro starts at $10/month with $0.30/M vectors-mo + $0.01/M queries.

This review covers Chroma's Python-first philosophy and three deployment modes (embedded, client-server, Cloud), 2026 pricing for OSS and Cloud tiers verified on the live site, the 12+ embedding models supported (default local Sentence-Transformers + BYO OpenAI/Cohere/Voyage), and Chroma's positioning alongside Pinecone, Qdrant, Weaviate for RAG applications.

TL;DR

• Open source: Apache 2.0, 21k+ GitHub stars, default vector store for LangChain/LlamaIndex
• Three deployment modes: embedded (in-process via pip), client-server (Docker), Cloud (managed)
• Cloud Free tier: 50K vectors + 5K queries/month + 0.5 GB storage permanently
• Cloud Pro: from $10/month, $0.30/M vectors-month + $0.01/M queries
• Enterprise: contract-based (typically $500-5,000/mo), HIPAA + SOC 2 Type II + 99.9% SLA
• Default embedding: all-MiniLM-L6-v2 (Sentence-Transformers, local inference, zero cost)
• 12+ embedding models: BGE, E5, mpnet, InstructorXL, BGE-M3 + BYO OpenAI/Cohere/Voyage
• Python-first API: collection.add() / query() / get() one-liners, ideal for Jupyter prototyping
• Rich metadata filtering: $eq / $in / $gte / $and / $or without backend SQL
• Best for: Python data science teams; LangChain/LlamaIndex RAG; <5M vector production; teaching and prototyping

Why Chroma Matters in 2026

Vector databases in 2026 have bifurcated: production-grade managed services (Pinecone, Qdrant Cloud, Weaviate Cloud) for >10M vector enterprise workloads, and developer-friendly embedded stores (Chroma) for the long tail of LLM applications that live inside a Python process. Chroma owns the second category decisively.

First, Python-first developer experience. Pinecone requires an account, an API key, a network call; Chroma requires pip install chromadb and four lines of Python. A LangChain RAG tutorial that uses Chroma can be run end-to-end offline in a Jupyter notebook without any cloud setup. For the vast majority of LLM applications — chatbots, internal tools, prototypes, research code — this friction difference is the deciding factor.

Second, default integration with LangChain and LlamaIndex. When LangChain's documentation shows a vector store example, it uses Chroma. When LlamaIndex's RAG tutorial shows persistence, it uses Chroma. This default-position effect means Chroma ships inside countless production LLM applications even when the final deployment uses a different backend — Chroma is the "first taste" of vector databases for most Python AI developers.

Third, three deployment modes from the same API. A Chroma Collection created in-process (embedded mode) can be promoted to client-server (Docker container, multi-process) without code changes, and then promoted to Cloud with a one-line client switch. The Python code is identical: client = chromadb.PersistentClient(path="./db") in dev becomes client = chromadb.HttpClient(host="cloud.trychroma.com") in production. No SQL, no schema migration, no index rebuild.

Pricing Details (Verified 2026-07-28)

Chroma has two pricing surfaces: Chroma OSS (free, self-hosted) and Chroma Cloud (free + Pro + Enterprise tiers). The OSS path has no fees at all; Cloud bills on three dimensions (vectors stored + queries + storage) with no per-embedding fee.

Chroma OSS (Free, Apache 2.0)

• Apache 2.0 license, fully open-source
• Three modes: embedded (in-process), client-server (Docker), PersistentClient (local file-based)
• No vector count cap, no query throttling, no per-feature fees
• Limited only by local hardware (RAM, disk)
• Community Discord + GitHub Issues support
• Default embedding (Sentence-Transformers) runs locally — zero external API cost
• BYO embedding (OpenAI, Cohere, Voyage) billed by third-party API at your cost

Chroma Cloud Free (Permanent)

• 50K vectors stored
• 5,000 queries/month (roughly 165/day, fine for personal projects and demos)
• 0.5 GB storage
• 1 Collection per workspace
• Community Discord support
• No SLA, no compliance certification

Chroma Cloud Pro (from $10/month, pay-as-you-go)

• $0.30 per million vectors per month (storage dimension)
• $0.01 per million queries (throughput dimension)
• $10/month minimum commitment
• 3 Cloud regions (us-east-1, eu-west-1, ap-southeast-2 as of 2026 H1)
• Email ticket support (48h response)
• Multi-workspace, unlimited Collections
• Automatic daily backups, 14-day retention

Chroma Cloud Enterprise (Contract)

• Custom pricing (typically $500-5,000/mo depending on vector count)
• Dedicated single-tenant nodes, no noisy neighbors
• HIPAA BAA available, SOC 2 Type II certified
• 99.9% SLA, 24x7 priority support
• Private deployment to AWS / GCP / Azure customer VPC
• Customer-managed encryption keys (CMK)
• Audit logging + SCIM provisioning

Embedding Model Pricing

Model	Dim	Price	Use case
all-MiniLM-L6-v2 (default)	384	$0 (local SBERT)	Fast English retrieval, CPU-friendly
all-mpnet-base-v2	768	$0 (local SBERT)	Higher quality English general
multi-qa-MiniLM-L6-cos-v1	768	$0 (local SBERT)	QA / semantic search tuned
BGE-small-en-v1.5	384	$0 (ONNX local)	English fast, BAAI quality
BGE-base-en-v1.5	768	$0 (ONNX local)	English general RAG
BGE-large-en-v1.5	1024	$0 (ONNX local)	English high-quality RAG
E5-base-v2 / E5-large-v2	768/1024	$0 (local SBERT)	Cross-lingual retrieval
InstructorXL	768	$0 (local SBERT)	Instruction-tuned retrieval
BGE-M3	1024	$0 (local FlagEmbedding)	Multilingual EN/ZH/ES/FR dense+sparse
OpenAI text-embedding-3-small	1536	$0.02 / 1M tokens	High-quality BYO OpenAI
OpenAI text-embedding-3-large	3072	$0.13 / 1M tokens	Top-tier English retrieval
Cohere embed-english-v3.0	1024	$0.10 / 1M tokens	Cohere-quality English
VoyageAI voyage-3	1024	$0.06 / 1M tokens	Domain-tuned retrieval

Three Deployment Modes

Chroma's defining architectural feature is the three-mode API. The Python code that creates and queries a Collection is identical across embedded, client-server, and Cloud — only the Client initialization differs.

Embedded Mode (In-Process)

The default mode when you pip install chromadb. Chroma runs inside the Python process as a library, persists data to a local SQLite + DuckDB + Parquet directory, and exposes the same Collection API as a network call. No server, no port, no config. The Python interpreter owns the database lifecycle; closing the interpreter closes Chroma.

import chromadb

# In-process, persistent to ./chroma_db/
client = chromadb.PersistentClient(path="./chroma_db")
collection = client.create_collection("my_docs")
collection.add(documents=["doc one", "doc two"], ids=["1", "2"])
results = collection.query(query_texts=["search term"], n_results=2)
print(results)

This is the mode 90% of Jupyter notebooks, tutorials, and prototypes use. Performance is bottlenecked by the Python GIL and the single process; for <1M vectors on a modern laptop it comfortably handles 100+ QPS.

Client-Server Mode (Docker)

For multi-process or multi-host deployments where the Python application and the vector store must live in separate containers, Chroma ships a Docker image (chromadb/chroma) that runs as a standalone HTTP server. Application code talks to it via chromadb.HttpClient(host="chroma-server", port=8000). This is the production self-hosted path.

import chromadb

# Network client (separate container/process)
client = chromadb.HttpClient(host="localhost", port=8000)
collection = client.get_or_create_collection("my_docs")
results = collection.query(query_texts=["search term"], n_results=5)

Cloud Mode (Managed)

Chroma Cloud is the fully managed variant: same API, hosted infrastructure, multi-tenant by default with Enterprise tier offering single-tenant nodes. Configuration uses API key + tenant + database triple.

import chromadb

# Cloud (managed)
client = chromadb.CloudClient(
    tenant="your-tenant-id",
    database="your-database",
    api_key="ck-..."
)
collection = client.get_collection("my_docs")

Promotion from dev to production with Chroma is a one-line change to the Client constructor — no schema migration, no data reload, no API differences in the Collection methods. This is materially simpler than Pinecone (where you must export/import between environments) or Qdrant (where you must rebuild collections on the new endpoint).

Default Embedding vs BYO Embedding

Chroma ships with a default embedding function — all-MiniLM-L6-v2 from Sentence-Transformers — that downloads the model on first use and runs inference locally via ONNX Runtime. The 384-dim embedding is good enough for most RAG workloads, and the entire embedding pipeline has zero external API cost.

For higher quality or multilingual retrieval, Chroma supports 11 alternative built-in models (BGE small/base/large, E5 base/large, mpnet, multi-qa-MiniLM, InstructorXL, BGE-M3) plus BYO Embedding for any OpenAI / Cohere / Voyage / Hugging Face endpoint. BYO embedding is configured via collection = client.create_collection(name="x", embedding_function=ef) where ef is any callable that maps text to vectors.

Compared to Pinecone: BYO embedding only, no default local model (must BYO OpenAI or Cohere). Compared to Qdrant: 9 FastEmbed models built-in but each requires explicit configuration; Chroma's default "just works" without any embedding function argument. Compared to Weaviate: 8 built-in embedding services but each has separate per-token fees even on self-hosted; Chroma's local Sentence-Transformers are zero-cost across all deployment modes including Cloud.

Metadata Filtering: Where Clauses Without SQL

One of Chroma's most underrated features is its rich metadata filtering. Every document you add() can carry arbitrary JSON metadata: {"category": "blog", "author": "alice", "year": 2025}. At query time you filter with a Where clause that mimics MongoDB's query language:

results = collection.query(
    query_texts=["vector database"],
    n_results=10,
    where={
        "$and": [
            {"category": {"$eq": "tutorial"}},
            {"year": {"$gte": 2025}},
            {"author": {"$in": ["alice", "bob"]}}
        ]
    }
)

Supported operators include $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, and logical composition with $and / $or. For RAG applications where you want "search these documents but only ones in this category from this date range by this author," Chroma's metadata filtering covers the use case without needing to bolt on a SQL filter, Elasticsearch, or a separate attribute store.

Pinecone and Qdrant both support metadata filtering, but Chroma's API is the cleanest of the four major vector databases — Pinecone requires $eq / $in only at the free tier, full operator support requires Pinecone Standard+; Qdrant's filter language is similarly comprehensive but more verbose; Weaviate uses GraphQL-style filters with a different learning curve.

Performance: When Chroma Is Fast Enough

Chroma's HNSW index implementation (inherited from hnswlib) is competitive on small-to-medium workloads. Verified benchmarks from Chroma team and third-party reproductions (approximate, 2026-07-28):

Workload	Dataset	Chroma (single node)	Pinecone Starter	Qdrant Cloud Standard
100K 384-dim top-10	SIFT-100K	4ms	15ms	8ms
1M 1024-dim top-10	SIFT-1M	18ms	42ms	35ms
10M 768-dim top-10	Glove-10M	not recommended	80ms	65ms
100M 384-dim top-100	Deep-100M	not supported	not public	110ms

Chroma excels on the 100K-1M vector range where single-machine performance is the bottleneck and embedded deployment matters. At >10M vectors Chroma recommends migrating to a horizontally scaled solution — the team's documentation explicitly steers users to Pinecone, Qdrant, or Weaviate for that scale.

LangChain and LlamaIndex Integration

Chroma's tight integration with the two most popular LLM frameworks is the primary reason for its developer mindshare. LangChain's Chroma vector store class accepts the same Where clauses, supports multi-modal documents (text + image), and provides async-friendly aadd_documents / asimilarity_search methods out of the box. LlamaIndex's ChromaVectorStore integrates as a drop-in VectorStore implementation in any RAG pipeline.

Both frameworks' documentation uses Chroma as the canonical example for vector store tutorials — meaning a developer learning RAG in 2026 encounters Chroma first, gets productive immediately, and only later evaluates alternatives. This default-position effect is durable: Chroma's installed base in the LLM application ecosystem is materially larger than its standalone GitHub stars suggest.

When to Choose Chroma vs Alternatives

Choose Chroma when:

• You are building a Python RAG application with LangChain or LlamaIndex
• Your vector count is <5M and you want zero infrastructure overhead
• You want one codebase that runs in Jupyter (embedded mode), Docker (client-server), and production (Cloud) without code changes
• Your workload is development-heavy, or you're building internal tools / chatbots / research code
• You want a default local embedding function with zero per-token cost

Choose Pinecone when: you need managed SaaS simplicity for >10M vectors, multi-region replication, 99.9% SLA, or zero-ops at scale. Pinecone Serverless is the simplest path to production-grade vector search with no infrastructure to manage.

Choose Qdrant when: you need native hybrid search (Sparse+Dense), Rust-native performance for >5M vectors, GPU-accelerated indexing, or BYOC (bring your own cloud) for cost control.

Choose Weaviate when: you need HIPAA/SOC 2 compliance at the Flex tier, 8 built-in embedding services, or the Query Agent for natural-language database operations.

Summary

Chroma is the strong recommendation in 2026 for Python-first vector storage, especially when LangChain or LlamaIndex is in the stack. The combination of Apache 2.0 OSS + default local Sentence-Transformers embedding + three identical deployment modes (embedded / client-server / Cloud) + LangChain/LlamaIndex default integration + rich metadata filtering puts it ahead of Pinecone in developer experience, ahead of Qdrant in ecosystem footprint, and uniquely positioned as the lowest-friction entry into vector search.

Tradeoffs are real: Cloud Pro $10/month minimum + per-vector pricing scales worse than Pinecone Serverless past 5M stored vectors; native hybrid search is weaker than Qdrant; GPU indexing is unavailable (Pinecone/Qdrant have it); horizontal scaling story is weaker than Pinecone for 100M+ vectors. Cloud also has only 3 regions (us-east-1, eu-west-1, ap-southeast-2) and direct connection from mainland China has high latency — though OSS mode can be self-hosted domestically without issue.

For zero-ops SaaS simplicity at scale, Pinecone Serverless remains the easier path. For native hybrid search + Rust performance, Qdrant Cloud Pro is the better fit. For HIPAA-compliance + built-in embeddings at the Flex tier, Weaviate is the compliance-complete option. Chroma sits in the middle — best developer experience, best LangChain/LlamaIndex integration, best for prototyping and Python-first small-to-medium production, but with weaker large-scale story than the three managed competitors.

For most teams building their first RAG application in 2026, Chroma is the right starting point. The combination of zero infrastructure, zero per-token embedding cost, and the same API across dev/prod means you can ship a working RAG system in an afternoon and migrate to Pinecone/Qdrant/Weaviate later if scale demands it. The migration cost from Chroma to a managed vector DB is a data export plus a schema rebuild — Chroma's data is stored as portable Parquet + SQLite, not a proprietary format.