by chroma-core
Provides vector, full‑text, and metadata‑based retrieval powered by Chroma for LLM applications, supporting in‑memory, persistent, HTTP, and cloud clients as well as multiple embedding functions.
Chroma MCP Server exposes Chroma's embedding database through the Model Context Protocol, enabling LLMs to create collections, add documents, and perform semantic or keyword queries without writing custom storage code.
uvx chroma-mcp
).CHROMA_CLIENT_TYPE
, CHROMA_DATA_DIR
, CHROMA_TENANT
, etc.).uvx chroma-mcp --client-type persistent --data-dir /path/to/data
.chroma_create_collection
, chroma_add_documents
, chroma_query_documents
, …) from an LLM integration or CLI.chroma_list_collections
, chroma_query_documents
, etc.) for easy interaction.Q: Do I need to set API keys for embedding services?
A: Yes. Set CHROMA_<PROVIDER>_API_KEY
(e.g., CHROMA_OPENAI_API_KEY
) in a .env
file or export it before starting the server.
Q: Can I switch embedding functions after a collection is created? A: The embedding function is persisted with the collection configuration; to change it you must create a new collection or re‑initialize with the desired function.
Q: How does pagination work for list operations?
A: List tools accept limit
and offset
(or page
/page_size
) arguments; the server returns the requested slice of collections or documents.
Q: Is there a way to load environment variables from a custom path?
A: Yes. Use --dotenv-path /custom/.env
or set CHROMA_DOTENV_PATH
.
Q: What storage backend does the persistent client use?
A: It stores Chroma data files in the directory specified by CHROMA_DATA_DIR
.
The Model Context Protocol (MCP) is an open protocol designed for effortless integration between LLM applications and external data sources or tools, offering a standardized framework to seamlessly provide LLMs with the context they require.
This server provides data retrieval capabilities powered by Chroma, enabling AI models to create collections over generated data and user inputs, and retrieve that data using vector search, full text search, metadata filtering, and more.
Flexible Client Types
Collection Management
Document Operations
chroma_list_collections
- List all collections with pagination supportchroma_create_collection
- Create a new collection with optional HNSW configurationchroma_peek_collection
- View a sample of documents in a collectionchroma_get_collection_info
- Get detailed information about a collectionchroma_get_collection_count
- Get the number of documents in a collectionchroma_modify_collection
- Update a collection's name or metadatachroma_delete_collection
- Delete a collectionchroma_add_documents
- Add documents with optional metadata and custom IDschroma_query_documents
- Query documents using semantic search with advanced filteringchroma_get_documents
- Retrieve documents by IDs or filters with paginationchroma_update_documents
- Update existing documents' content, metadata, or embeddingschroma_delete_documents
- Delete specific documents from a collectionChroma MCP supports several embedding functions: default
, cohere
, openai
, jina
, voyageai
, and roboflow
.
The embedding functions utilize Chroma's collection configuration, which persists the selected embedding function of a collection for retrieval. Once a collection is created using the collection configuration, on retrieval for future queries and inserts, the same embedding function will be used, without needing to specify the embedding function again. Embedding function persistance was added in v1.0.0 of Chroma, so if you created a collection using version <=0.6.3, this feature is not supported.
When accessing embedding functions that utilize external APIs, please be sure to add the environment variable for the API key with the correct format, found in Embedding Function Environment Variables
claude_desktop_config.json
file:"chroma": {
"command": "uvx",
"args": [
"chroma-mcp"
]
}
claude_desktop_config.json
file:"chroma": {
"command": "uvx",
"args": [
"chroma-mcp",
"--client-type",
"persistent",
"--data-dir",
"/full/path/to/your/data/directory"
]
}
This will create a persistent client that will use the data directory specified.
claude_desktop_config.json
file:"chroma": {
"command": "uvx",
"args": [
"chroma-mcp",
"--client-type",
"cloud",
"--tenant",
"your-tenant-id",
"--database",
"your-database-name",
"--api-key",
"your-api-key"
]
}
This will create a cloud client that automatically connects to api.trychroma.com using SSL.
Note: Adding API keys in arguments is fine on local devices, but for safety, you can also specify a custom path for your environment configuration file using the --dotenv-path
argument within the args
list, for example: "args": ["chroma-mcp", "--dotenv-path", "/custom/path/.env"]
.
claude_desktop_config.json
file:"chroma": {
"command": "uvx",
"args": [
"chroma-mcp",
"--client-type",
"http",
"--host",
"your-host",
"--port",
"your-port",
"--custom-auth-credentials",
"your-custom-auth-credentials",
"--ssl",
"true"
]
}
This will create an HTTP client that connects to your self-hosted Chroma instance.
Find reference usages, such as shared knowledge bases & adding memory to context windows in the Chroma MCP Docs
You can also use environment variables to configure the client. The server will automatically load variables from a .env
file located at the path specified by --dotenv-path
(defaults to .chroma_env
in the working directory) or from system environment variables. Command-line arguments take precedence over environment variables.
# Common variables
export CHROMA_CLIENT_TYPE="http" # or "cloud", "persistent", "ephemeral"
# For persistent client
export CHROMA_DATA_DIR="/full/path/to/your/data/directory"
# For cloud client (Chroma Cloud)
export CHROMA_TENANT="your-tenant-id"
export CHROMA_DATABASE="your-database-name"
export CHROMA_API_KEY="your-api-key"
# For HTTP client (self-hosted)
export CHROMA_HOST="your-host"
export CHROMA_PORT="your-port"
export CHROMA_CUSTOM_AUTH_CREDENTIALS="your-custom-auth-credentials"
export CHROMA_SSL="true"
# Optional: Specify path to .env file (defaults to .chroma_env)
export CHROMA_DOTENV_PATH="/path/to/your/.env"
When using external embedding functions that access an API key, follow the naming convention
CHROMA_<>_API_KEY="<key>"
.
So to set a Cohere API key, set the environment variable CHROMA_COHERE_API_KEY=""
. We recommend adding this to a .env file somewhere and using the CHROMA_DOTENV_PATH
environment variable or --dotenv-path
flag to set that location for safekeeping.
Please log in to share your review and rating for this MCP.
Discover more MCP servers with similar functionality and use cases
by topoteretes
Enables AI agents to store, retrieve, and reason over past conversations, documents, images, and audio transcriptions by loading data into graph and vector databases with minimal code.
by basicmachines-co
Basic Memory is a local-first knowledge management system that allows users to build a persistent semantic graph from conversations with AI assistants. It addresses the ephemeral nature of most LLM interactions by providing a structured, bi-directional knowledge base that both humans and LLMs can read and write to.
by smithery-ai
mcp-obsidian is a connector that allows Claude Desktop to read and search an Obsidian vault or any directory containing Markdown notes.
by qdrant
Provides a semantic memory layer on top of the Qdrant vector search engine, enabling storage and retrieval of information via the Model Context Protocol.
by GreatScottyMac
A database‑backed MCP server that stores project decisions, progress, architecture, custom data, and vector embeddings, allowing AI assistants in IDEs to retrieve precise, up‑to‑date context for generation tasks.
by StevenStavrakis
Enables AI assistants to read, create, edit, move, delete, and organize notes and tags within an Obsidian vault.
by mem0ai
Provides tools to store, retrieve, and semantically search coding preferences via an SSE endpoint for integration with MCP clients.
by graphlit
Enables integration between MCP clients and the Graphlit platform, providing ingestion, retrieval, RAG, and publishing capabilities across a wide range of data sources and tools.
by andrea9293
MCP Documentation Server is a TypeScript-based server that provides local document management and AI-powered semantic search capabilities, designed to bridge the AI knowledge gap.