Pinecone MCP. Query embeddings & manage vector indexes from 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.
Pinecone MCP Server gives your AI agent full control over your vector databases. Use this server to query embeddings, check index health, list collections, or delete vectors—all via natural language chat.
It lets you manage complex knowledge graphs and run semantic searches without writing boilerplate code or leaving your IDE.
What your AI agents can do
Delete vectors
Deletes specified vectors from an index after confirming the ID and collection name.
Describe index
Retrieves configuration details, like dimensions, for a named vector index.
Fetch vectors
Gets specific vectors from an index when you know their unique IDs.
Shows all vector indexes currently set up in your Pinecone environment.
Retrieves the full configuration details—the schema, dimensions, and metadata requirements—for a specific index.
Finds the most semantically similar vectors and their associated data by passing an array of query embeddings.
Retrieves known, specific vectors from an index when you already have their unique IDs.
Pulls real-time usage metrics, including vector count and pod capacity limits, for any given index.
Lists all snapshot collections that hold grouped versions of your data over time.
Removes specific vectors from an index, allowing you to clean up old or irrelevant data records.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
Pinecone MCP Server: 7 Tools for Vector Index Management
These seven tools give your AI agent direct operational control over every aspect of your Pinecone vector database, from discovery to deletion.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Pinecone on Vinkius019d75f3delete vectors
Deletes specified vectors from an index after confirming the ID and collection name.
019d75f3describe index
Retrieves configuration details, like dimensions, for a named vector index.
019d75f3fetch vectors
Gets specific vectors from an index when you know their unique IDs.
019d75f3get index stats
Returns usage statistics, including vector count and pod capacity, for a specified index.
019d75f3list collections
Lists all snapshot collections stored within your Pinecone environment.
019d75f3list indexes
Retrieves the names of every active vector index in your account.
019d75f3query vectors
Searches for and returns the most similar vectors and their metadata based on a query embedding.
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 Pinecone, then connect any of our 4,800+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,800+ 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
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Pinecone. 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.
Dealing with vector databases used to feel like a manual crawl through dashboards.
Before this server, checking your knowledge graph was a multi-step pain. You'd have to jump between the Pinecone console, run multiple reports on capacity limits, and then manually write client code just to test if a retrieved chunk of text actually answered the question correctly.
Now? You ask your agent: 'What are the index stats for X?' It runs `get_index_stats` in the background and gives you the full breakdown—vector count, pod usage, dimension details—all in one chat response. No clicks required.
Pinecone MCP Server: Control your data from conversation.
Manually listing indexes and collections used to be a separate, error-prone process that had to happen before you could even start building the retrieval logic. You'd have to check `list_indexes` then `describe_index`, just to get started.
Now, your agent handles the setup. It runs discovery tools like `list_indexes` and validates the schema using `describe_index`—all before it executes a single search query (`query_vectors`). The workflow is safer and faster.
What you can do with this MCP connector
Listen up. This Pinecone MCP Server gives your agent full control over your vector databases. You're talking about querying embeddings, checking index health, listing collections, or deleting vectors—all done via natural language chat. It lets you manage complex knowledge graphs and run deep semantic searches without needing to write boilerplate code or jumping out of your IDE.
When you connect this server, you gain a suite of tools that let your AI client interact directly with Pinecone's operational layer. You don't just ask questions; you make database changes. Here’s what it lets you do:
Discovery & Mapping:
You can start by listing every single active vector index in your account using the list_indexes tool. This shows you a quick rundown of all the knowledge bases you've set up. If you need to see historical groupings, you run list_collections, which returns names of snapshot collections holding grouped versions of your data over time.
For any specific index you find, you can check its exact configuration—its schema, dimensions, and metadata requirements—by calling describe_index. This means you know precisely what structure the data in that index expects before sending anything to it.
Retrieval Operations:
Want to search for something? You use query_vectors. By passing an array of query embeddings, this tool finds the most semantically similar vectors and pulls back their associated metadata. It's not just a keyword match; it’s finding concepts that mean the same thing. If you already know the unique IDs of the records you need—maybe they came from another process—you skip the similarity search and use fetch_vectors to grab those specific vectors directly from an index.
Monitoring & Auditing:
You gotta keep track of your resources, right? To check how much capacity you're using or if you're running low on space, call get_index_stats. This pulls real-time usage metrics for any given index, giving you the vector count and pod capacity limits. This is crucial for knowing when you need to scale up your environment before things break.
Maintenance & Cleanup:
Sometimes you gotta clean house. If you find old or irrelevant data records cluttering an index, delete_vectors lets you perform surgical cleanups. You must confirm the vector ID and the collection name first; it’s a controlled deletion process so you don't mess up anything important.
Essentially, your agent doesn't just read from Pinecone; it operates within it. It maps out the structure with list_indexes and list_collections. It validates the schema using describe_index. It executes complex searches with query_vectors or retrieves known data points via fetch_vectors. It tracks usage limits by pulling stats with get_index_stats. And it keeps things tidy by running cleanup jobs with delete_vectors.
You get full, structured access to your entire vector database environment.
019d75f3-2b6b-72d6-bba4-f5773344ccd9 
How Pinecone MCP Works
- 1 First, supply your Pinecone API key to the MCP Server.
- 2 Next, prompt your AI client with a request—like 'What's the vector count for X index?' or 'Find things similar to Y.'
- 3 The agent runs the necessary tool (e.g.,
get_index_statsorquery_vectors) and returns the structured data directly into the chat thread.
The bottom line is, you bypass writing client code and talk to your vector database like it's a simple API endpoint in a conversation.
Who Is Pinecone MCP For?
This is for the ML Engineer who's sick of debugging relevance by running dozens of tiny Python scripts. It's also for the Data Custodian who needs to audit storage capacity or the Agent Builder weaving complex RAG logic into multiple systems. If your job involves querying large, unstructured knowledge graphs, you need this.
Tests semantic chunk relevance by running conversational queries instead of constructing manual Python test scripts.
Audits storage capacity across multi-tenant indexes and verifies data integrity after bulk deletions using delete_vectors.
Weaves dynamic, conversational RAG integrations into systems by testing Pinecone core endpoints directly through a chat workspace.
What Changes When You Connect
- Instant Schema Validation: You don't have to guess what an index expects. Running
describe_indexgives you the exact configuration details before your agent tries to query it, saving hours of debugging time. - Conversational Debugging: Forget writing boilerplate Python test scripts just to check semantic relevance. Asking your agent a simple question like 'What are the stats for X?' runs
get_index_statsand gives you the answer immediately in chat. - Data Governance at Scale: Need to clean up old vectors? Use
delete_vectors. You can manage data lifecycle—deleting records belonging to specific IDs or namespaces—without leaving your conversational flow. - Structured Discovery: Mapping your entire knowledge graph is easy. Run
list_indexesfirst, then uselist_collectionsto see all historical snapshots, keeping your data lineage clear. - High-Speed Retrieval: When you need the best context,
query_vectorshandles the heavy lifting of finding semantically similar vectors and returning their metadata, making RAG pipelines faster and more reliable.
Real-World Use Cases
Debugging Context Relevance (ML Engineer)
A developer suspects chunks from Index A aren't relevant enough. Instead of writing a test script, they prompt their agent: 'Run query_vectors on Index A with this embedding and tell me the top 5 results.' The agent executes the query and returns the data structure, letting the engineer pinpoint the failure point instantly.
Auditing Storage Capacity (Data Custodian)
The platform architect needs to know if a specific index is hitting its capacity limit before migrating more data. They ask the agent: 'Check get_index_stats for the production index.' The agent runs the tool and reports the vector count and pod utilization percentage, preventing an outage.
Building Multi-Tenant Agents (Agent Developer)
An agent needs to process data across several client namespaces. First, it uses list_indexes to find all available indexes, then runs describe_index on each one to validate the expected dimensions and schema before attempting any reads.
Cleaning Up Old Records (Data Architect)
After a project phase ends, an index accumulates stale vectors. The architect uses list_indexes to confirm the correct target, then calls delete_vectors targeting specific IDs or namespaces, ensuring clean data retention and reducing costs.
The Tradeoffs
Assuming Schema Compliance
Sending a query embedding directly to your agent without first validating the index schema. The system fails because the dimensions don't match what the underlying database expects.
→
Always run describe_index first. This confirms the exact mathematical dimension and configuration details, ensuring that subsequent calls like query_vectors won't fail due to mismatched parameters.
Over-relying on One Query
Using only query_vectors without knowing what collections exist. You might retrieve data from a staging environment, thinking it's production.
→
Start by running list_collections. This shows all snapshot versions available, letting you confirm if the context you need comes from 'staging' or the primary production collection.
Attempting Bulk Deletion Blindly
Telling the agent to delete everything in an index just because it seems old. You risk wiping out critical, unindexed data.
→
Use list_indexes and then use describe_index to understand the scope. Only run delete_vectors when you have a confirmed list of IDs or namespaces you absolutely need gone.
When It Fits, When It Doesn't
Use this server if your workflow requires managing complex, multi-step data operations (read, write, audit) using natural language chat prompts. It’s perfect for debugging relevance and auditing stored knowledge graphs.
Don't use it if you need to interact with the underlying database platform through a custom API endpoint that isn't covered by one of the seven exposed tools. For example, if your process requires generating complex aggregation reports or running non-standard mathematical functions on the raw vector data, you'll need a dedicated reporting tool instead. This MCP is for operational control and retrieval safety.
Common Questions About Pinecone MCP
How do I check which indexes are available with list_indexes? +
You simply ask your agent to run list_indexes. It returns a plain list of all the vector index names you've created in your Pinecone environment. This is always step one for discovery.
What does describe_index do if I don't know my schema? +
Running describe_index pulls the full configuration details, including the required mathematical dimension and metadata structure. It tells you exactly what your index expects so subsequent queries won't fail.
Can query_vectors find data if I don't know the ID? +
Yes. query_vectors is designed for similarity search. You provide an embedding, and it finds the top N most similar vectors based on mathematical distance, regardless of whether you knew their IDs.
How do I clean up old data using delete_vectors? +
You must specify three things: the index name, a collection, and the specific vector ID(s). The agent uses delete_vectors to target only what you explicitly tell it to remove.
How do I check the usage capacity or health metrics using `get_index_stats`? +
It returns real-time statistics on vector counts and pod utilization. This shows you if your index is nearing its capacity limit, so you can proactively manage storage before a service failure.
What does `list_collections` show me about my stored backups? +
It lists all saved versions (snapshots) of your data structure. You use this to audit or roll back to a specific point in time, which is crucial for safe testing or compliance.
If I know the exact vector ID, how do I use `fetch_vectors`? +
It pulls the precise metadata and embedding data associated with that single ID. This method bypasses similarity searches, offering faster retrieval when you need a specific record.
How do I verify the required vector dimension size using `describe_index`? +
This tool provides the index's configured mathematical dimension. Checking this confirms compatibility with your embedding model and prevents data ingestion errors during setup.
Can the AI execute raw vector similarity searches? +
Yes, absolutely. Once you supply the raw semantic embedding coordinates (normally a float array generated previously), the LLM can funnel it through the query_vectors tool. The Pinecone DB will process this and return the top-K closest vector matches along with embedded metadata.
How do I check my remaining vector storage capacity? +
It's extremely simple. Just ask the connected AI agent to 'Get the index stats'. It will internally call get_index_stats against the specified index namespace, returning total vector count and physical dimensionality limits to your chat window.
Is it safe to delete vectors dynamically using the chat terminal? +
Yes, but with standard precautions. The delete_vectors tool operates exactly as the official SDK. As long as you maintain clear contextual scopes and ID filtering in your prompts, the execution is purely deterministic and secure.
Multi-server workflows that include Pinecone MCP
Build Document Intelligence Using MCP Servers
You have 500 PDFs, contracts and reports that contain critical business knowledge locked inside files nobody reads , Unstructured extracts the content, Pinecone makes it searchable, and Notion indexes every document
Track Competitor Moves Using MCP Servers
Google Alerts sends you irrelevant noise. Exa understands meaning , it finds the blog post where your competitor quietly announced a pricing change buried in paragraph 7 of a product update, because semantic search reads intent, not just keywords
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.