Analytics cookies only (Google Analytics, PostHog). No ad networks, no cross-site tracking. See our privacy policy.
upstream: github.com/chroma-core/chroma (opens in new tab) · github.com/qdrant/qdrant (opens in new tab)
Pick Chroma
If you are prototyping a small RAG app in Python or TypeScript, want a default embedding model handled for you, and the collection will fit in RAM on one node.
Pick Qdrant
If you already compute embeddings and want payload filters, quantization from 4x to 64x, a dashboard, an API key and a route to several nodes later.
Chroma and Qdrant are both Apache-2.0 vector databases that run as a single
server on a VPS, store embeddings next to metadata and return nearest
neighbours over HTTP. They suit different starting points. Chroma began as the
library you pip install in a notebook and grew a server, so it leans toward
getting a prototype working: it can embed text for you with a default model.
Qdrant is a search engine you deploy and secure, with a dashboard, payload
filters, quantization and a path to clustering. For the bigger systems around
this pair, see Milvus vs Qdrant and
Qdrant vs Weaviate.
Chroma calls itself "the open-source data infrastructure for AI". It stores documents and metadata with embeddings and supports dense, sparse and hybrid vector search, full-text and regex search without embeddings, metadata filtering and multi-modal retrieval. Clients exist for Python, JavaScript and TypeScript, with Rust in the docs. Python can run it in-process (an ephemeral or persistent client); the JS/TS client must connect to a server.
Qdrant's README calls it "a vector similarity search engine and vector database". Its pitch is filtering on a JSON payload, hybrid search that combines multiple vectors in one query, built-in quantization and distributed deployment with sharding and replication. Our install is one container with its own storage, no separate datastore.
Chroma will do it. If you do not choose an embedding function it uses
DefaultEmbeddingFunction, the Sentence Transformers all-MiniLM-L6-v2 model,
which "runs locally on your machine" in the client process, downloading model
files the first time. You can also pick API-based providers. That is
convenient for a prototype and means the server itself only stores and searches.
Qdrant's server expects vectors. Its quickstart creates a collection with a
vector size and a distance metric (the example uses dot product) and then
adds points with the vectors filled in. Its Python client can compute
embeddings locally through FastEmbed, but that is an optional extra
(qdrant-client[fastembed]) you choose a model for. If you already run an
embedding model, Qdrant asks nothing more.
Both filter on metadata at query time. Qdrant's filters combine must, should
and must_not clauses over match, range, geo and full-text conditions, and the
docs define must as "true only if every condition listed inside must is
satisfied". Chroma filters on metadata and on document contents, and adds
regex search.
Compression is Qdrant's strength. Its guide documents scalar quantization
("achieving 4x compression"), binary quantization ("for up to 32x compression")
and product quantization ("up to 64x compression"), and advises you to "Keep
the original vectors on disk and the quantized vectors in RAM". Chroma's
performance guide takes the opposite line: "The HNSW algorithm requires that
the embedding index reside in system RAM to query or update", so you provision
RAM for the collection size. For 1024-dimensional embeddings it gives N = R * 0.245, where N is the
maximum collection size in millions and R is RAM in gigabytes.
Chroma's docs call it a single-node solution: "it will not scale forever", and "If a collection grows larger than available memory, insert and query latency spike rapidly". For more they point to "a distributed deployment", which they say currently relies on a different storage subsystem from single-node, so local Chroma "may temporarily lack some features". Its docs say Chroma Cloud "simply runs the same open-source distributed system". On a VPS you run one node.
Qdrant can cluster on plain servers. Set cluster.enabled: true or
QDRANT__CLUSTER__ENABLED=true, start the first node with --uri and others with
--bootstrap. Raft keeps topology and collection structure consistent, but
enabling distributed mode "does not automatically replicate your data": you set
a replication factor when you create a collection, and the default is 1.
Peers talk on port 6335, which should stay isolated.
Neither is safe on a public port by default. Qdrant's docs say an open-source
deployment "accepts requests from anyone who can reach it" and "Connections are
unencrypted by default"; our snippet sets an API key
(QDRANT__SERVICE__API_KEY), and TLS is yours to enable. Chroma's server
reference says it "no longer ships built-in authentication
implementations". Our Chroma snippet publishes port 8000 with no
authentication and no web UI, so put it behind a firewall or an authenticating
reverse proxy. Qdrant ships a dashboard at /dashboard.
On a GCP e2-standard-2 (Ubuntu 26.04), idle at first boot with our default snippet and an empty database, Chroma used ~11 MB of RAM and ~789 MB of disk (November 2026), and Qdrant used ~17 MB of RAM and ~278 MB of disk (October 2026). These are empty-database figures, not load, and they say nothing about behaviour with millions of vectors. Chroma's guide suggests reserving "at least a gigabyte" of RAM for the system's other needs; our floors, 2 GB for Chroma and 1 GB for Qdrant, are estimates.
Both rate 2 out of 5 for difficulty: a one-service compose file and a volume. The extra work is yours: authentication, TLS, and backups.
Choose Chroma if you are building a prototype or a small RAG app in Python or TypeScript, want embeddings handled by a default model, and the collection will fit in RAM on one node.
Choose Qdrant if you already compute embeddings, want payload filters, quantization to cut memory, a dashboard, an API key, and a route to several nodes later.
Both are verified on Ubuntu 26.04; the pinned compose files are on the
Chroma and Qdrant pages. Chroma's
data lives in the chroma_data volume and Qdrant's in qdrant_storage
(a directory next to the compose file, mounted at /qdrant/storage); back
both up, and Qdrant also offers collection and full-storage snapshots, which
its docs say "can be used to archive data". Size RAM from your vector count, not from our idle figures.
Chroma for a prototype or small RAG app where a default embedding model and a quick start matter and the collection fits in RAM on one node. Qdrant when you compute your own embeddings and want filters, quantization, a dashboard, an API key and clustering later. Both idled at 11 to 17 MB of RAM in our empty-database check, which says nothing about load.
Yes, on the client side. If you do not choose an embedding function it uses DefaultEmbeddingFunction, the Sentence Transformers all-MiniLM-L6-v2 model, which its docs say "runs locally on your machine". Qdrant's server expects vectors; its Python client can compute them locally only if you install the optional FastEmbed extra.
Chroma's performance guide says the HNSW index must reside in system RAM and gives N = R * 0.245 for 1024-dimensional embeddings, with N the maximum collection size in millions and R the RAM in gigabytes, plus at least a gigabyte for the system. Qdrant can keep original vectors on disk and quantized vectors in RAM.
Qdrant can: enable cluster mode, start nodes with --bootstrap, and set a replication factor when creating a collection (Raft covers cluster metadata, not your data). Chroma's docs call it a single-node solution that "will not scale forever" and point to a separate distributed deployment.
Paid link — we earn a commission if you shop through it.
One Rust container with its own storage, or a Standalone stack with etcd and MinIO that scales up to Kubernetes.
Bring your own vectors to a Rust engine with a dashboard, or let a Go database call the embedding model for you.
A whiteboard-and-docs workspace on a plain Compose file vs. native apps on a commercial server.