On this page · 11 sections
- What Chroma announced, and the two dates that matter
- Who is affected, and who is not
- The Cloud-only features you must replace
- Export: the steps, in order
- Copy the vectors or re-embed?
- Migration targets compared
- Decision table: which target to choose
- Worked cost example: a SaaS company with 2 million chunks
- Timeline: what to do by when
- How eCorpIT can help
- References
Summary. Chroma Cloud, the hosted service behind chromadb.CloudClient, becomes read-only on 7 December 2026 and stops serving reads on 22 December 2026, under the wind-down notice Chroma published on 23 October 2026. Counted from today, 21 November, that leaves 16 days before writes fail and 31 days before every query fails. The notice came the same day Chroma announced a definitive agreement to join Replit. Open-source ChromaDB stays under the Apache 2.0 licence, and Chroma no longer offers its BYOC deployment. Three Cloud-only pieces make the move harder than a plain copy: the Search API with RRF hybrid ranking, sparse vectors from the hosted Splade function, and the hosted Qwen embedding function. Exporting is cheap: at $0.09 per GiB returned, pulling a 9.5 GiB database costs under $2, in pages of at most 300 records. Our verdict: copy your existing vectors unless you are changing embedding model, take a local snapshot with chroma copy --from-cloud this week, and choose the target by workload. In our 2-million-chunk example, managed targets cost $16 to about $85 a month.
About this article. This is for engineering leads and developers running retrieval-augmented generation (RAG), search or agent memory on Chroma Cloud. We checked the dates, features, limits and prices against Chroma's notice, blog and documentation, and against the pricing pages, documentation and migration guides of Pinecone, Qdrant, Weaviate, turbopuffer and pgvector, on 21 November 2026. Vendors change prices and terms often, so re-check before you commit; we did not benchmark these databases, and no vendor paid for inclusion. Researched with AI assistance and checked against the primary sources listed in the references.
Choosing a vector database from scratch rather than racing a deadline? Start with our production RAG vector database comparison.
What Chroma announced, and the two dates that matter
Chroma's wind-down page, published on 23 October 2026, sets two milestones. Forty-five days after the notice, on 7 December, Chroma Cloud turns read-only: applications can no longer create, update or delete data. Sixty days after the notice, on 22 December, it stops answering read requests. The page gives no reason for the shutdown and no date for deleting stored data. The table below follows that page.
| Date | What happens on Chroma Cloud | What Chroma asks customers to do |
|---|---|---|
| 23 October 2026 | Notice published | Read the timeline |
| 7 December 2026 | Writes disabled; service becomes read-only | Stop or redirect writes, move active workloads, start exporting and validating |
| 7 to 22 December 2026 | 15-day read-only window | Existing data can still be read |
| 22 December 2026 | Reads disabled | Finish exports, confirm apps no longer call Chroma Cloud endpoints, remove or rotate Chroma Cloud credentials |
The context sits in a separate post. Chroma's chief executive, Jeff Huber, wrote that Chroma has signed a definitive agreement to join Replit, that the team will carry on with ChromaDB and its Foundation context product at Replit, and that the existing cloud service is being wound down over 60 days. He added that Chroma has moved more code from its private repositories into the Apache 2.0 project and that Replit will keep contributing to it. The post gives no deal terms.
Two details catch teams out. Some early coverage gave a different write cutoff: Dealroom's 28 October summary said writes stop on 22 November. Chroma's own page, checked on 21 November, says 7 December, which matches its 45-day rule. And Chroma's BYOC engineering post now carries an October 2026 update saying Chroma no longer offers BYOC deployments. If you ran Chroma in your own cloud under that model, confirm your position with Chroma support through the contact on the wind-down page.
Who is affected, and who is not
You are affected if any code path talks to Chroma's hosted service. In practice that means:
- Chroma Cloud databases reached through
CloudClient, theapi.trychroma.comendpoint, or a framework integration such as LangChain, LlamaIndex or Mem0 that is configured with a Chroma Cloud key.
- Chroma Cloud embedding functions. The Qwen and Splade functions run on Chroma Cloud's servers and need a Chroma API key, so even a self-hosted collection that calls them will break.
- Chroma Sync jobs that pull S3, GitHub or web content, billed at $0.04 per GiB processed plus $0.01 per extracted or scraped page.
- Collection forks, a Cloud-only feature priced at $0.03 per fork request.
You are not affected if you run ChromaDB yourself: embedded with PersistentClient, as a chroma run server, in the chromadb/chroma container, or as the open-source distributed cluster. Chroma says the transition covers only the existing Chroma Cloud service.
Before you call a service clean, search code, notebooks, CI variables and secret stores for CHROMA_API_KEY, CHROMA_TENANT, CloudClient and trychroma.com.
The Cloud-only features you must replace
A Chroma Cloud collection does not always run unchanged on single-node Chroma. Chroma's Search API documentation says the API is available only on Chroma Cloud for now, with single-node support planned. If your code calls collection.search() with Knn, Rrf or GroupBy, moving to a local server means rewriting those calls to query() and get(), or moving to a database with native hybrid ranking. Forking is Cloud-only too: Chroma says the single-node storage engine cannot fork. Full-text and regex filtering, by contrast, is documented for local Chroma as well.
| Chroma Cloud feature | Works on self-hosted single-node Chroma? | Practical replacement |
|---|---|---|
| query() and get() with metadata, full-text and regex filters | Yes | Same code against a local server |
| Search API: search(), RRF hybrid ranking, GroupBy | No, Cloud only for now | Rewrite to query(), or use hybrid search in Qdrant, Weaviate, Pinecone or turbopuffer |
| Sparse vectors from the hosted Splade function | The hosted function goes away | Generate sparse vectors with a model you host, or use the target's BM25 or full-text search |
| Hosted Qwen embeddings | The hosted function goes away | Self-host Qwen3-Embedding-0.6B (Apache 2.0) or re-embed with another model |
| Collection forking | No | Snapshot or copy collections in your own pipeline |
| Sync (S3, GitHub, web) | No | Your own ingestion and parsing pipeline |
Chroma Cloud's quotas also shape the export: up to 4,096 dimensions, 5,000,000 records per collection, 300 results per request and 10 concurrent reads per collection.
Export: the steps, in order
Treat the export and the migration as two jobs: first a verified copy you control, then the move.
1. Inventory. List every database and collection with its record count, dimensions, distance metric (l2, cosine or ip; Chroma's default is l2) and embedding function.
2. Take a local snapshot with the Chroma CLI. The chroma copy command moves collections from Chroma Cloud to a local Chroma server or a local data directory.
chroma login
chroma copy --from-cloud --all --db my-db --path ./chroma-snapshot
# or named collections into a running local server
chroma copy --from-cloud collections support-docs product-faq --host http://localhost:8050
That snapshot is your safety net and, if the target is self-hosted Chroma, most of the migration. Keep it even if you end up on another database.
3. Export to an open format as well. A JSONL or Parquet file of IDs, embeddings, documents, metadata and URIs is something every other target can ingest. Page through each collection 300 records at a time:
import json, os, chromadb
client = chromadb.CloudClient(
tenant=os.environ["CHROMA_TENANT"],
database=os.environ["CHROMA_DATABASE"],
api_key=os.environ["CHROMA_API_KEY"],
)
PAGE = 300 # Chroma Cloud returns at most 300 records per request
for col in client.list_collections():
coll = client.get_collection(col.name)
total, offset = coll.count(), 0
with open(f"{col.name}.jsonl", "w") as out:
while offset < total:
b = coll.get(limit=PAGE, offset=offset,
include=["embeddings", "documents", "metadatas", "uris"])
for i, rid in enumerate(b["ids"]):
out.write(json.dumps({
"id": rid,
"embedding": [float(x) for x in b["embeddings"][i]],
"document": b["documents"][i],
"metadata": b["metadatas"][i],
"uri": b["uris"][i] if b.get("uris") else None,
}) + "\n")
offset += PAGE
print(col.name, total, col.metadata)
Offset paging is only safe on a collection that is not changing. Weaviate's to-weaviate guide for Chroma explains why: Chroma Cloud holds new writes in a log until a compaction moves them into the collection, and a compaction of more than 5,000 records gives records new positions, so a read by position during it can skip some. Pause writes before the export, or take the final export after 7 December, once writes have stopped and any pending compaction has finished.
4. Load the target. Use the vendor's tool where one exists:
- Qdrant. Its migration tool has a
chromasource with Chroma Cloud options (theapi.trychroma.comURL, tenant, database and anX-Chroma-Tokenheader) and migrates one collection per run. Keep--migration.batch-sizeat 300 or lower, and set--qdrant.distance-metricif your collection uses cosine or inner product, because the tool does not read your metric and defaults toeuclid.
- Weaviate. The
to-weaviatetool inspects Chroma, writes a plan you review, copies with resume and then verifies. It keeps original Chroma IDs in asource_idproperty, does not migrate sparse vectors, and stops if Chroma compacts the collection during a read.
- Pinecone. We found no Chroma-specific tool from Pinecone. Write Parquet to object storage and use Pinecone's import, priced at $0.25 per GB on Standard and Enterprise, or upsert in batches.
- turbopuffer. It says it does not currently offer migration tools, so script the load, and send batches of about 3.2 MB or more to get the full 50% batch-write discount.
- pgvector. Load into a
vector(n)orhalfvec(n)column, then build the HNSW index after the bulk load, as the pgvector README advises.
- Self-hosted Chroma. The step 2 snapshot is already a Chroma data directory; serve it with
chroma run --path ./chroma-snapshot.
5. Validate before you cut over. Qdrant's verification guide works for any target. Before migrating, record counts, sample at least 1,000 records or 1% of the data (whichever is larger) and record 10 to 50 baseline queries; afterwards, check that counts match and that recall@k on 50 or more queries meets a threshold such as 0.9.
6. Cut over and clean up. Move writes first, then reads, collection by collection. Before 22 December, remove or rotate every Chroma Cloud key in your applications, CI secrets and vaults, as Chroma asks.
Copy the vectors or re-embed?
If the same model will embed future queries, copying stored embeddings is faster and cheaper than re-embedding, and avoids a relevance regression.
| Your situation | Recommendation | Why |
|---|---|---|
| You embedded in your own code with an API model (OpenAI, Cohere, Voyage, Bedrock and similar) and will keep it | Copy vectors | Query embeddings stay compatible; no token spend |
| You used Chroma's default local model, all-MiniLM-L6-v2 | Copy vectors and keep the model in your app | The model runs locally; Weaviate's tool has no module for it, so embed queries in your code |
| You used the hosted Chroma Cloud Qwen function | Copy vectors, then self-host Qwen3-Embedding-0.6B and test parity | The open model is Apache 2.0 with up to 1,024 dimensions, but you must prove your hosted query vectors match |
| You used hosted Splade sparse vectors | Regenerate sparse vectors or switch to the target's keyword search | The hosted function goes away and Weaviate's tool does not migrate sparse vectors |
| You were already planning a model upgrade | Re-embed into the new store | One migration instead of two |
| Your vectors exceed 2,000 dimensions and the target is pgvector | Copy, but index as halfvec | pgvector's HNSW index takes vector up to 2,000 and halfvec up to 4,000 dimensions |
The Qwen case needs care. Chroma's wrapper requires a task such as nl_to_code and accepts optional instructions for documents and queries. The Qwen3-Embedding-0.6B model card marks the model as instruction-aware, so instruction text changes the vector, and it shows serving through Text Embeddings Inference and vLLM. Embed a few hundred real queries through Chroma's endpoint and through your own deployment, and compare cosine similarity. If the pairs are not near-identical, re-embed the corpus with your hosted copy. Chroma's notice does not say whether the hosted embedding endpoints stop on 7 December or 22 December, so run the test now.
Re-embedding is usually cheap next to the engineering time. A corpus of 2 million chunks at about 250 tokens each is 500 million tokens. At list prices that is 500 × $0.025 = $12.50 on Weaviate Embeddings' Snowflake Arctic-embed-m-v1.5, 500 × $0.08 = $40 on Pinecone's multilingual-e5-large, or 500 × $0.16 = $80 on Pinecone's llama-text-embed-v2, before any included allowance. Our embedding model selection guide covers the quality trade-offs if you do switch.
Migration targets compared
Prices are US dollar list prices from each vendor's page on 21 November 2026; floor rates vary by cloud and region. Chroma's instance costs are its own published figures, not current AWS quotes.
| Target | Licence or model | Hosted entry price | Key unit prices | Chroma migration path | Keyword or hybrid search |
|---|---|---|---|---|---|
| Self-hosted Chroma | Apache 2.0 | Your infrastructure | Chroma's sizing: t3.large (8 GB RAM) about 1.7M 1,024-dim records at $61.34 a month; r7i.2xlarge (64 GB) about 15M at $386.94 | chroma copy | Full-text and regex filters; Search API and RRF are Cloud-only |
| Pinecone | Proprietary, managed | Starter free; Builder $20 flat; Standard $50 minimum; Enterprise $500 minimum | Standard: reads $16 to $18 per million RU; writes $4 to $4.50 per million WU; storage $0.33 per GB-month; import $0.25 per GB | Your script, then object-storage import | Dense, sparse and full-text indexes |
| Qdrant | Apache 2.0, plus Qdrant Cloud | Free cluster with 0.5 vCPU, 1 GB RAM, 4 GB disk; Standard usage-based; Premium minimum spend | Hourly vCPU, memory and storage; rates in the calculator only | Migration tool with a chroma source | BM25 hybrid without sparse vectors since Qdrant 1.20 |
| Weaviate | BSD-3-Clause core, enterprise features under a separate Weaviate licence; plus Weaviate Cloud | Free 100,000 objects; Flex from $45 a month; Premium prepaid from $400 | Flex: dimensions from $0.00465 per million, storage from $0.12 per GiB, backups from $0.03036 per GiB | to-weaviate with plan, resume and verify | Built-in BM25 plus vector hybrid |
| turbopuffer | Proprietary, managed | Launch $16 minimum; Scale $256; Enterprise from $4,096 | Storage $0.33 per GB-month; writes $2 per GB; data queried $1 per PB; data returned $0.05 per GB; Enterprise usage rates 35% higher, storage unchanged | None offered; your script | Vector plus full-text search |
| pgvector | PostgreSQL License | Your Postgres | v0.8.7 on Postgres 13 and later; HNSW up to 2,000 dimensions (vector) or 4,000 (halfvec) | Your script into a table | Postgres full-text alongside vectors |
Three notes the table cannot carry. Self-hosted Chroma keeps its HNSW index in RAM, and Chroma's sizing rule is about 0.245 million 1,024-dimension records per GB of memory, plus at least 1 GB for the system. A single node is one machine, so standby and backups are yours to build. Pinecone charges a query 1 read unit per GB of the namespace searched, with a 0.25 RU minimum, so one large namespace is expensive and many small tenant namespaces are cheap. turbopuffer bills each query on the larger of the namespace size or 1.28 GB, with marginal discounts of 80% between 32 and 128 GB and 96% above that. For Postgres options beyond pgvector, see our Postgres vector search comparison.
Decision table: which target to choose
| Choose | If |
|---|---|
| Self-hosted Chroma | Your code uses query() and get() only, the corpus fits one node's RAM, and you want the smallest code change before 7 December |
| pgvector | You already run Postgres 13 or later, want vectors beside business data, and your dimensions fit 2,000 (or 4,000 as halfvec) |
| Pinecone | You want fully managed serverless with no tuning, can split data into tenant namespaces, and accept the $50 Standard minimum |
| turbopuffer | You have many small namespaces, want usage pricing above a $16 monthly minimum, and can write your own loader |
| Qdrant | You want open source with a managed option, payload filtering, and a migration tool that reads Chroma Cloud directly |
| Weaviate | You relied on Chroma's hybrid search and want built-in BM25 hybrid, multi-tenancy, and a tool that plans, resumes and verifies the copy |
Worked cost example: a SaaS company with 2 million chunks
A B2B software company runs a support assistant and in-app search on Chroma Cloud. It holds 2 million chunks with 1,024-dimension float32 embeddings (4,096 bytes) and about 1,000 bytes of text and metadata each, so 2,000,000 × 5,096 bytes = 10.2 GB in decimal units, or 9.5 GiB. It serves 500,000 queries a month, each returning 10 results of about 1 KB without vectors, so 5 GB returned. All data sits in one collection or namespace, priced from the vendors' pages.
| Option | Monthly arithmetic | Monthly total | One-time load |
|---|---|---|---|
| Chroma Cloud today (baseline) | Storage 9.5 GiB × $0.33 = $3.14; queried 500,000 × 0.00928 TiB × $0.0075 = $34.79; returned 4.66 GiB × $0.09 = $0.42 | About $38 | Not applicable |
| turbopuffer Launch | Storage 10.2 GB × $0.33 = $3.37; queried 500,000 × 10.2 GB = 5.1 PB × $1 = $5.10; returned 5 GB × $0.05 = $0.25; total $8.72, below the minimum | $16 (minimum) | Writes 10.2 GB × $2 with the 50% batch discount = $10.20 |
| Weaviate Flex | Dimensions 2,048M × $0.00465 per million = $9.52; storage 9.5 GiB × $0.12 = $1.14; both inside the $45 minimum; backups 9.5 GiB × $0.03036 = $0.29 on top | From about $45.29 | Not separately priced |
| Pinecone Standard, one namespace | Reads 10.2 RU × 500,000 = 5.1M RU × $16 per million = $81.60; storage 10.2 GB × $0.33 = $3.37; egress inside the 100 GB allowance | About $85 | Import 10.2 GB × $0.25 = $2.55 |
| Pinecone Standard, 100 tenant namespaces | Each namespace about 0.1 GB, so 0.25 RU per query: 125,000 RU × $16 per million = $2; storage $3.37; total below the minimum | $50 (minimum) | $2.55 |
| Self-hosted Chroma | 2M records need about 8.2 GB plus 1 GB for the system, beyond the 8 GB t3.large; t3.xlarge (16 GB, about 3.6M records) at Chroma's figure of $121.89 | About $122 plus disk, backups and on-call time | Engineering time only |
| Qdrant Cloud | Rates published only in the calculator; the free tier's 1 GB RAM and 4 GB disk are too small | Not published | Not published |
| pgvector | 2M × 4,104 bytes = 8.2 GB of vectors, plus HNSW index memory; cost is your Postgres instance | Depends on your instance | Engineering time only |
Exporting first costs about 9.5 GiB × $0.09 = $0.86 in returned data, across roughly 2,000,000 ÷ 300 = 6,667 paged get() calls. Chroma's pricing page does not say how a filter-free get() is metered; even if each call counted as one query over the whole 9.5 GiB, that adds about $0.46, so the export stays under $2. Managed alternatives land in the same range as the Chroma Cloud bill being lost, and namespace design moves Pinecone's bill more than any list price. Self-hosting is dearer at this size once you count a right-sized node and a standby. The real cost is engineering: rewriting Search API calls, retesting relevance and replacing Chroma Sync. Embedding and LLM costs are excluded.
Timeline: what to do by when
| Window | Chroma Cloud status | What should be done |
|---|---|---|
| 23 to 27 November | Normal | Inventory collections, metrics and embedding functions; take the CLI snapshot; pick a target; trial-migrate one collection |
| 30 November to 4 December | Normal | Point ingestion and Sync replacements at the new store, or dual-write; run recall checks on 50 or more queries |
| 7 December | Read-only | Every write path is on the new store; any write to Chroma Cloud now fails |
| 8 to 18 December | Read-only | Take the final export of frozen data; verify counts; move reads collection by collection; finish Qwen parity tests |
| 22 December | Reads disabled | No application, job or notebook calls Chroma Cloud; keys removed or rotated |
| After 22 December | Service ended | Keep your exported snapshot; Chroma has not said when stored data is deleted |
7 December is a Monday, and the days before 22 December run into holiday change freezes at many organisations. If your change board needs a week's notice, your practical read cut-over deadline is about 15 December. Chroma is not the only early-December deadline: our roundup of developer service cutoffs in December 2026 covers others due in the same weeks.
How eCorpIT can help
eCorpIT is a Gurugram-based technology organisation, founded in 2021, assessed at CMMI Level 5 and MSME certified, with senior-led engineering teams working across AWS, Microsoft and Google platforms. Our AI and machine learning services team can inventory your Chroma collections, export and validate them, rebuild hybrid search on the target you choose and set up recall checks for the cut-over. Talk to us at /contact-us/.
Last updated: 21 November 2026.