# DataStax Astra DB Vector MCP for AI Agents AI Agent Connect

> DataStax Astra DB Vector lets you connect your Astra DB instance to your favorite AI client. You can perform vector similarity searches, manage NoSQL JSON documents, and browse your collections through a simple chat interface. It gives your agent direct access to your unstructured data layer for RAG workflows and database management.

## Overview
- **Category:** ai-frontier
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_AqDRfth2dYqeDTcgeoWzkACu9uC1WOaTh5GDBWN7/ai-agent-connect
- **Tags:** nosql, vector-search, similarity-search, cassandra, unstructured-data, genai-infrastructure

## Description

Imagine you're building a retrieval-augmented generation system and you need to pull relevant context from a massive pool of unstructured data. Instead of writing custom scripts or switching back and forth between your database console and your code editor, you can just ask your agent to do the heavy lifting. This Connector makes your Astra DB feel like an extension of your agent's own memory. You can tell it to find the most similar items based on embeddings or ask it to pull out a specific document that matches a set of criteria.

If you're a data engineer trying to spot an anomaly in your JSON blobs, you can just ask the agent to count records or list your current collections to see what's active. It handles the specific syntax of the database so you don't have to. By adding this to your setup through the Vinkius catalog, you turn your agent into a capable database administrator that knows your data inside and out. It's about getting answers from your vector database without the friction of manual querying.

## Tools

### list_collections
See every collection in your namespace. It helps you quickly orient yourself when you have dozens of tables to manage.

### find_documents
Pull multiple records that match your specific NoSQL filters. Use this when you need to grab a batch of data for analysis.

### find_one_document
Grab a single JSON object from a collection. This is perfect for checking the details of a specific entry.

### vector_search
Run an Approximate Nearest Neighbor search on your embeddings. This is the core tool for finding semantically related content.

### insert_document
Add new data to your Astra DB. You can include pre-generated vector keys for immediate use in similarity searches.

### delete_document
Remove an entry from your collection. Use this to keep your database clean or remove outdated records.

### count_documents
Get a quick tally of how many records are in a collection. It's the fastest way to check the scale of your data.

## Prompt Examples

**Prompt:** 
```
Show me the collections in my Astra DB.
```

**Response:** 
```
Here are the collections present in your connected Astra DB namespace:

* `user_vectors` (active)
* `products` (active)
* `archived_logs` (active)

Which one would you like to inspect?
```

**Prompt:** 
```
Count how many products are in the 'inventory' collection.
```

**Response:** 
```
Your `inventory` collection currently holds exactly **1,240** active JSON documents across the cluster.
```

**Prompt:** 
```
Find any users from New York in the 'user_vectors' collection.
```

**Response:** 
```
I found 3 matching documents in `user_vectors`. Here are the details:

| User ID | City | Status |
| :--- | :--- | :--- |
| `u_992` | New York | Active |
| `u_441` | New York | Pending |
| `u_002` | New York | Active |
```

## Capabilities

### Perform vector similarity searches
Find semantically related documents based on your embeddings.

### Find specific NoSQL documents
Retrieve multiple JSON records that match your specific filters.

### Insert new documents with embeddings
Add new data to your collection including pre-generated vector keys.

### List all database collections
Browse every active table in your Astra DB namespace.

### Count records in a collection
Get an instant tally of how many documents are in a specific collection.

### Delete specific database entries
Remove outdated or incorrect records from your collection.

### Retrieve a single document
Grab a single JSON object from your database to inspect its details.

## Use Cases

### RAG Context Retrieval
An AI developer needs to find products similar to a user's description. They ask the agent to run a vector_search and get back the top 5 results.

### Data Cleaning
A data engineer notices some corrupted JSON. They ask the agent to find_documents with a specific city filter to identify the bad records.

### Rapid Prototyping
A product manager wants to see how many users are in the system. They ask the agent to count_documents in the 'users' collection for a quick status update.

### Database Maintenance
A DBA needs to clear out old logs. They ask the agent to delete_document for all entries older than a certain date.

## Benefits

- Faster RAG development: Use vector_search to pull context instantly without writing complex query logic every time you want to test a retrieval step.
- Easier data debugging: Use find_documents and find_one_document to spot issues in your JSON blobs quickly by just describing the criteria to your agent.
- Simplified record management: Use insert_document and delete_document to update your database state through chat, making it easier to maintain your data layers.
- Instant collection oversight: Use list_collections to get a high-level view of your active tables without having to navigate the DataStax dashboard.
- Rapid scale monitoring: Use count_documents to keep an eye on your record growth across different collections as your application scales.

## How It Works

The bottom line is you get a conversational interface for your entire Astra DB instance.

1. Subscribe to the Connector and get your credentials.
2. Input your Astra DB API Endpoint, Namespace, and Application Token.
3. Ask your agent to search, insert, or manage your vector data.

## Frequently Asked Questions

**Can I use DataStax Astra DB Vector to manage my NoSQL data?**
Yes. You can use this Connector to find, insert, delete, and count NoSQL JSON documents in your Astra DB through a natural conversation with your agent.

**How does DataStax Astra DB Vector help with RAG?**
It allows your agent to perform vector similarity searches directly. This makes it much easier to retrieve relevant context for your RAG workflows without writing custom query code.

**Can I insert new records into Astra DB using the AI?**
Yes, you can ask your agent to insert new documents. It can even include pre-generated vector keys so the data is ready for similarity searches immediately.

**Does DataStax Astra DB Vector support vector similarity?**
Yes, that is a core feature. The Connector allows your agent to perform Approximate Nearest Neighbor (ANN) searches to find semantically related content.

**Is it easy to connect DataStax Astra DB Vector to my agent?**
It's very straightforward. You just need to provide your Astra DB API Endpoint, Namespace, and Application Token to get started.

**Can I delete specific documents from my collection?**
Yes, you can ask your agent to remove specific records from your collection to keep your database clean or remove outdated entries.

**Can my AI agent do similarity searches across vector embeddings?**
Yes. Ask the agent to find documents related to a specific vector array in your target collection. The agent natively passes the numerical array directly into Astra DB's ANN engine, instantly returning the top semantically matched documents.

**Does this work like standard Cassandra or is it strictly vector-only?**
Both. While it excels at vector searches, the integration fully supports standard NoSQL JSON documents. You can insert, find, count, and delete standard text documents using strict JSON filters just like regular database operations.

**Can I switch seamlessly between different collections?**
Absolutely. Just mention the target collection by name in your prompts, and the agent adapts flawlessly. If you forget which ones exist, you can instruct it to list all available collections within your default namespace anytime.