# Chroma (Vector DB) MCP for AI Agents AI Agent Connect

> Chroma (Vector DB) lets you manage vector embeddings and semantic data directly through your AI client. You can list collections, query high-dimensional embeddings for relevant context, and audit document counts or metadata. It's the bridge between your vector database and your AI agent's memory.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_aUtliGRmHCVn8DepMSRkGx8uw3Df2TS9KO1N5DG4/ai-agent-connect
- **Tags:** embeddings, semantic-search, llm-infrastructure, vector-search, data-retrieval, machine-learning

## Description

Instead of jumping between your database console and your AI chat, you can now talk directly to your Chroma instance. You'll be able to ask your agent to find specific documents based on meaning rather than just keywords. It handles the heavy lifting of navigating your vector collections so you don't have to write custom scripts every time you need to see what's inside a specific database. You can figure out why a specific query isn't returning the right context or confirm that your documents actually uploaded correctly. This Connector gives you a direct line of sight. You'll find this in the Vinkius catalog, where it serves as a direct bridge between your AI agent and your Chroma instance. You can switch between production and staging environments on the fly, ensuring your agent always has the right data at the right time without manual configuration errors.

## Tools

### list_collections
See every vector collection in a specific tenant database. This helps you get a clear picture of your data organization at a glance.

### get_collection
View the logical settings and configurations for a specific collection. You can use this to check how your data is being bounded or grouped.

### count_documents
Get the total number of documents currently in a collection. It's the fastest way to check if your data ingestion scripts finished correctly.

### get_documents
Get the exact physical documents and semantic context from a collection. This lets you see the raw data your agent is actually using for answers.

### query_embeddings
Find documents that match specific high-dimensional semantic clusters. Use this to test how well your semantic search handles different types of queries.

### peek_documents
Get a bounded preview of the database limits and content. It's great for a quick look at the data without pulling the entire collection.

### check_heartbeat
Check if the Chroma API nodes are online and reachable. Use this to make sure your connection is active before starting a heavy task.

## Prompt Examples

**Prompt:** 
```
How many docs are in the 'knowledge-base'?
```

**Response:** 
```
I've checked the 'knowledge-base' collection for you:

| Collection | Document Count |
| :--- | :--- |
| knowledge-base | 1,240

Would you like to see a preview of the first few documents?
```

**Prompt:** 
```
Show me a few examples from 'knowledge-base'.
```

**Response:** 
```
Peeking into 'knowledge-base'... Here are the first 3 documents:

* **Doc 1**: API Authentication Flow (Source: docs.internal)
* **Doc 2**: User Permission Matrix (Source: security.pdf)
* **Doc 3**: Database Schema v2 (Source: repo.git)

Each includes metadata like `source` and `last_updated`.
```

**Prompt:** 
```
Is the database online?
```

**Response:** 
```
Checking heartbeat... 

**Connection successful!** 
The Chroma instance responded in 12ms and is fully operational.
```

## Capabilities

### List all vector collections
See every collection in your database to understand your data organization.

### Inspect collection configurations
View the logical settings and boundaries for a specific collection.

### Find relevant context via semantic search
Identify documents that match specific high-dimensional semantic clusters.

### Count total documents in a collection
Get an exact count of the documents currently stored in a collection.

### Get specific document records
Pull the physical documents and semantic context from your vector arrays.

### Preview database content segments
Get a bounded preview of the data without pulling the entire collection.

### Check database connectivity
Confirm that your Chroma API nodes are online and reachable.

## Use Cases

### Verifying data ingestion
A developer wants to see if a new batch of documents was successfully indexed by using `count_documents`.

### Auditing production metadata
A data engineer needs to check the metadata consistency across three different production tenants using `get_collection`.

### Inspecting AI context
A product manager wants to see what specific documents the AI is remembering for a specific user by using `peek_documents`.

### Monitoring instance health
A DevOps engineer needs to quickly check if the self-hosted Chroma instance is responding to the API using `check_heartbeat`.

## Benefits

- Stop writing custom scripts just to see if your data uploaded correctly by using `count_documents` and `peek_documents`.
- Debug your RAG pipelines faster by asking your agent to `query_embeddings` and seeing the exact context returned.
- Keep your environments clean by using `get_collection` to switch between staging and production metadata.
- Reduce downtime by using `check_heartbeat` to confirm your Chroma Cloud or self-hosted instance is actually online.
- Audit your data more accurately by using `get_documents` to see the actual content stored in your vector arrays.

## How It Works

The bottom line is you get a conversational interface for your vector database without writing any extra code.

1. Subscribe to the Chroma (Vector DB) MCP on Vinkius.
2. Enter your Chroma URL and API Key into your AI client configuration.
3. Ask your agent to find relevant data or check your collection status.

## Frequently Asked Questions

**Can I use Chroma (Vector DB) MCP with my own self-hosted instance?**
Yes. You can connect to any Chroma instance, whether it's hosted in the cloud or on your own local hardware, just by providing your URL and API key.

**How do I check if my embeddings are actually in the database?**
You can use the Connector to query specific collections and see the document counts or peek at the content to confirm your data was indexed correctly.

**Can I see the metadata for my vector collections?**
Yes. The Connector allows your agent to inspect the logical settings and configurations for any specific collection in your database.

**Does Chroma (Vector DB) MCP work with Chroma Cloud?**
It works perfectly with Chroma Cloud. You just need to provide your cloud URL and API key to get started.

**How do I switch between different database tenants?**
You can ask your agent to switch between different tenants or databases on the fly to isolate your production and staging environments.

**Can I use this to find specific documents by meaning?**
Yes. You can ask your agent to perform a semantic search to find documents that match the specific meaning or context of your query.

**How do I check if my database is online?**
You can simply ask your agent to check the heartbeat, and it will confirm if your Chroma API nodes are reachable and operational.

**Can my agent perform semantic search across my collections?**
Yes. Provide the vector embedding array in JSON format, and your agent will return the closest document matches along with their distance metrics. It is the perfect way to test your RAG (Retrieval-Augmented Generation) logic without complex scripts.

**How can I verify the health of my self-hosted Chroma instance?**
Simply ask your agent to check the heartbeat. The agent performs a nanosecond-level responsiveness test against your API nodes, confirming the physical database is active and reachable from the gateway.

**I manage multiple tenants — how do I switch between them?**
You can define the tenant and database names during the setup phase. If you need to switch often, you can update the credentials in the dashboard. The agent uses these values for all collection and document operations to ensure strict isolation.