Pinecone MCP Server

Official Pinecone MCP for documentation search, index management, and vector search in an AI client.

Description

Pinecone MCP Server is Pinecone's official Model Context Protocol integration. It connects MCP-capable coding assistants such as Cursor, Claude, and Claude Code directly to Pinecone projects and their documentation. According to the official documentation, an agent can use it to search Pinecone documentation, list and describe indexes, create new indexes, upsert records, search semantically, and merge and rerank results across multiple indexes.

Purpose: developer workflow with a vector database

According to official documentation, Pinecone MCP Server targets developers who use Pinecone as part of their technology stack. It is designed for use in coding assistants, not as a general-purpose AI agent. Its focus covers three areas. First, searching the official Pinecone documentation so that the assistant can answer questions about the API, index configuration, and best practices without relying on pre-trained knowledge. Second, managing indexes, including creation, description, and status queries. Third, working with data: upserting records and running searches directly from the development environment to test queries and evaluate results.

Tools: what the assistant can execute

The official documentation describes nine tools provided by the MCP server. search-docs searches the official Pinecone documentation. list-indexes returns all indexes in the connected Pinecone project. describe-index describes the configuration of a single index. describe-index-stats provides statistics about the contents of an index, including the record count and available namespaces. create-index-for-model creates a new index that uses an integrated inference model to embed text as vectors. upsert-records inserts or updates records in an index with integrated inference. search-records searches for records based on a text query with embedding and supports metadata filtering and reranking. cascading-search searches across multiple indexes, deduplicates, and reranks the results. rerank-documents reorders a collection of records or text documents using a specialized reranking model.

According to the documentation, the MCP server supports only indexes with integrated inference. Indexes without integrated inference, standalone embeddings, and plain vector search are not supported.

Prerequisites and setup

Connecting to a Pinecone project requires a Pinecone API key, which can be created through the Pinecone console. Without an API key, the assistant can still search documentation but cannot manage or query indexes. For local execution, the server requires Node.js v20 or later, with node and npx available in PATH. The npm package is @pinecone-database/mcp, at version 0.3.0 according to the npm registry.

Configuration happens through a JSON file specific to each client. For Cursor, create a .cursor/mcp.json file in the project root. In Claude Desktop, add the settings under Settings > Developer > Edit Config. Claude Code uses the claude mcp add-json command. Antigravity provides an MCP Store for direct installation. For Gemini CLI, the repository documents an extension install command. The PINECONE_API_KEY is placed in the env section of the server configuration in all cases.

Boundary: MCP server versus Assistant MCP

Official Pinecone documentation distinguishes the Pinecone Developer MCP Server from a separate Assistant MCP Server. The Developer MCP Server improves the workflow of developers who use Pinecone in their stack. The Assistant MCP Server gives AI assistants access to context sourced from uploaded files in a Pinecone knowledge base. Both products are independent offerings with different use cases and configuration paths.

Security and data handling

The PINECONE_API_KEY should be stored exclusively in the client's secret or credential management facility, never in a source code repository, shared configuration files, prompts, or in plaintext in terminal history or screenshots. Tool calls that execute index management or write operations make permanent changes to the connected Pinecone project. This includes creating indexes and upserting records. For write operations, obtain approval from a responsible person before the agent acts. Restrict agent permissions to the operations that are actually needed.

Records upserted through upsert-records leave the local device and are stored on Pinecone's servers. The same applies to text queries sent to search-records, which are processed by Pinecone's integrated inference to produce embeddings. Before using sensitive data, review Pinecone's current terms of service and privacy policy directly with the provider. Both the connected MCP client and the assistant's model provider may additionally process and retain prompt content and tool results.

The official pinecone-io/pinecone-mcp repository is Apache-2.0 licensed. On 2026-09-08, the GitHub API reported exactly 71 stars. Stars are a point-in-time repository-popularity signal only; they do not demonstrate source quality, privacy, completeness, or security.

FAQ

Can the server also access Pinecone Assistants and their knowledge base? No. According to official documentation, there is a separate Pinecone Assistant MCP Server for that purpose. The Pinecone Developer MCP Server is designed for working with indexes and developer documentation.

Does the server work without an API key? In a limited way. Without a key, the assistant can search Pinecone documentation according to the documentation, but it cannot perform any index operations.

Which indexes are supported? Only indexes with integrated inference, according to the documentation. Indexes using external embedding models are not supported by this MCP.

Requirements

An MCP-capable coding client, Node.js v20+ with npx, and a Pinecone API key for index operations.

Installation instructions

Pinecone MCP Server connects coding assistants like Cursor, Claude Code, and Claude Desktop directly to Pinecone projects and their official documentation. According to official Pinecone documentation, a connected agent can search documentation, manage indexes, upsert records, and run semantic searches without switching between the assistant and the Pinecone console. This guide shows how to set up the server safely, what prerequisites are needed, and what to watch for when using it in development.

Step 1: Check prerequisites

Before setup, three things must be in place. First, Node.js v20 or later must be installed. Verify this with node --version. Second, npx must be available in PATH; check with which npx. Third, you need a Pinecone API key, which can be created through the Pinecone console. Without an API key, only documentation search is available according to the documentation; index operations are not possible. Have the key ready but do not store it in configuration files until the storage location is secured.

