Related Pages

Related topics: Core Features: Collections, Vector/Full-Text/Hybrid Search & Metadata, Deployment Modes, Clients, CLI, Operations & Failure Modes

Project Overview & System Architecture

What is Chroma?

Chroma is an open-source AI-native search database designed to make it easy to inject private, offline, and real-time data that large language models were not trained on into their context. It focuses on search infrastructure for AI applications, where language models provide reasoning and Chroma provides retrieval Source: [README.md].

The project supports multiple complementary search modes, exposed through a unified search endpoint that can perform weighted hybrid search across all of them Source: [rust/chroma/README.md]:

Community interest in combining these modes is high: hybrid BM25 + vector search has been a top-requested feature (see #1330 and #1686), and metadata query flexibility is a recurring concern (#1195, #469). Long-running concerns also exist about metadata filter performance beyond ~20M records (#4089).

High-Level Architecture

Chroma is delivered as a multi-language, client/server system. The repository contains the Python full-library, a separate HTTP-only Python client, two JavaScript/TypeScript client packages, an official Rust client, a Rust CLI, and a server implementation that can be either Python-based or Rust-based Source: [README.md, clients/python/README.md, rust/cli/src/lib.rs].

flowchart TB
    subgraph Clients
        Py[Python: chromadb / chromadb-client]
        JS[JS/TS: chromadb / chromadb-core]
        RS[Official Rust Client: rust/chroma]
    end
    subgraph Server
        PySrv[Python Backend API]
        RustSrv[Rust Backend API - default]
    end
    Py -->|HTTP/REST| PySrv
    Py -->|HTTP/REST| RustSrv
    JS -->|HTTP/REST| RustSrv
    RS -->|HTTP/REST| RustSrv
    CLI[Rust CLI - rust/cli] --> RustSrv
    PySrv --> Storage[(Blockfile Storage)]
    RustSrv --> Index[Sparse/Dense/Full-Text Indexes]
    Index --> Storage

Key architectural facts:

• By default, chroma ships the Rust server; the Python backend remains available and is the implementation affected by a prior server-side RCE vulnerability (#6717) Source: [README.md].
• The new JavaScript package (clients/new-js/packages/chromadb) re-exports an auto-generated OpenAPI client and SDK (./api/index.ts) for fully typed REST access Source: [clients/new-js/packages/chromadb/src/api/index.ts].
• The Rust client exposes the same search API used internally by the server, allowing native embedding of Chroma in Rust applications Source: [rust/chroma/README.md].

Indexing and Storage Subsystem

The Rust server uses a blockfile-based storage layer with pluggable index types. The sparse index, for example, is split across two blockfiles — sparse_max for dimension- and block-level maximums (used for pruning), and a posting-list blockfile for actual data. The index exposes a SparseDelta for accumulating changes, a SparseWriter for incremental commits, and a SparseReader that returns scored hits via per-dimension Cursor structures Source: [rust/index/src/sparse/README.md].

The Python legacy server uses a similar blockfile format under the hood, and both implementations share the same conceptual data model: collections hold records with id, document, embedding, metadata, and optional uri, queryable through add, get, query, and delete operations Source: [clients/new-js/packages/chromadb/src/types.ts, clients/python/README.md].

Embedding Function Layer

Embedding functions are pluggable on both the Python and JavaScript sides and are validated against shared JSON Schema (Draft-07) definitions to guarantee cross-language compatibility. Each schema declares a version, a set of required properties, and sets additionalProperties to false for strict validation Source: [chromadb/utils/embedding_functions/schemas/README.md, schemas/embedding_functions/README.md].

A concrete example is the Jina embedding function, which calls https://api.jina.ai/v1/embeddings, accepts a model_name (defaulting to jina-embeddings-v2-base-en), and supports optional parameters such as task, late_chunking, truncate, dimensions, embedding_type, and normalized. It reads the API key from a configurable environment variable (default CHROMA_JINA_API_KEY) Source: [clients/js/packages/chromadb-core/src/embeddings/JinaEmbeddingFunction.ts].

Tooling, CLI, and Examples

The Rust CLI (workspace member rust/cli) is a clap-based command tree with subcommands for browse, copy, db, install, login, profile, run, update, vacuum, and webpage, plus shortcuts like docs Source: [rust/cli/src/lib.rs, rust/cli/src/commands/mod.rs]. Releases such as cli-1.4.4 and cli-1.4.3 track this binary independently of the server Source: [GitHub Releases].

The examples/ directory holds integration patterns: a Gemini RAG example that loads documents, embeds them, and augments a Gemini prompt with retrieved context Source: [examples/gemini/README.md]; an xAI RAG example using the same shape but with XAI_API_KEY Source: [examples/xai/README.md]; and a sample_apps/generative_benchmarking toolkit for synthetically generating query/document benchmarks from a user's own corpus Source: [sample_apps/generative_benchmarking/README.md]. The two JavaScript client variants — chromadb (bundled dependencies) and chromadb-client (peer dependencies) — give users a choice between convenience and lean dependency trees Source: [clients/js/README.md, clients/new-js/packages/chromadb/README.md].

The current main build is 1.5.10.dev103, with stable releases in the 1.5.x line; recent versions have added shard-aware materialize_logs, per-shard retries, getCollectionById cross-client support, and topology-DB function blocking Source: [GitHub Releases].

See Also

• Sparse Index Internals (rust/index/src/sparse)
• Embedding Function Schemas
• Rust CLI Reference
• Chroma Cloud

Related Pages

Related topics: Project Overview & System Architecture, Embedding Functions, Schemas & Language Integrations

Core Features: Collections, Vector/Full-Text/Hybrid Search & Metadata

Chroma is the open-source AI-native data infrastructure that powers search for LLM applications. Its core feature surface consists of collections (the unit of organization) plus a family of search modes (dense vector, full-text, sparse, and metadata) that can be combined through a single hybrid search endpoint. The following sections describe how these features are exposed in the client SDKs, what the Rust core actually implements, and which limitations and open feature requests shape real-world usage.

1. Collections

A collection is the top-level container in Chroma. It groups related records, each of which carries an id, an optional document, an optional embedding, optional uris, and a metadata payload. The public Python and JavaScript SDKs both expose a Collection (and AsyncCollection in Python) abstraction. The Python HTTP-client flow is representative:

import chromadb
client = chromadb.HttpClient(host="localhost", port=8000)
collection = client.create_collection("all-my-documents")
collection.add(
    documents=["This is document1", "This is document2"],
    metadatas=[{"source": "notion"}, {"source": "google-docs"}],
    ids=["doc1", "doc2"],
    embeddings=[[1.2, 2.1, ...], [1.2, 2.1, ...]],
)

Source: clients/python/README.md

Collections are described in the Rust client as the main entry point: "the easiest route is to sign up for [Chroma Cloud]." Source: rust/chroma/README.md. The JS SDK mirrors this with a ChromaClient that returns awaitable collection handles, e.g. await chroma.createCollection({ name: "test-from-js" }). Source: clients/new-js/packages/chromadb/README.md.

The TypeScript types.ts defines a BaseRecordSet interface that captures every field a record can carry: ids, embeddings, metadatas, documents, and uris. Source: clients/new-js/packages/chromadb/src/types.ts.

2. Search Modes

Chroma supports multiple, composable search modes, each backed by its own index in the Rust core.

2.1 Vector (Dense) Search

Dense embeddings give a numeric score for the similarity between two strings. The Rust crate README states: "Chroma supports dense embeddings for similarity search... Chroma automatically indexes your data so that you may query for similar text." Source: rust/chroma/README.md. This is the default mode in any query call where the caller supplies (or generates) a query_embeddings vector.

2.2 Full-Text Search

Full-text search is implemented as a word-based bitmap index in the Rust core. According to the index README: "Word-based full-text substring search using hashed token buckets with roaring bitmaps." Source: rust/index/src/fulltext/README.md.

The architecture is split into a Tokenizer (which performs splitting, lowercasing, ASCII folding, length filtering, and murmur3 hashing) and a Writer/Reader pair that stores (prefix, key) -> RoaringBitmap in a single blockfile. The 32-bit key layout is [partition:2][id:24][chunk:6], which chunks doc-ID bitmaps into 16M doc-ID ranges and supports up to 1B document IDs. The reader returns an over-estimate candidate set; the caller is responsible for the final brute-force verification stage. Source: rust/index/src/fulltext/README.md.

2.3 Sparse Vector Search (BM25, SPLADE)

Chroma also supports sparse embeddings, which the Rust client describes as being "more so than dense embeddings, sparse embeddings are sensitive to the literal words in documents." Source: rust/chroma/README.md.

The sparse index has three components: types.rs (dimension-ID encoding helpers and special prefix constants), writer.rs (SparseDelta, SparseWriter, SparseFlusher for incremental updates), and reader.rs (SparseReader, Cursor, Score). Source: rust/index/src/sparse/README.md.

Sparse vectors are stored in two blockfiles:

• sparse_max: per-dimension and per-block maximum values used for pruning (Prefix: String -> Key: u32 -> Value: f32), with two prefix shapes — "DIMENSION" for global dimension maximums and encode_u32(dimension_id) for block-level maximums.
• (A second blockfile holds the posting lists themselves; details continue in the source.)

Source: rust/index/src/sparse/README.md.

A first-party client-side sparse embedder is shipped as @chroma-core/chroma-cloud-splade, which calls Chroma's hosted embedding service for Splade++ English v1 (prithivida/Splade_PP_en_v1). Source: clients/new-js/packages/ai-embeddings/chroma-cloud-splade/README.md.

2.4 Hybrid Search

The headline capability is that all of the above modes can be combined. From the Rust client README: "Chroma natively supports hybrid search of all search modes via its search endpoint, which can do a weighted hybrid search across all modes of search, enabling applications to mix and match search strategies." Source: rust/chroma/README.md.

The following diagram shows how a single search request flows through the index stack:

flowchart LR
    A[Client SDK query/search] --> B[Hybrid Search Endpoint]
    B --> C[Dense Vector Index]
    B --> D[Sparse Vector Index]
    B --> E[Full-Text Bitmap Index]
    B --> F[Metadata Filter]
    C & D & E & F --> G[Weighted Rerank / Merge]
    G --> H[Top-K Result Set]

2.5 Embedding Function Integration

Search modes that require text-to-vector conversion are wired through pluggable embedding functions. The schemas README states: "These schemas are used by both the Python and JavaScript clients to validate embedding function configurations." Source: schemas/embedding_functions/README.md. A concrete example is the Jina embedding function, which validates api_key_env_var, model_name, and optional fields like task, late_chunking, truncate, and dimensions before issuing a request to https://api.jina.ai/v1/embeddings. Source: clients/js/packages/chromadb-core/src/embeddings/JinaEmbeddingFunction.ts.

3. Metadata & Filtering

Record and collection metadata in the JS SDK is typed as Record<string, boolean | number | string | SparseVector | boolean[] | number[] | string[] | null>. Source: clients/new-js/packages/chromadb/src/types.ts. Metadata filtering is applied as part of every search, often as a pre-filter that narrows the candidate set before vector/sparse/text scoring.

Known Limitations and Community Requests

• Lists in metadata are still a top feature request: the proposal is to extend metadata fields beyond scalar values. (Community issue #3415.) Source: clients/new-js/packages/chromadb/src/types.ts for the current type model.
• Flexible metadata operators (range queries, logical operators across fields) are tracked in #1195.
• Metadata filter scaling: a reported bug (#4089) describes metadata filters failing or returning no results for collections above ~20 million records, a practical ceiling operators should be aware of.
• Result ordering/sorting is not currently exposed on the query/get path; see #469. Users currently sort client-side.
• Hybrid + BM25 is one of the highest-engagement feature requests (#1330, #1686); sparse and full-text indexes already exist, but a turnkey weighted hybrid with BM25 is the dominant ask.
• Embedding-function install/typing issues are common: the TypeScript sample code referencing EmbeddingFunction (issue #7203) caused a SyntaxError for chromadb ^3.4.3 consumers.

4. Operational Tooling

The Rust CLI (chroma) groups every operation into subcommands: browse, copy (between local and Chroma Cloud), db (manage Cloud databases), docs, install (sample applications), login, profile, run, update, vacuum, and webpage. Source: rust/cli/src/lib.rs. The browse and db subcommands are the operational entry points for inspecting collections, while copy and vacuum are most relevant for working with large hybrid collections where metadata pre-filters and full-text indexes need to be rebuilt.

A working set of reference examples, including xAI (examples/xai) and Gemini (examples/gemini) RAG demos, is curated under examples/README.md, and the project ships standalone notebooks for basic and advanced functionality.

See Also

• README.md — project overview and quick start
• rust/chroma/README.md — Rust client and search modes
• rust/index/src/fulltext/README.md — full-text bitmap index internals
• rust/index/src/sparse/README.md — sparse vector index internals
• schemas/embedding_functions/README.md — cross-language embedding function configuration
• rust/cli/src/lib.rs — CLI subcommands

Related Pages

Related topics: Core Features: Collections, Vector/Full-Text/Hybrid Search & Metadata, Deployment Modes, Clients, CLI, Operations & Failure Modes

Embedding Functions, Schemas & Language Integrations

Overview

Chroma is the open-source AI-native data infrastructure for building LLM applications, providing dense, sparse, full-text, and hybrid search modes. Embedding functions are the pluggable layer that converts raw text (or other content) into vectors that Chroma can index, store, and query.

As stated in the top-level README.md, Chroma supports dense embeddings, sparse embeddings (e.g., BM25 or SPLADE-v3), full-text search, and metadata search — and "natively supports hybrid search of all search modes via its search endpoint" per rust/chroma/README.md. To keep these features consistent across runtimes, the project maintains a shared JSON Schema catalog for every embedding function and ships language-specific clients in Python, JavaScript/TypeScript, and Rust.

A recurring community request — for example issue #1330 ("Hybrid Search with BM25") and #1686 — shows that users expect BM25/full-text to be first-class across all clients. The schema-first approach described below is the mechanism that makes this portable.

Embedding Function Schemas

A dedicated schemas/ directory holds the canonical JSON Schema (Draft-07) for every supported embedding function. The rationale, from schemas/embedding_functions/README.md, is "cross-language compatibility and to validate that changes in one client library do not accidentally diverge from others."

Each schema file declares a version, title, description, properties, required fields, and sets additionalProperties: false for strict validation. The Python mirror at chromadb/utils/embedding_functions/schemas/README.md exposes a validate_config helper:

from chromadb.utils.embedding_functions.schemas import validate_config
config = {
    "api_key_env_var": "CHROMA_OPENAI_API_KEY",
    "model_name": "text-embedding-ada-002"
}
validate_config(config, "openai")

The JavaScript counterpart validateConfig lives in chromadb-core and is invoked from each embedding class — for example, clients/js/packages/chromadb-core/src/embeddings/JinaEmbeddingFunction.ts imports validateConfigSchema from ../schemas/schemaUtils and runs it during construction. This guarantees that the same set of keys (e.g., model_name, api_key_env_var, task, dimensions) is accepted in every client.

Language Integrations

Chroma ships three first-party client surfaces, each documented in its own README.

The Python client targets both the Rust-backed default server and the older Python server (see issue #6717 — "Python Backend Server Side RCE & Python Client SDK RCE" — which only affected the Python backend, not the Rust one). The JavaScript client README explicitly states "JS client version 3._ is only compatible with chromadb v1.0.6 and newer or Chroma Cloud" per clients/js/README.md. The next-gen JS client exposes rich typed result objects — see GetResult and QueryRowResult in clients/new-js/packages/chromadb/src/types.ts — including a .rows() helper for row-shaped iteration.

The Rust client is the canonical fast-path. The rust/chroma/README.md describes it as "the official Chroma Rust client" supporting dense, sparse, full-text, and hybrid search. Internally, the sparse index lives in rust/index/src/sparse/ and stores data in two blockfiles (sparse_max for pruning, the inverted posting list) — see rust/index/src/sparse/README.md.

Embedding Function Implementations

Each client provides concrete embedding classes. The patterns are remarkably uniform:

1. Store a StoredConfig type with the schema-validated keys.
2. Resolve the API key from the constructor argument or an env var (default CHROMA_<PROVIDER>_API_KEY).
3. Call the upstream HTTP endpoint, returning number[][].

Two representative implementations:

• clients/js/packages/chromadb-core/src/embeddings/JinaEmbeddingFunction.ts supports model_name, task, late_chunking, truncate, dimensions, embedding_type, and normalized, posting to https://api.jina.ai/v1/embeddings.
• clients/js/packages/chromadb-core/src/embeddings/TogetherAIEmbeddingFunction.ts is a minimal model_name + api_key_env_var implementation that POSTs to https://api.together.xyz/v1/embeddings.

Sparse embeddings are exposed through a separate family. clients/new-js/packages/ai-embeddings/chroma-cloud-splade/README.md documents the ChromaCloudSpladeEmbeddingFunction (default model SPLADE_PP_EN_V1, key via CHROMA_API_KEY), addressing the long-standing hybrid/BM25 demand from issues #1330 and #1686.

Example Applications and Tooling

The examples/ and sample_apps/ directories showcase end-to-end integrations. examples/README.md lists targets including basic/advanced functionality notebooks, deployments, and "use with" adapters for LangChain, LlamaIndex, Streamlit, and Next.js. Concrete chat-with-your-docs apps are provided for examples/gemini/README.md and examples/xai/README.md, both of which chunk source PDFs, embed them, and persist the collection locally.

For evaluation, sample_apps/generative_benchmarking/README.md ships generate_benchmark.ipynb and compare.ipynb so users can synthesize queries from their own corpora and compare embedding models.

Common Failure Modes

• TypeScript import errors. Issue #7203 reports SyntaxError: The requested module 'chromadb' does not provide an export named 'EmbeddingFunction'. Users must import the function class from the matching package (chromadb bundled vs. chromadb-client peers) and ensure the client major version matches the server (v3.x requires Chroma ≥ 1.0.6 per clients/js/README.md).
• Server-side RCE in the Python backend. Issue #6717 is scoped to the legacy Python server; the default Rust server is unaffected.
• Sparse / hybrid availability. Where a client lacks BM25 wiring, hybrid search degrades to dense-only. The schema-driven Splade package and the Rust sparse index are the supported path for true hybrid retrieval.

See Also

• Chroma Rust Client overview — rust/chroma/README.md
• Sparse Index internals — rust/index/src/sparse/README.md
• JS Client overview — clients/js/README.md
• Python Client overview — clients/python/README.md
• Generative Benchmarking — sample_apps/generative_benchmarking/README.md

Related Pages

Related topics: Project Overview & System Architecture, Embedding Functions, Schemas & Language Integrations

Deployment Modes, Clients, CLI, Operations & Failure Modes

Overview

Chroma is the open-source data infrastructure for AI, providing dense, sparse, and full-text search, with native hybrid search across all modes via its unified search endpoint. Source: rust/chroma/README.md:1-25. The project supports several deployment surfaces that share the same wire-level API: a Python full-library client, a Python HTTP-only client, a JavaScript/TypeScript client, an official Rust client, a chroma CLI for local operations, and a managed offering called Chroma Cloud. Source: README.md:1-25, Source: clients/python/README.md:1-15.

There are two server-side implementations: a Python backend and a Rust backend. The Rust backend is the default and is what the chroma CLI typically launches in dev mode. Source: community discussion in issue #6717. The Python backend shares the same API surface but is used in research, lightweight, or self-hosted Python-centric deployments.

Deployment Modes

The typical local development loop is pip install chromadb followed by chroma run --path /chroma_db_path, which spins up the server and persists data on disk. Source: README.md:1-25. For shared or production workloads, the repository ships reference deployments under examples/deployments/:

• Render.com — Terraform-driven, requires terraform init and terraform apply -auto-approve with variables such as TF_VAR_render_api_token, TF_VAR_chroma_release, TF_VAR_region, TF_VAR_enable_auth, and TF_VAR_auth_type. The free Render plan is incompatible because the Render API requires a paid tier. Source: examples/deployments/render-terraform/README.md:1-40.
• Google Cloud Compute — Uses the gcloud and terraform CLIs. SSH key generation is recommended; the template defaults to prevent_destroy = false for the persistent volume, which must be changed for production. Source: examples/deployments/google-cloud-compute/README.md:1-35.
• Chroma Cloud — Hosted serverless vector, hybrid, and full-text search with a sign-up flow granting $5 of free credits. Source: README.md:1-25.

Clients

The HTTP-only Python package is the recommended choice for server-mode deployments because it avoids loading the embedded server. Source: clients/python/README.md:1-25.

Embedding functions follow a strict cross-language contract. Each function (e.g. Jina, OpenAI) implements a common interface, validates configuration against a JSON Schema (Draft-07) with additionalProperties: false, and stores a StoredConfig object so the same settings can be reloaded in any client. Source: clients/js/packages/chromadb-core/src/embeddings/JinaEmbeddingFunction.ts:1-60, Source: schemas/embedding_functions/README.md:1-30.

The `chroma` CLI

The CLI is defined in the Rust workspace at rust/cli/. The top-level Command enum in rust/cli/src/lib.rs:18-55 exposes the following subcommands:

Command is parsed with clap and dispatched in the match block at rust/cli/src/lib.rs:65-80. The module is split per-command under rust/cli/src/commands/mod.rs:1-12.

The install subcommand resolves a sample app manifest, writes a .env file with CHROMA_HOST, CHROMA_TENANT, and CHROMA_DATABASE (defaulting to default_tenant and default_database), and records the installed version in the CLI's FileConfigStore. Source: rust/cli/src/commands/install.rs:1-60. This is the entry point for projects like the generative_benchmarking sample app. Source: sample_apps/generative_benchmarking/README.md:1-15.

Operations and Common Failure Modes

Operations teams running Chroma in production should be aware of the following known issues and limitations surfaced by the community:

flowchart TD
  A[Client Request] --> B{Server Type}
  B -- Rust default --> C[Rust Backend]
  B -- Python backend --> D[Python Backend]
  C --> E[Sparse + Dense + Full-text]
  D --> F[Limited search modes]
  D --> G["RCE exposure (issue #6717)"]
  C --> H["Metadata filter >20M chunks bug (issue #4089)"]
  E --> I[Hybrid search endpoint]

• Python backend RCE — A remote code execution vulnerability was reported against the Python API server. It does not affect the default Rust server. Operators running the Python backend should patch promptly and consider switching to the Rust binary. Source: issue #6717.
• Metadata filter regression at scale — Filtering on metadata breaks when a collection exceeds roughly 20 million records, while non-filter queries continue to return quickly. Source: issue #4089.
• JS export mismatch — TypeScript consumers importing EmbeddingFunction directly from chromadb hit SyntaxError: The requested module 'chromadb' does not provide an export named 'EmbeddingFunction'. Embedding function classes live in chromadb-core; users should import from there instead. Source: issue #7203, Source: clients/js/packages/chromadb-core/src/schemas/index.ts:1-5.
• Missing metadata features — Lists inside metadata values are not yet supported, and metadata filter expressions are limited in expressiveness, motivating workarounds such as many small collections. Source: issues #3415 and #1195.
• No native sort on get/query — Sort/ordering of results is not exposed; callers must sort client-side. Source: issue #469.
• Hybrid search via search endpoint — The Rust client explicitly documents that Chroma supports a weighted hybrid search endpoint combining dense, sparse (BM25 / SPLADE-v3), full-text, and metadata search. Source: rust/chroma/README.md:5-25.
• Persistent data layout — Sample apps persist to a chroma_data directory; deleting it resets the collection. Source: examples/xai/README.md:1-30.

See Also

• Embedding function schemas and cross-language validation
• Sample applications and benchmarking tools
• Rust sparse index internals
• Chroma Cloud database management

Doramagic Pitfall Log

Found 9 structured pitfall item(s), including 2 high/blocking item(s). Top priority: Installation risk - Installation risk requires verification.

1. Installation risk: Installation risk requires verification

• Severity: high
• Finding: Project evidence flags a installation risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/chroma-core/chroma/issues/4089

2. Installation risk: Installation risk requires verification

• Severity: high
• Finding: Project evidence flags a installation risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/chroma-core/chroma/issues/6717

3. Installation risk: Installation risk requires verification

• Severity: medium
• Finding: Project evidence flags a installation risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: community_evidence:github | https://github.com/chroma-core/chroma/issues/7203

4. Capability evidence risk: Capability evidence risk requires verification

• Severity: medium
• Finding: README/documentation is current enough for a first validation pass.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: capability.assumptions | github_repo:546206616 | https://github.com/chroma-core/chroma

5. Maintenance risk: Maintenance risk requires verification

• Severity: medium
• Finding: Project evidence flags a maintenance risk. Review the linked source before relying on this workflow.
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: evidence.maintainer_signals | github_repo:546206616 | https://github.com/chroma-core/chroma

6. Security or permission risk: Security or permission risk requires verification

• Severity: medium
• Finding: no_demo
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: downstream_validation.risk_items | github_repo:546206616 | https://github.com/chroma-core/chroma

7. Security or permission risk: Security or permission risk requires verification

• Severity: medium
• Finding: no_demo
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: risks.scoring_risks | github_repo:546206616 | https://github.com/chroma-core/chroma

8. Maintenance risk: Maintenance risk requires verification

• Severity: low
• Finding: issue_or_pr_quality=unknown。
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: evidence.maintainer_signals | github_repo:546206616 | https://github.com/chroma-core/chroma

9. Maintenance risk: Maintenance risk requires verification

• Severity: low
• Finding: release_recency=unknown。
• User impact: May increase setup, validation, or first-run risk for the user.
• Recommended check: Reproduce the official install and quickstart path in an isolated environment.
• Evidence: evidence.maintainer_signals | github_repo:546206616 | https://github.com/chroma-core/chroma

Community Discussion Evidence

Doramagic exposes project-level community discussion separately from official documentation. Review these links before using chroma with real data or production workflows.

• [[Vulnerability ]: Python Backend Server Side RCE & Python Client SDK RCE](https://github.com/chroma-core/chroma/issues/6717) - github / github_issue
• [[Install issue]:](https://github.com/chroma-core/chroma/issues/7203) - github / github_issue
• [[Bug]: metadata filter does not work over 20 millions chunk.](https://github.com/chroma-core/chroma/issues/4089) - github / github_issue
• Latest - github / github_release
• 1.5.9 - github / github_release
• cli-1.4.4 - github / github_release
• foundation-cli-v0.1.0-alpha.3 - github / github_release
• 1.5.8 - github / github_release
• 1.5.7 - github / github_release
• cli-1.4.3 - github / github_release
• cli-1.4.2 - github / github_release
• 1.5.6 - github / github_release