Astra DB Vector MCP. Run NoSQL CRUD and Vector Search from your chat.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
DataStax Astra DB Vector connects your AI agent directly to a NoSQL database. You can list collections, count records, retrieve single or multiple JSON documents using `find_documents`, and perform advanced Approximate Nearest Neighbor (ANN) vector similarity searches.
It lets you manage structured data and unstructured embeddings conversationally.
What your AI agents can do
Count documents
Returns the precise count of active JSON documents in a specified Astra DB collection.
Delete document
Removes targeted documents from an Astra DB collection based on provided criteria.
Find documents
Retrieves multiple JSON records from a specified collection using standard NoSQL filtering and querying.
Retrieves a list of every collection (table) currently defined in the connected Astra DB namespace.
Performs an ANN vector search on a specified collection to find documents whose embeddings are semantically close to your query vector.
Retrieves one or multiple JSON documents from a collection using standard NoSQL filtering parameters.
Adds a new document to a specified Astra DB collection. The input can include pre-generated vector keys for immediate searching.
Removes one or more existing JSON documents from an active collection.
Returns the total number of active records contained within a specified collection.
Ask AI about this MCP
Supported MCP Clients
Gemini Waiting for input…
DataStax Astra DB Vector: 7 Tools for DataOps
These seven tools allow your AI client to perform every standard database function—from counting records to performing complex vector similarity searches—directly against your Astra DB instance.
019d7553count documents
Returns the precise count of active JSON documents in a specified Astra DB collection.
019d7553delete document
Removes targeted documents from an Astra DB collection based on provided criteria.
019d7553find documents
Retrieves multiple JSON records from a specified collection using standard NoSQL filtering and querying.
019d7553find one document
Gets a single, specific document from an Astra DB collection when you know the unique identifier or precise filter.
019d7553insert document
Adds a new JSON document to a specified Astra DB collection. You can optionally include vector data for embedding searches.
019d7553list collections
Outputs a list of all distinct collections (tables) available in the configured database namespace.
019d7553vector search
Executes an Approximate Nearest Neighbor (ANN) search on a collection using vector embeddings to find semantically similar documents.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with DataStax Astra DB Vector, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,700+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
What you can do with this MCP connector
You connect your AI agent straight to a NoSQL database using Astra DB Vector. This server gives your agent full hands-on access to both structured JSON records and high-dimensional vector embeddings, letting it run complex data operations right through natural conversation.
Your agent first lists all the collections available in the connected namespace via list_collections, showing you every distinct table name you can work with. For basic data oversight, you'll get a count of active documents using count_documents against any specified collection.
You read data by finding specific records: if you know a unique identifier or a precise filter set, your agent retrieves one document at a time using find_one_document. If you need to pull back multiple JSON records based on standard NoSQL filtering—like retrieving all users from a certain city—you use find_documents.
For searching by concept or similarity, the system performs an Approximate Nearest Neighbor (ANN) vector search via vector_search. You supply your query vector, and the tool finds documents whose embeddings are semantically close to that input, regardless of keyword matching. This mechanism lets you find information based on meaning, not just text.
When you need to add data, insert_document handles it. Your agent can drop a new JSON document into any collection; this process supports optionally including pre-generated vector keys right alongside the structured data, making those records immediately available for embedding searches. Conversely, if you need to clean up old or incorrect information, your agent deletes targeted documents using delete_document, removing specific records based on criteria you provide.
It's a complete loop: You can browse every collection name with list_collections; you count the total items present in any given table; you pull single or bulk JSON data using standard filters (find_one_document and find_documents); you execute conceptual searches across all records via vector embeddings (vector_search); and finally, you manage the dataset by adding new content with insert_document or removing it entirely with delete_document.
This makes your agent a fully functional data steward for your structured and unstructured information.
How Astra DB Vector MCP Works
- 1 Subscribe to the MCP Server and provide your Astra DB API Endpoint, Namespace, and Application Token.
- 2 Your AI client executes an action (e.g., 'Find all user records in the
user_vectorscollection'). - 3 The agent calls the appropriate tool (like
find_documents) with context-aware parameters, and you receive the structured results.
The bottom line is: your AI client treats the database like a natural extension of its memory, executing complex queries without needing hardcoded API calls.
Who Is Astra DB Vector MCP For?
Data engineers who hate running boilerplate scripts just to check data consistency. DBAs tired of context switching between query tools and chat interfaces. AI developers building RAG systems that need deep, dynamic connections to unstructured data.
Uses list_collections and count_documents to map out the database structure before writing a query. Then uses find_documents to validate JSON schema adherence.
Integrates this server into an agent workflow, using insert_document and vector_search to test new data pipelines without leaving the IDE.
Manages record lifecycle by calling delete_document or verifying total counts across multiple collections using count_documents.
What Changes When You Connect
- Eliminate complex API calls. Instead of writing code to check a record count, just ask the agent: 'How many documents are in
products?' Thecount_documentstool handles it instantly. - Move beyond keyword search. Using
vector_search, your agent finds results based on meaning (semantics), not just matching words, drastically improving RAG quality. - Simplify data insertion and updating. Use the
insert_documenttool to add new records; you can even generate and include a$vectorkey at the same time. - Manage unstructured data in context. Need to know what collections exist? Run
list_collections. It gives you an instant map of your entire database structure. - Streamline debugging. If a document is wrong or needs removing, use
find_documentsfirst, then calldelete_document. No need to jump into the GUI console.
Real-World Use Cases
Checking Data Integrity Post-Migration
A data engineer just migrated 50,000 user profiles. Instead of writing a massive script, they ask their agent: 'How many records did we put in the user_vectors collection?' The agent runs count_documents and provides an immediate confirmation.
Improving Customer Support Search
A support developer is testing a new search feature. They ask: 'Find documents about 'server latency' that are related to the product line.' The agent uses vector_search on the knowledge base, returning relevant concepts even if the exact phrase isn't in the text.
Debugging a Missing Record
A DBA needs to verify if an old log entry exists. They know the ID but need confirmation: 'Does document xyz-123 exist in archived_logs?' The agent calls find_one_document and confirms existence or returns the JSON blob.
Building a Multi-Stage Data Pipeline
A developer wants to test a new product feature. They first ask to see all available collections (list_collections). Then, they use find_documents on the 'products' collection to grab existing records before running an update script.
The Tradeoffs
Using plain search for concepts
Trying to find documents about 'AI-driven efficiency' using standard filters on find_documents only finds the literal words 'AI' and 'efficiency', missing related context.
→
Use the dedicated vector_search tool. This performs Approximate Nearest Neighbor (ANN) lookups, finding semantically related documents based on meaning, not just keywords.
Ignoring data structure
Assuming all my collections have the same fields and trying to run a single query across different types of data.
→
Always start by calling list_collections. This shows you exactly which collections are available, letting you target specific tools like find_documents on the correct dataset.
Manual API calls for simple counts
Stopping your workflow to run a separate database CLI command just to check if 100 documents were added.
→
After running insert_document batches, immediately call count_documents. This provides instant feedback in the conversation thread, keeping your flow uninterrupted.
When It Fits, When It Doesn't
Use this MCP Server if your primary bottleneck is translating complex database operations (CRUD, vector search) into natural language commands. It's perfect for AI agents that need to act like a full-time DBA: they can read schema (list_collections), query specific data (find_documents, find_one_document), manage records (insert_document, delete_document), and perform deep semantic searches (vector_search).
Don't use this if you only need to run a single, simple API call in a script. If your process is just: 'GET user ID 123,' then a direct SDK connection is faster. But if your process is: 'First check the schema, then find all users who live in X city and whose embeddings are close to Y concept,' this server handles that orchestration layer for you.
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by DataStax Astra DB. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 7 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Available Capabilities
Checking data consistency shouldn't require opening six different tabs.
Today, checking if a record exists or confirming how many records were created involves jumping between the application dashboard, running ad-hoc queries in the CLI, and manually counting rows. It’s slow, prone to caching errors, and forces you to stop your thought process.
With this MCP Server, you just ask: 'What's the count in `products`?' The agent runs `count_documents`, returns a single number, and lets you keep building context. It makes data validation feel like asking a teammate.
Vector Search & Document Ops
Manually running vector searches means exporting embeddings to separate tools or writing complex similarity index queries that are far from the main application logic. It's an extra step, and it adds overhead to your code base.
Now, you simply ask: 'Find documents about X.' The agent uses `vector_search` against the collection directly through your client. Everything happens inside the conversation window. It’s instant.
Common Questions About Astra DB Vector MCP
How do I know what collections are available in Astra DB Vector? +
You run the list_collections tool. This gives you an immediate inventory of every collection name in your namespace, so you know exactly where to point subsequent queries.
Can I use vector_search on a document that doesn't have embeddings? +
No. vector_search requires the target collection to contain properly indexed vector data. If your documents are missing vectors, you must first run an embedding process and use insert_document to add them.
Is `find_documents` better than `find_one_document`? +
find_documents is for queries that might return a group of records based on filtering parameters. Use find_one_document only when you are absolutely certain the query will yield one single, unique result.
How do I add new data to the database using insert_document? +
To add data, call insert_document. You must provide a JSON body and specify the target collection. If you plan to search this document by concept later, include the pre-generated $vector key.
What credentials must I provide to run any query tool like `list_collections`? +
You need three things: your API Endpoint, Namespace, and Application Token. These credentials authenticate your AI agent directly to the Astra DB instance.
If I use `find_documents` with an invalid filter query, how does my agent handle the error? +
The tool returns a specific database exception detailing the schema or syntax issue. You must validate your JSON filters against the collection's actual structure before running the search.
Are there rate limits when I run many complex searches using `vector_search`? +
Yes, high request volumes can trigger throttling. The platform handles this with standard backoff mechanisms; your AI client should automatically retry the query if it receives a 429 error.
When I use `delete_document`, how do I confirm that the document was successfully removed? +
The tool returns an immediate success status upon execution. To be absolutely sure, run a follow-up query with find_one_document using the original identifier to verify it's gone.
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
NVIDIA AI
Access LLMs, embeddings, code generation, and reasoning via NVIDIA API Catalog.
Cohere
Access Cohere AI models via API — chat with Command models, generate embeddings, rerank documents and tokenize text from any AI agent.
Mistral AI
Access Mistral AI models via API — chat with Claude alternatives, generate embeddings, moderate content and manage batch jobs from any AI agent.
You might also like
Buttondown
Manage your newsletter via Buttondown — track subscribers, send emails, and monitor analytics directly from any AI agent.
Flightcontrol (AWS PaaS Deployments)
Deploy and manage AWS infrastructure via Flightcontrol — list projects, manage environments, and scale services directly from any AI agent.
Dune Analytics (Web3 SQL Analytics API)
Execute SQL queries on blockchain data via Dune Analytics — track executions, fetch results, and analyze Web3 metrics directly from your AI agent.