A Pinecone MCP for agents that read and write the index, not just search it
Connect one Pinecone API key and 35 nodes land on the canvas: create and configure indexes, run similarity search, upsert and update vectors, manage namespaces and text records, take backups before anything irreversible, and start bulk imports. An AI agent can retrieve context, write what it learned back to the right namespace, and check the record count afterwards, with the results sitting next to your tasks and databases.
What the Pinecone MCP connector does
The Pinecone connector for Mattering Automations is 35 nodes on Pinecone API version 2025-10, covering both halves of the REST surface. The control plane carries indexes (including indexes with integrated embedding), collections, backups and restore jobs. The data plane carries the vectors themselves: similarity search, fetch by id and by metadata filter, upsert and update, deletes, namespaces, text records, and asynchronous bulk imports from object storage. One API key authenticates all of it, sent as Pinecone's Api-Key header. Mattering also sends the X-Pinecone-Api-Version header on every call, pinned to 2025-10: a request without that header falls back to the oldest supported stable version, so pinning is what keeps the connector on a known API shape.
Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An agent can search a namespace for context with Pinecone: Query Vectors, write a summary of its own work back with Pinecone: Upsert Vectors, and confirm the namespace grew with Pinecone: Describe Index Stats, without anyone opening the Pinecone console.
One structural fact about Pinecone shapes the whole connector, and it is worth explaining rather than hiding. Pinecone is two APIs on two hosts: control-plane calls go to one global address, and data-plane calls go to the index's OWN host, a different address for every index, which Pinecone hands you from the console or the API rather than following a pattern you can assemble yourself. So the host is not part of the credential, it is node configuration. You connect one credential for the project, and each vector node carries an index host field that is a picker sourced from Pinecone: List Indexes. You choose an index by name, the host that lister already returned is what gets saved, and nothing has to be resolved again at run time.
The safety modeling is stated rather than implied. Of the 35 nodes, 18 read and 17 act, and five are flagged destructive: Pinecone: Delete Index, Pinecone: Delete Namespace, Pinecone: Delete Vectors, Pinecone: Delete Collection, and Pinecone: Delete Backup. None of them has an undo and none of them lands in a trash: deleting an index or a namespace takes every record inside it. Pinecone: Delete Vectors is flagged even though its narrowest form removes only the ids you listed, because with delete all set, or with a metadata filter, its blast radius is whatever happens to be in the index at that moment rather than a list anyone checked. Pinecone: Create Backup is what makes any of this recoverable, which is exactly why deleting a backup counts as destructive too. One plan caveat belongs with that, because it changes the advice: Pinecone documents backups and restores as available on the Standard and Enterprise plans and not on Starter or Builder, so on an entry tier the recovery path for those five nodes is a rebuild from your source of truth rather than a snapshot.
One connection, three surfaces
- Visual automations. Drag Pinecone nodes onto the canvas and wire them to triggers, conditions, and other apps.
- AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
- The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.
Every Pinecone node, ready to drop on the canvas
35 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.
Read and query nodes 18
Pinecone: Describe Backup
Get one backup's status and contents: source index, record count, namespace count, size in bytes, dimension, metric and creation time. Poll this after Pinecone: Create Backup until status is Ready.
Pinecone: Describe Collection
Get one collection's configuration and status: dimension, record count, size in bytes, environment, and whether it is Initializing, Ready or Terminating.
Pinecone: Describe Import
Check one import: status (Pending, InProgress, Failed, Completed or Cancelled), percent complete, records imported so far, and any error message. Poll this after Pinecone: Start Import.
Pinecone: Describe Index
Get one index's full configuration and deployment status: dimension, metric, vector type, spec, tags, deletion protection, any integrated embedding model, and the data-plane host at data.host. Poll this after creating or reconfiguring an index until data.status.ready is true.
Pinecone: Describe Index Stats
Count what is actually in an index: total vectors, dimension, metric, and a per-namespace vector count. Note that data.namespaces is a MAP keyed by namespace name, not a list, so a specific namespace is read as data.namespaces.NAME.vectorCount. Index fullness is meaningful only for pod-based indexes; serverless indexes scale on their own.
Pinecone: Describe Namespace
Get one namespace's record count and its metadata schema, including which fields are indexed for filtering. Serverless indexes only.
Pinecone: Describe Restore Job
Check how far a restore has got: status, percent complete, the backup it came from, and the target index name. Poll this after Pinecone: Create Index From Backup until status is Completed.
Pinecone: Fetch Vectors By Id
Look up records by exact id, with their values and metadata. No similarity involved. Note that data.vectors is a MAP keyed by vector id, not a list, so one record is read as data.vectors.ID. If you only need metadata, Pinecone: Query Vectors with include_values false is often cheaper.
Pinecone: Fetch Vectors By Metadata
Pull records out by metadata filter rather than by id or similarity, paginated. Useful for auditing or re-processing everything tagged a certain way. Like the id fetch, data.vectors is a MAP keyed by vector id, not a list.
Pinecone: List Collections
List every collection in the project, with its size, record count, dimension and status. A collection is a static snapshot of a pod-based index that a new index can be created from. Serverless indexes do not support collections; they use backups instead.
Pinecone: List Imports
List recent and running import operations for one index, with each one's status, progress percentage and imported record count. Paginated.
Pinecone: List Index Backups
List the backups taken from one index. Same shape as the project-wide list, scoped to a single source index, which is what a restore workflow wants.
Pinecone: List Indexes
List every index in the project the API key belongs to, with each index's dimension, metric, deployment state and its data-plane host. This is the node every other Pinecone node leans on: the host it returns is what data-plane nodes need, and it is also the cheapest way to confirm a credential works.
Pinecone: List Namespaces
List the namespaces in one index, with each namespace's record count, in sorted order and paginated. This is the list-shaped namespace source: Pinecone: Describe Index Stats reports the same counts but as a map keyed by name. Serverless indexes only.
Pinecone: List Project Backups
List every backup in the project across all indexes, newest first, with each backup's source index, record count, size and status. Paginated: pass data.pagination.next back as the pagination token for the following page.
Pinecone: List Vector Ids
Page through the record ids in one namespace, in sorted order, optionally narrowed to a common prefix. This is how you enumerate a namespace without reading vectors. Serverless indexes only.
Pinecone: Query Vectors
The core similarity search. Give it a query vector (or the id of a vector already stored) and it returns the top_k nearest records in one namespace, each with a similarity score, and optionally their metadata and values. Reads nothing else and writes nothing.
Pinecone: Search Records
Search a namespace with plain text, with a vector, or by record id, and optionally rerank the results with a hosted reranking model for better ordering. Searching by text needs an index with integrated embedding; searching by vector or by id works on any index.
Action nodes 17
Pinecone: Cancel Import
Stop an import that is still running. Records already imported stay in the index, so this halts the job rather than rolling it back, and the import can simply be started again. Has no effect on an import that has already finished.
Pinecone: Configure Index
Change an existing index in place: scale read capacity or pod size and replicas, turn deletion protection on or off, edit tags, or attach an embedding configuration. Cloud, region, dimension and metric are fixed at creation and cannot be changed here. The call returns 202: check the index status to see when the change has landed.
Pinecone: Create Backup
Take a backup of an index. This is the only thing that makes Pinecone: Delete Index recoverable, so run it before any bulk rewrite or teardown. Backups are created asynchronously: poll Pinecone: Describe Backup until status is Ready. Restore with Pinecone: Create Index From Backup.
Pinecone: Create Collection
Snapshot a pod-based index into a new collection. The collection is static: it does not track later writes to the source index. Creation is asynchronous, so poll Pinecone: Describe Collection until status is Ready. Serverless indexes do not support collections.
Pinecone: Create Index
Create an index. The spec object decides where and how it is deployed. Creation is asynchronous: the response comes back with status.state Initializing, and the index only accepts vectors once Pinecone: Describe Index reports ready true. The response carries the new index's data-plane host at data.host.
Pinecone: Create Index From Backup
Restore a backup into a NEW index. The existing index is never touched and the new name must be free, so this is safe to run against production. The response returns a restore_job_id: feed it to Pinecone: Describe Restore Job to watch progress.
Pinecone: Create Index With Integrated Embedding
Create a serverless index that embeds text for you. Pinecone runs a hosted embedding model on write and on search, so you send text instead of vectors and use Pinecone: Upsert Text Records and Pinecone: Search Records against it. The embedding model cannot be changed after creation.
Pinecone: Create Namespace
Create an empty namespace explicitly. Usually unnecessary, since upserting into a new name creates it implicitly; the reason to use this node is to set the metadata schema up front so only the fields you name are indexed for filtering. Serverless indexes only.
Pinecone: Delete Backup
DESTRUCTIVE AND IRREVERSIBLE. Delete a backup. Anything the backup was the only remaining copy of becomes unrecoverable, which is exactly the situation a backup exists to prevent. Returns 202 with an empty body.
Pinecone: Delete Collection
DESTRUCTIVE AND IRREVERSIBLE. Delete a collection and the snapshot it holds. Indexes already created from it are unaffected, but no new index can be seeded from it again. Returns 202 with an empty body.
Pinecone: Delete Index
DESTRUCTIVE AND IRREVERSIBLE. Delete an index and every vector, namespace and piece of metadata inside it. There is no undo and no trash: the data is recoverable only from a backup taken beforehand. Refused while the index has deletion protection enabled. Returns 202 with an empty body.
Pinecone: Delete Namespace
DESTRUCTIVE AND IRREVERSIBLE. Delete a namespace and every record in it. Pinecone's own guidance is explicit that this cannot be undone and the data is permanently gone. The scope is the whole namespace, however many records that turns out to be. Serverless indexes only.
Pinecone: Delete Vectors
DESTRUCTIVE AND IRREVERSIBLE. Delete records from one namespace. With ids, it removes exactly those records. With delete_all true it WIPES THE ENTIRE NAMESPACE, and with a filter it removes every matching record; in both of those cases the blast radius is whatever happens to be in the index, not a list you checked. Nothing is recoverable without a backup. Run Pinecone: Update Vector with dry_run true to count what a filter matches before deleting by it.
Pinecone: Start Import
Kick off an asynchronous bulk load of Parquet files from object storage into an index. This is the path for large backfills that would take far too many upsert calls. Returns an import id immediately; follow it with Pinecone: Describe Import. The storage bucket must already be connected as a storage integration in the Pinecone console.
Pinecone: Update Vector
Change part of a record in place. OVERWRITES WHAT IT TOUCHES: values sent here replace the stored vector entirely, and each key in set_metadata replaces that key's stored value. Keys you do not send are left alone. Supplying a filter instead of an id applies the metadata change to EVERY matching record in the namespace, so run it once with dry_run true first and read the returned match count.
Pinecone: Upsert Text Records
Write TEXT into an index that has integrated embedding, and let Pinecone produce the vectors with its hosted model. No embedding step of your own is needed. OVERWRITES BY ID the same way the vector upsert does. Works only on indexes made with Pinecone: Create Index With Integrated Embedding.
Pinecone: Upsert Vectors
Write vectors into a namespace. OVERWRITES BY ID: if a record already exists at that id, its values and its metadata are replaced wholesale, with no error and no merge. Pinecone recommends batches of up to 1000 vectors per call. A namespace that does not exist yet is created implicitly.
Connecting Pinecone takes one credential
Pinecone authenticates every request, on the control plane and on each index's data plane alike, with an API key sent as the Api-Key header. Keys are created in the Pinecone console on the project's API keys page, and a key belongs to that one project: it addresses every index the project holds, which is why this connector never asks for a project id. Mattering also sends the X-Pinecone-Api-Version header on every call, pinned to the 2025-10 version the connector was built and sampled against, because Pinecone's versioning guide states that a request without that header falls back to the oldest supported stable version. Worth checking before you design a workflow around the whole catalog: your Pinecone plan decides which of these 35 nodes can run. Pinecone documents backups and restores as available on the Standard and Enterprise plans and not on Starter or Builder, and documents bulk imports from object storage as Standard and Enterprise only, which is 11 of the 35 nodes. The index, search, upsert, update, delete, namespace and text record nodes work on any plan that can create a serverless index. Pinecone's pricing page is the place to confirm what your project's plan includes.
Open the Pinecone console, select the project whose indexes you want to reach, and go to its API keys page. Create a key and copy the value.
In Mattering Automations, open Connectors, click Add Connector, choose Pinecone, and create a credential with that key.
Click Test Connection. Mattering calls Pinecone's index list endpoint on the control plane, which needs no parameters and no per-index host: a list, even an empty one, proves the credential, and a 401 with code UNAUTHENTICATED means the key is wrong or no longer valid.
All 35 Pinecone nodes appear in the canvas palette. Run Pinecone: List Indexes first. It returns each index's data-plane host, which is the value every vector node needs, and the index host picker on those nodes is filled straight from it.
Common uses for the Pinecone MCP
Retrieval that runs where the rest of the work runs
Pinecone: Query Vectors is the core similarity search: give it a query vector, or the id of a vector already stored, and it returns the nearest records in a namespace with their scores and optionally their metadata. Pinecone: Search Records does the same with plain text on an index that has integrated embedding, and can rerank the results with a hosted model for better ordering, where your Pinecone plan includes hosted reranking models. Because the search is a node rather than a script, the results flow straight into the next step: an agent's answer, a Mattering database row, a task with the matched documents attached, or a condition that decides whether a human sees it at all.
Keep an index in step with the source of truth
When a document changes, Pinecone: Upsert Vectors writes the new embedding at the same id and replaces what was there, values and metadata together. Pinecone: Update Vector is the narrower tool: it replaces the values you send and merges only the metadata keys you send, leaving the others alone, which is what you want for retagging rather than re-embedding. Pinecone: Delete Vectors removes the records a deletion in the source should remove. The pattern that keeps this calm is stated on the nodes themselves: an upsert overwrites by id with no error and no merge, so send the whole record you mean to store.
Text in, answers out, with no embedding step of your own
Pinecone: Create Index With Integrated Embedding creates a serverless index that runs a hosted embedding model for you on write and on search. After that, Pinecone: Upsert Text Records takes text rather than vectors and Pinecone: Search Records takes a query string, so a whole retrieval pipeline can exist without a separate embedding call anywhere in it. Two trades to know before you commit. Pinecone does not document a way to change the embedding model on an existing integrated index, so treat the model as a decision to make before the first write, and the text path works only on indexes created this way. Pinecone also documents that indexes with integrated embedding do not support updating or importing with text, so partial updates and bulk loads on those indexes stay on the vector-shaped nodes.
A backup habit that makes deletes survivable
Pinecone: Create Backup takes a snapshot of an index, and because backups are created asynchronously the workflow polls Pinecone: Describe Backup until the status reads Ready. Recovery goes the other way: Pinecone: Create Index From Backup restores into a NEW index, never touching the existing one, and returns a restore job id that Pinecone: Describe Restore Job tracks to completion. Put the backup in front of every bulk rewrite and every teardown and the five destructive nodes stop being the scariest thing on the canvas. Pinecone: List Project Backups and Pinecone: List Index Backups keep the inventory honest. Two conditions on this pattern. Pinecone documents backups and restores on the Standard and Enterprise plans and not on Starter or Builder, so check your plan before you build a workflow that depends on them. And Pinecone documents that a backup only includes vectors that were in the index at least 15 minutes before the backup time, so a snapshot taken the instant a write finishes will not carry that write: leave a gap, or take the snapshot before the writing starts.
Backfill millions of records without a million calls
Pinecone: Start Import kicks off an asynchronous bulk load of Parquet files from object storage into an index, which is the sane path for a first load or a full rebuild that would otherwise be an enormous number of upsert calls. Pinecone: Describe Import reports status, percent complete and records imported, Pinecone: List Imports shows what is running, and Pinecone: Cancel Import halts a job in flight. Cancelling is not a rollback: Pinecone documents the status moving to Cancelled but documents no undo, so treat a cancelled import as partial rather than undone, and check what actually landed before starting it again. One prerequisite can live outside the API, which the node says out loud: a secure data source has to be connected as a storage integration in the Pinecone console first, while a public bucket needs no integration. Plan matters here too, because Pinecone documents bulk imports as available on the Standard and Enterprise plans.
Inventory and drift reporting for a fleet of indexes
Pinecone: List Indexes gives every index in the project with its dimension, metric, deployment state and host, Pinecone: Describe Index adds the full configuration, and Pinecone: Describe Index Stats counts what is actually stored, per namespace. Pinecone: List Namespaces and Pinecone: Describe Namespace go a level deeper on serverless indexes, including which metadata fields are indexed for filtering, and Pinecone: List Vector Ids enumerates a namespace without reading the vectors back. A scheduled sweep can write all of it into a Mattering database and open a task when a record count moves further than a rebuild should have moved it.
Example: A nightly re-index that cannot lose what it replaces
Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.
Trigger: a nightly schedule fires, and a database or HTTP node pulls the documents that changed since the last run.
Pinecone: Create Backup snapshots the live index before anything is written, and Pinecone: Describe Backup is polled until the status reads Ready, so the rest of the run has a recovery path. Timing matters: Pinecone documents that a backup only includes vectors that were in the index at least 15 minutes before the backup time, so if the previous run wrote recently, leave that gap before snapshotting. This step needs a Standard or Enterprise plan, since Pinecone does not offer backups on Starter or Builder.
An embedding node turns each changed document into a vector, and Pinecone: Upsert Vectors writes them into the namespace in batches, overwriting by id. Pinecone's guidance is a batch as large as you can make it, up to 1000 records, without exceeding the 2 MB maximum request size, and with vectors of any real width that size ceiling is usually what binds first. Text record upserts are capped lower, at 96 records per call.
Pinecone: Update Vector runs once with dry run set to true against the metadata filter for retired documents, and the returned match count goes into a condition: a number in the expected range continues, anything larger stops the run and opens a task.
Pinecone: Delete Vectors removes the retired ids once the count checks out, which is the only irreversible step in the workflow and the reason the backup came first.
Pinecone: Describe Index Stats reads the namespace back, the totals land in a Mattering database next to last night's, and a task opens for a person only if the delta looks wrong.
Pinecone MCP questions, answered
What Pinecone operations are supported?
35 nodes on Pinecone API version 2025-10: 18 read nodes and 17 action nodes. On the control plane, indexes (list, describe, create, create with integrated embedding, configure, delete), collections (list, describe, create, delete), and backups and restores (list by project, list by index, create, describe, delete, create an index from a backup, and describe the restore job). On the data plane, index statistics, similarity search, fetch by id, fetch by metadata filter, vector id listing, upsert, update, delete, namespaces (list, create, describe, delete), text records with integrated embedding and search, and bulk imports (start, list, describe, cancel). Deliberately not included: Pinecone's separate Inference, Assistant, and Admin surfaces, which are different APIs with their own catalogs and auth models.
Does this work with Claude, ChatGPT, or other AI assistants?
Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.
Why do the vector nodes ask for an index host when I already connected a credential?
Because Pinecone splits its API across two hosts. Index and backup operations go to one global control-plane address, but every vector operation goes to that specific index's own host, which Pinecone returns from the console or the API rather than following a pattern you can assemble yourself. A single API key routinely addresses many indexes, so the host cannot live on the credential without forcing one connection per index. It is a per-node field instead, and it is a picker: it lists your indexes by name from Pinecone: List Indexes and saves the host that lister already returned. You pick a name, not an address, and the connector never invents a hostname.
Do I need a separate credential for each index or project?
One credential per Pinecone project. A Pinecone API key is scoped to a project, so the key selects the project and Pinecone: List Indexes returns that project's indexes, which is why the connector asks for no project id anywhere. If you keep production and staging in separate Pinecone projects, connect a credential for each, and select the right one on the nodes. Within one project, a single credential covers every index; the index host field is what picks between them.
Can an AI agent delete my vectors by accident?
The five destructive nodes are flagged as destructive so you can gate them: Pinecone: Delete Index, Pinecone: Delete Namespace, Pinecone: Delete Vectors, Pinecone: Delete Collection, and Pinecone: Delete Backup. Nothing Pinecone deletes goes to a trash, so the honest guardrails are structural rather than hopeful. Keep agents on the read nodes and the upsert nodes, put deletes behind a condition or an approval task, run Pinecone: Create Backup before any bulk rewrite, and use the dry run flag on Pinecone: Update Vector to count what a metadata filter matches before anything acts on that filter. Deleting a backup is worth its own thought: it removes the recovery path for everything above it. If your project is on Starter or Builder, note that Pinecone does not offer backups there, so the gating has to carry more weight: keep the deletes behind an approval, and know that recovery means reloading from your source of truth.
Does it embed text for me, or do I bring my own vectors?
Both work. Bring your own vectors and Pinecone: Upsert Vectors and Pinecone: Query Vectors take arrays of floats, so an embedding node upstream (or any model you already use) feeds straight in. Or create the index with Pinecone: Create Index With Integrated Embedding and Pinecone runs a hosted embedding model itself, at which point Pinecone: Upsert Text Records takes text and Pinecone: Search Records takes a query string. The integrated path is chosen at index creation, and Pinecone does not document a way to change the model on an existing integrated index, so treat it as a decision to make before the first write rather than a switch to flip later. Pinecone also documents that indexes with integrated embedding do not support updating or importing with text, so on those indexes partial updates and bulk loads stay on the vector-shaped nodes.
Does the connector work with pod-based indexes as well as serverless?
Mostly, and the exceptions are Pinecone's rather than ours, so the nodes say which is which. Namespace operations (Pinecone: List Namespaces, Pinecone: Create Namespace, Pinecone: Describe Namespace, Pinecone: Delete Namespace) and Pinecone: List Vector Ids are documented as serverless only, so on a pod-based index they will not run and the namespace picker on other nodes will not populate. Collections are the mirror image: a collection is a static snapshot of a POD-BASED index, and serverless indexes do not support them. On serverless, the backup nodes are the snapshot mechanism, on the plans where Pinecone offers them, which is Standard and Enterprise rather than Starter or Builder. Both families are built, so whichever kind of index you have, the right half is there. Most readers will be on serverless either way: Pinecone documents that customers who signed up for Standard or Enterprise on or after 18 August 2025 cannot create pod-based indexes at all.
Which Pinecone API version does the connector use?
2025-10, pinned. Pinecone versions its API by release date, and Mattering sends the X-Pinecone-Api-Version header on every call with that value. The header is not something you can safely leave off: Pinecone's versioning guide states that a request without it falls back to the oldest supported stable version, so pinning is what keeps the connector on a known API shape rather than on whatever the oldest supported version happens to be. The connector was researched and sampled against that version's published OpenAPI specifications, and moving it forward means re-sampling rather than editing a number. Plan for that as maintenance rather than a one-off: Pinecone releases a stable version quarterly and supports each one for a minimum of twelve months, so a pinned version needs re-sampling onto a newer one periodically.
Pinecone publishes its own MCP server. Why use this connector?
Pinecone does, and for some jobs its server is the better answer. Pinecone ships a developer MCP server, published as @pinecone-database/mcp and run locally in your own editor or client config, with nine tools: search-docs, list-indexes, describe-index, describe-index-stats, create-index-for-model, upsert-records, search-records, cascading-search and rerank-documents. Pinecone also runs a dedicated MCP server for each Pinecone Assistant. Those tools are shaped for a developer writing Pinecone code, and if that is what you are doing, use Pinecone's server. This connector is shaped for operations instead: 35 nodes across both planes, including namespaces, deletes, backups and restores, and bulk imports, usable as steps on an automation canvas as well as over MCP, with the credential held once in the workspace rather than in each developer's local config, and the destructive nodes flagged so you can gate them.
Put Pinecone to work inside your workspace
Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.
All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Pinecone is a product of its respective owner; Mattering is an independent platform.