bash
node --version

Also check which client you are using. Cursor, Claude Desktop, Claude Code, and Antigravity are explicitly described in the official documentation. For Gemini CLI, the repository documents an extension install command. Verify that your client has current MCP support before starting configuration.

Store the API key securely

The PINECONE_API_KEY belongs in the client's secret or credential management facility, not in source code, not in a shared configuration file, and not as plaintext in terminal history. Most clients provide an environment-variable management or secret function that can make the key available to the MCP process. Use that instead of inserting the key directly into JSON configuration files that could accidentally be checked into a repository.

If a key has already been placed in a configuration file, add the file to .gitignore immediately before it reaches a repository. Rotate or revoke a potentially exposed key through the Pinecone console. The key grants read and write access to your Pinecone project; an exposed key should be revoked without delay.

Step 2: Set up Cursor

For a project-level setup, create a .cursor/mcp.json file in the project root and add the following configuration:

json
{
  "mcpServers": {
    "pinecone": {
      "command": "npx",
      "args": ["-y", "@pinecone-database/mcp"],
      "env": {
        "PINECONE_API_KEY": "<your-api-key>"
      }
    }
  }
}

Replace <your-api-key> with the actual key, or use a Cursor-specific secret facility. For a machine-wide setup, place the file in the home directory at .cursor/mcp.json. Check the server status under Cursor Settings > MCP. The official documentation also recommends adding Cursor rules for correct usage of the MCP server.

Step 3: Set up Claude Desktop

In Claude Desktop, open Settings > Developer > Edit Config and insert the configuration into claude_desktop_config.json. The structure matches the Cursor example above. After saving, restart Claude Desktop. A hammer icon should appear on the new chat screen, showing the available MCP tools. If the icon is absent, check the JSON syntax of the configuration file and verify that Node.js is installed correctly.

Step 4: Set up Claude Code

For Claude Code, use the following command:

bash
claude mcp add-json pinecone-mcp \
  '{"type": "stdio",
    "command": "npx",
    "args": ["-y", "@pinecone-database/mcp"],
    "env": {"PINECONE_API_KEY": "YOUR_API_KEY"}}'

After restarting Claude Code, check the status with /mcp. The official documentation also describes the Pinecone Claude Code Plugin, which bundles the MCP server, eight skills, and slash commands, if a more comprehensive integration is desired.

Step 5: Run a first test

After setup, start with a low-risk documentation query, for example: "Search the Pinecone docs for information about metadata filtering." This verifies that the assistant recognizes and uses the tool before running any write operations. If that works, use list-indexes to list your own indexes and verify project access.

For initial write operations, choose a test environment or a namespace that does not contain production data. Create an index with create-index-for-model, upsert test data, and then search it. This lets you evaluate queries and results directly in the development environment before real content is upserted.

Know the server's limits

According to official documentation, the Pinecone Developer MCP Server only supports indexes with integrated inference. External embedding models and plain vector search without integrated inference are not supported. For access to Pinecone Assistants and their knowledge bases, there is a separate Pinecone Assistant MCP Server that is configured independently. Keep these two use cases clearly separate to avoid configuration errors.

Write permissions and human approval

Operations such as upsert-records and create-index-for-model permanently modify the Pinecone project. In a production environment, explicit approval from a responsible person should be part of the process before the assistant executes such changes. Restrict agent permissions to the operations that are actually needed. Data upserted through upsert-records leaves the local device and is stored on Pinecone servers; review Pinecone's privacy policy and terms of service directly with the provider before using sensitive content. This guide intentionally gives no price amounts.

FAQ

Which npm package starts the Pinecone MCP Server? @pinecone-database/mcp, launched via npx -y @pinecone-database/mcp.

bash
npx -y @pinecone-database/mcp

Do I need an API key for documentation search? No. Documentation search is available without an API key according to official documentation. A key is required for index operations.

How do I check whether the server is active? In Cursor under Settings > MCP; in Claude Code with the /mcp command.

npx -y @pinecone-database/mcp

Authentication

Pinecone API key, stored as PINECONE_API_KEY in the env section of the client configuration. Without a key, only documentation search is available.

Required access permissions

Access and available operations depend on the Pinecone account, API key permissions, client support, and current provider terms.

Transmitted or stored data

Tool calls use the Pinecone API; upserted records and search queries are processed on Pinecone servers. Prompts and results can also reach the model and logging path of the connected client.

Security risks

API keys can be exposed through configuration files, logs, or repositories. Write operations permanently modify the Pinecone project and require human approval. Sensitive data should not be upserted without reviewing provider terms.

License and costs

License
Apache-2.0
Cost
paid

The source code is Apache-2.0 licensed. API key use follows the account, limits, and current provider terms; check them directly with Pinecone. This entry lists no specific prices.

Alternatives

Not recorded yet.

At a glance

Provider
Pinecone
Status
Official server
Deployment
Local
Current version
0.3.0
GitHub stars
72
Last reviewed
08.09.2026

Repository and documentation

Categories

Supported clients