> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to Pinecone

The Pinecone connector lets your AI agent act in each user's Pinecone account. Each user connects their own Pinecone API key once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 22 tools.

**Authentication:** API Key
**Categories:** Databases, AI
**Tools:** 22: 12 read, 7 write, 3 destructive
**Users sign in with:** API key
**Built by:** Scalekit connector
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=PINECONE)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Pinecone connection

   In **AgentKit > Connections**, create a Pinecone connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'pinecone'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Pinecone:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'pinecone_index_stats_get',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "pinecone"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Pinecone:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="pinecone_index_stats_get",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user opens the link once and enters their Pinecone credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'pinecone_index_get',
  toolInput: {
    index_name: '<index_name>',
  },
  connector: 'pinecone',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="pinecone_index_get",
    tool_input={
        "index_name": "<index_name>",
    },
    connection_name="pinecone",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `pinecone_index_get`

Get Index · Read-only

Get the configuration and status of one Pinecone index by name.
Returns the index host and private host, status (ready, state), deployment, schema (fields with their dimension, metric or embedding model), read capacity, deletion protection and tags.
Use this to check that a new index is ready or to read its host. Use pinecone_index_stats_get for record counts per namespace.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `index_name` (`string`, required): Name of the Pinecone index to describe, as returned by pinecone_indexes_list. Example: docs-example

Example input: `{"index_name":"<index_name>"}`

### `pinecone_index_stats_get`

Get Index Stats · Read-only

Get record statistics for the Pinecone index on the connected account's index host.
Returns the total record count, the record count per namespace, the dimension, the index fullness and the metric.
Use this to see how much data each namespace holds. Use pinecone_index_get for configuration and pinecone_namespaces_list to page through many namespaces.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `filter` (`object`, optional): Metadata filter that limits the counted records (pod-based indexes only; serverless indexes reject a filter), written in Pinecone's filter language: a field name maps to a value or to an operator object such as $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin or $exists, and $and / $or combine conditions. Example: {"genre": {"$eq": "documentary"}, "year": {"$gte": 2020}}

Example input: `{}`

### `pinecone_indexes_list`

List Indexes · Read-only

List every index in the Pinecone project that the API key belongs to.
Returns each index's name, host, status (ready or not), deployment (cloud, region), schema, deletion protection and tags.
Use this to find an index name or its data-plane host. Use pinecone_index_get when you already know the index name.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `pinecone_model_get`

Get Model · Read-only

Get the details of one Pinecone-hosted embedding or reranking model by name.
Returns its type, vector type, default and supported dimensions, metrics, maximum sequence length and batch size, and supported parameters.
Use this to check a model's limits and parameters before calling it. Use pinecone_models_list to see all models.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `model_name` (`string`, required): Name of the hosted model. Example: llama-text-embed-v2

Example input: `{"model_name":"<model_name>"}`

### `pinecone_models_list`

List Models · Read-only

List the embedding and reranking models Pinecone hosts, optionally only one type.
Returns each model's name, type, vector type, supported dimensions and metrics, token limits and parameters.
Use this to pick a model for pinecone_embeddings_generate, pinecone_documents_rerank or pinecone_index_create_for_model. Use pinecone_model_get for one model.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `type` (`string`, optional): Only list models of this type: embed or rerank. Example: embed. One of: `embed`, `rerank`.
- `vector_type` (`string`, optional): With type embed, only list models that produce this vector type: dense or sparse. Example: dense. One of: `dense`, `sparse`.

Example input: `{}`

### `pinecone_namespace_get`

Get Namespace · Read-only

Get one namespace of the Pinecone index on the connected account by name.
Returns the namespace name, its record count and its schema of indexed metadata fields when one is set.
Use this to check how many records a namespace holds. Use pinecone_namespaces_list to find namespace names. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `namespace` (`string`, required): Name of the namespace. Use __default__ for the default namespace. Example: example-namespace

Example input: `{"namespace":"<namespace>"}`

### `pinecone_namespaces_list`

List Namespaces · Read-only

List the namespaces in the Pinecone index on the connected account, optionally only those starting with a prefix.
Returns each namespace's name and record count, the total count and a pagination token.
Use this to find namespace names for the vector and record tools. Use pinecone_namespace_get for one namespace. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `limit` (`integer`, optional): Maximum number of namespaces to return, from 1 to 100. Defaults to 100. Example: 50
- `pagination_token` (`string`, optional): Token for the next page of namespaces, taken from pagination.next in the previous response. Leave empty for the first page. Example: Tm90aGluZyB0byBzZWUgaGVyZQo=
- `prefix` (`string`, optional): Only return namespaces whose name starts with this text. Example: customer-

Example input: `{}`

### `pinecone_records_search`

Search Records · Read-only

Search a namespace of an integrated-embedding Pinecone index with plain text, which Pinecone embeds with the index's model, and optionally rerank the hits.
Returns the hits with _id, _score and the requested fields, plus usage counts.
Use this for indexes made with pinecone_index_create_for_model. Use pinecone_vectors_query when you supply your own query vector. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `namespace` (`string`, required): Namespace to search. Use __default__ for the default namespace. Example: example-namespace
- `top_k` (`integer`, required): Number of hits to return, from 1 to 10000. Example: 10
- `fields` (`array`, optional): Record fields to return with each hit. All fields are returned when empty. Example: ["chunk_text", "category"]
- `filter` (`object`, optional): Metadata filter that limits the hits, written in Pinecone's filter language: a field name maps to a value or to an operator object such as $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin or $exists, and $and / $or combine conditions. Example: {"genre": {"$eq": "documentary"}, "year": {"$gte": 2020}}
- `id` (`string`, optional): ID of a record in the index whose vector is used as the query instead of text. Example: rec1
- `query_text` (`string`, optional): The search text, embedded with the index's model. Give query_text, query_vector or id. Example: Famous historical structures and monuments
- `query_vector` (`array`, optional): A dense query vector to search with instead of text, matching the index dimension. Example: [0.1, 0.2, 0.3]
- `rerank_fields` (`array`, optional): With rerank_model: the record fields the reranker reads; every hit must contain them. Required when rerank_model is set. Example: ["chunk_text"]
- `rerank_model` (`string`, optional): Hosted reranking model that reorders the hits by relevance, as listed by pinecone_models_list with type rerank. Leave empty to skip reranking. Example: bge-reranker-v2-m3
- `rerank_query` (`string`, optional): With rerank_model: text to rerank against instead of query_text. Required when searching by query_vector or id. Example: Which monuments are in Paris?
- `rerank_top_n` (`integer`, optional): With rerank_model: how many hits to keep after reranking. Defaults to top_k. Example: 5

Example input: `{"namespace":"<namespace>","top_k":10}`

### `pinecone_vector_ids_list`

List Vector IDs · Read-only

List record IDs in a namespace of the Pinecone index on the connected account, optionally only those starting with a prefix.
Returns up to 100 IDs per page and a pagination token for the next page.
Use this to discover IDs, for example all chunks of one document when IDs look like doc1#chunk1. Then use pinecone_vectors_fetch to read them. Serverless indexes only. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `limit` (`integer`, optional): Maximum number of IDs to return, from 1 to 100. Defaults to 100. Example: 50
- `namespace` (`string`, optional): Namespace to list. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace
- `pagination_token` (`string`, optional): Token for the next page of IDs, taken from pagination.next in the previous response. Leave empty for the first page. Example: Tm90aGluZyB0byBzZWUgaGVyZQo=
- `prefix` (`string`, optional): Only return IDs that start with this text. Example: doc1#

Example input: `{}`

### `pinecone_vectors_fetch`

Fetch Vectors · Read-only

Fetch records by ID from a namespace of the Pinecone index on the connected account.
Returns a map of the found IDs to their vector values, sparse values and metadata; missing IDs are left out.
Use this when you know the IDs. Use pinecone_vectors_fetch_by_metadata to select records by metadata and pinecone_vector_ids_list to discover IDs. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `ids` (`array`, required): IDs of the records to fetch, 1 to 1000. Example: ["doc1#chunk1", "doc1#chunk2"]
- `namespace` (`string`, optional): Namespace to read from. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace

Example input: `{"ids":["doc1#chunk1","doc1#chunk2"]}`

### `pinecone_vectors_fetch_by_metadata`

Fetch Vectors by Metadata · Read-only

Fetch the records whose metadata matches a filter from a namespace of the Pinecone index on the connected account.
Returns the matching records with their values and metadata, plus a pagination token when more remain.
Use this to read every record with a given metadata value. Use pinecone_vectors_fetch for known IDs and pinecone_vectors_query for similarity search. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `filter` (`object`, required): Metadata filter that selects the records, written in Pinecone's filter language: a field name maps to a value or to an operator object such as $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin or $exists, and $and / $or combine conditions. Example: {"genre": {"$in": ["comedy", "drama"]}}
- `limit` (`integer`, optional): Maximum number of records to return in this page. Pinecone returns 100 when empty. Example: 50
- `namespace` (`string`, optional): Namespace to read from. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace
- `pagination_token` (`string`, optional): Token for the next page of records, taken from pagination.next in the previous response. Leave empty for the first page. Example: Tm90aGluZyB0byBzZWUgaGVyZQo=

Example input: `{"filter":{}}`

### `pinecone_vectors_query`

Query Vectors · Read-only

Find the records most similar to a query vector, or to an existing record's vector, in a namespace of the Pinecone index on the connected account.
Returns the top matches with id, similarity score and, if requested, metadata and vector values.
Use this for similarity search with your own embeddings. Use pinecone_records_search to search an integrated-embedding index with plain text, and pinecone_vectors_fetch to read records by ID. Runs against the index host saved on the connected account.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `top_k` (`integer`, required): Number of matches to return, from 1 to 10000. Example: 10
- `filter` (`object`, optional): Metadata filter that limits the matches, written in Pinecone's filter language: a field name maps to a value or to an operator object such as $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin or $exists, and $and / $or combine conditions. Example: {"genre": {"$eq": "documentary"}, "year": {"$gte": 2020}}
- `id` (`string`, optional): ID of a record already in the index whose vector is used as the query. Cannot be combined with vector or sparse_vector. Example: doc1#chunk1
- `include_metadata` (`boolean`, optional): Set to true to return each match's metadata. Defaults to false. Example: true
- `include_values` (`boolean`, optional): Set to true to return each match's vector values. Defaults to false; leave it off unless you need the vectors, as it slows the query. Example: false
- `namespace` (`string`, optional): Namespace to search. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace
- `sparse_vector` (`object`, optional): Sparse query vector for sparse or hybrid search, as indices and values lists of equal length. Example: {"indices": [10, 45], "values": [0.5, 0.3]}
- `vector` (`array`, optional): The dense query vector, a list of numbers with the same length as the index dimension. Give either vector (optionally with sparse_vector) or id, not both. Example: [0.1, 0.2, 0.3]

Example input: `{"top_k":10}`

### `pinecone_documents_rerank`

Rerank Documents · Write

Reorder a list of documents by relevance to a query with a Pinecone-hosted reranking model.
Returns the documents sorted by relevance score, each with its original index, score and (by default) the document itself, plus rerank usage.
Use this to improve results you already have from any source. Use pinecone_records_search with rerank_model to search and rerank in one call. Uses Pinecone rerank units.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `documents` (`array`, required): The documents to rerank, each an object of string fields; by default the text field is ranked. Example: [{"id": "vec1", "text": "Paris is the capital of France."}, {"id": "vec2", "text": "Berlin is the capital of Germany."}]
- `model` (`string`, required): Hosted reranking model, as listed by pinecone_models_list with type rerank. Example: bge-reranker-v2-m3
- `query` (`string`, required): The query to rank the documents against. Example: What is the capital of France?
- `parameters` (`object`, optional): Model-specific parameters such as truncate. Example: {"truncate": "END"}
- `rank_fields` (`array`, optional): Document fields the model reads when ranking. Defaults to ["text"]; how many fields are allowed depends on the model. Example: ["text"]
- `return_documents` (`boolean`, optional): Set to false to return only indexes and scores without the documents. Defaults to true. Example: false
- `top_n` (`integer`, optional): Number of top documents to return. Defaults to all documents. Example: 3

Example input: `{"documents":[{"id":"vec1","text":"Paris is the capital of France."},{"id":"vec2","text":"Berlin is the capital of Germany."}],"model":"<model>","query":"<query>"}`

### `pinecone_embeddings_generate`

Generate Embeddings · Write

Convert text to vector embeddings with a Pinecone-hosted embedding model.
Returns one embedding per input, in input order (dense values, or sparse indices and values), plus the model, vector type and token usage.
Use this to embed text before pinecone_vectors_upsert or pinecone_vectors_query. Use pinecone_records_search to let an integrated-embedding index embed for you. Uses Pinecone inference tokens.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `model` (`string`, required): Hosted embedding model, as listed by pinecone_models_list with type embed. Example: llama-text-embed-v2
- `texts` (`array`, required): The texts to embed, one embedding per text. Example: ["Apple is a popular fruit known for its sweetness."]
- `input_type` (`string`, optional): Whether the texts are documents to store (passage) or search queries (query); most models need it. Example: passage. One of: `passage`, `query`.
- `parameters` (`object`, optional): Other model-specific parameters, such as truncate (END or NONE) or dimension for models that support several. Example: {"truncate": "END"}

Example input: `{"model":"<model>","texts":["Apple is a popular fruit known for its sweetness."]}`

### `pinecone_index_configure`

Configure Index · Write

Change settings of an existing Pinecone index: deletion protection, tags, read capacity, or replicas and pod type for a pod-based index.
Returns the updated index configuration.
Use this to turn deletion protection off before pinecone_index_delete or to retag an index. Fields you leave empty keep their current value.

Read only: no. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `index_name` (`string`, required): Name of the Pinecone index to configure, as returned by pinecone_indexes_list. Example: docs-example
- `deletion_protection` (`string`, optional): Whether deletion protection is on for the index. enabled blocks pinecone_index_delete until it is set back to disabled. Example: enabled. One of: `disabled`, `enabled`.
- `deployment` (`object`, optional): Pod-based indexes only: new replicas count and or pod_type (s1, p1 or p2 with a size suffix x1, x2, x4 or x8). Cloud, region and deployment type cannot change. Example: {"replicas": 2, "pod_type": "p1.x2"}
- `read_capacity` (`object`, optional): Read capacity mode for the index. Use {"mode": "OnDemand"} (the default) for usage-based reads, or {"mode": "Dedicated", "dedicated": {...}} to allocate dedicated read nodes, giving the node type, scaling mode and manual replica and shard counts. Example: {"mode": "OnDemand"}
- `tags` (`object`, optional): Custom tags for the index as an object of string keys and string values, at most 20. Keys are up to 80 characters (letters, digits, _ or -); values are up to 120 printable ASCII characters. Set a value to an empty string to remove that tag. Example: {"team": "search", "env": "prod"}

Example input: `{"index_name":"<index_name>"}`

### `pinecone_index_create`

Create Index · Write

Create a serverless Pinecone index from a schema of dense vector, sparse vector and text fields.
Returns the new index's name, host, status, deployment and schema; the index is usable once status.ready is true.
Use this for a classic vector index whose vector field is named _values, which you then fill with pinecone_vectors_upsert. A full-text field, an embed field or a vector field under any other name makes a document index, which pinecone_vectors_upsert, pinecone_vectors_query and pinecone_records_search reject, and this connector has no document tool. Use pinecone_index_create_for_model for an index that embeds text with a hosted model and is searched with pinecone_records_search.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `schema` (`object`, required): The fields the index searches over, as an object with a fields map from field name to field configuration. For a classic vector index that works with the vector tools, declare the reserved _values field as a dense vector with its dimension and metric (cosine, dotproduct or euclidean). Other field types are sparse_vector and string (with full_text_search, embed or sparse_embed). Example: {"fields": {"_values": {"type": "dense_vector", "dimension": 1536, "metric": "cosine"}}}
- `deletion_protection` (`string`, optional): Whether deletion protection is on for the index. enabled blocks pinecone_index_delete until it is set back to disabled. Example: enabled. One of: `disabled`, `enabled`.
- `deployment` (`object`, optional): Where the index runs. For a serverless index give deployment_type managed with a cloud (aws, gcp or azure) and a region. Defaults to managed on aws us-east-1 when empty. Example: {"deployment_type": "managed", "cloud": "aws", "region": "us-east-1"}
- `name` (`string`, optional): Name for the new index, unique in the project: 1 to 45 lowercase letters, digits or hyphens, starting and ending with a letter or digit. Pinecone generates one if left empty. Example: docs-example
- `read_capacity` (`object`, optional): Read capacity mode for the index. Use {"mode": "OnDemand"} (the default) for usage-based reads, or {"mode": "Dedicated", "dedicated": {...}} to allocate dedicated read nodes, giving the node type, scaling mode and manual replica and shard counts. Example: {"mode": "OnDemand"}
- `tags` (`object`, optional): Custom tags for the index as an object of string keys and string values, at most 20. Keys are up to 80 characters (letters, digits, _ or -); values are up to 120 printable ASCII characters. Set a value to an empty string to remove that tag. Example: {"team": "search", "env": "prod"}

Example input: `{"schema":{}}`

### `pinecone_index_create_for_model`

Create Index for Embedding Model · Write

Create a serverless Pinecone index with integrated embedding, so Pinecone converts a text field to vectors with a hosted model.
Returns the new index's name, host, status, embedding settings and deletion protection; the index is usable once status.ready is true.
Use this when you want to search with plain text through pinecone_records_search. Use pinecone_index_create for an index you fill with your own vectors.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `cloud` (`string`, required): Public cloud that hosts the index: aws, gcp or azure. Example: aws. One of: `aws`, `gcp`, `azure`.
- `field_map` (`object`, required): Which field of your records holds the text to embed, as an object whose text key names that field. Cannot be changed later. Example: {"text": "chunk_text"}
- `model` (`string`, required): Name of the hosted embedding model that embeds the text field, as listed by pinecone_models_list with type embed. Cannot be changed later. Example: llama-text-embed-v2
- `name` (`string`, required): Name for the new index, unique in the project: 1 to 45 lowercase letters, digits or hyphens, starting and ending with a letter or digit. Example: docs-example
- `region` (`string`, required): Cloud region for the index, which must be a region Pinecone supports for that cloud. Example: us-east-1
- `deletion_protection` (`string`, optional): Whether deletion protection is on for the index. enabled blocks pinecone_index_delete until it is set back to disabled. Example: enabled. One of: `disabled`, `enabled`.
- `dimension` (`integer`, optional): Dimension of the vectors the model produces, for models that support more than one. Defaults to the model's default dimension when empty. Example: 1024
- `metric` (`string`, optional): Distance metric for similarity search: cosine, euclidean or dotproduct. Defaults to the model's own metric when empty. Example: cosine. One of: `cosine`, `euclidean`, `dotproduct`.
- `tags` (`object`, optional): Custom tags for the index as an object of string keys and string values, at most 20. Keys are up to 80 characters (letters, digits, _ or -); values are up to 120 printable ASCII characters. Set a value to an empty string to remove that tag. Example: {"team": "search", "env": "prod"}

Example input: `{"cloud":"aws","field_map":{"text":"chunk_text"},"model":"<model>","name":"<name>","region":"<region>"}`

### `pinecone_vector_update`

Update Vector · Write

Update one record by ID, or the metadata of every record matching a filter, in a namespace of the Pinecone index on the connected account.
Returns matchedRecords, the number of records the update applied to (or would apply to on a dry run).
Use this to replace a record's values or merge new metadata fields without rewriting it. Use pinecone_vectors_upsert to write whole records. Runs against the index host saved on the connected account.

Read only: no. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `dry_run` (`boolean`, optional): With a filter, set to true to only count the records that match without updating them. Defaults to false. Example: true
- `filter` (`object`, optional): Metadata filter that limits which records get set_metadata, instead of a single id, written in Pinecone's filter language: a field name maps to a value or to an operator object such as $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin or $exists, and $and / $or combine conditions. Example: {"genre": {"$eq": "documentary"}, "year": {"$gte": 2020}}
- `id` (`string`, optional): ID of the record to update. Give either id or filter. Example: doc1#chunk1
- `namespace` (`string`, optional): Namespace that holds the record. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace
- `set_metadata` (`object`, optional): Metadata fields to set; they are merged into the existing metadata, overwriting fields with the same name. Field names cannot start with $. Example: {"genre": "comedy", "year": 2024}
- `sparse_values` (`object`, optional): New sparse vector for the record given by id, as indices and values lists of equal length. Example: {"indices": [10, 45], "values": [0.5, 0.3]}
- `values` (`array`, optional): New dense vector values for the record given by id, matching the index dimension. Example: [0.1, 0.2, 0.3]

Example input: `{}`

### `pinecone_vectors_upsert`

Upsert Vectors · Write

Write vectors to a namespace of the Pinecone index on the connected account, replacing any record with the same ID.
Returns upsertedCount, the number of vectors written.
Use this when you already have embeddings, for example from pinecone_embeddings_generate. Use pinecone_vector_update to change one field of an existing record. Runs against the index host saved on the connected account.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `vectors` (`array`, required): The vectors to write, up to 1000 per call. Each needs a unique id and either dense values (a list of numbers matching the index dimension) or sparseValues (indices and values lists of equal length), and may carry a metadata object of filterable fields. Example: [{"id": "doc1#chunk1", "values": [0.1, 0.2, 0.3], "metadata": {"genre": "documentary"}}]
- `namespace` (`string`, optional): Namespace to write to. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace

Example input: `{"vectors":[]}`

### `pinecone_index_delete`

Delete Index · Destructive

Permanently delete a Pinecone index and every record in it.
Returns an empty response once Pinecone accepts the request; deletion finishes in the background.
Fails while deletion protection is enabled; turn it off first with pinecone_index_configure. Use pinecone_namespace_delete or pinecone_vectors_delete to remove only some data.

Read only: no. Destructive: yes. Idempotent (safe to retry): yes.

Inputs:

- `index_name` (`string`, required): Name of the Pinecone index to delete, as returned by pinecone_indexes_list. Example: docs-example

Example input: `{"index_name":"<index_name>"}`

### `pinecone_namespace_delete`

Delete Namespace · Destructive

Permanently delete a namespace and every record in it from the Pinecone index on the connected account.
Returns an empty object on success.
Use this to drop all of one tenant's or dataset's data at once. Use pinecone_vectors_delete to remove only some records. Runs against the index host saved on the connected account.

Read only: no. Destructive: yes. Idempotent (safe to retry): yes.

Inputs:

- `namespace` (`string`, required): Name of the namespace to delete. Example: example-namespace

Example input: `{"namespace":"<namespace>"}`

### `pinecone_vectors_delete`

Delete Vectors · Destructive

Delete records from a namespace of the Pinecone index on the connected account, by ID, by metadata filter, or all of them.
Returns an empty object on success.
Use this to remove specific records. Use pinecone_namespace_delete to drop a whole namespace and pinecone_index_delete to drop the index. Runs against the index host saved on the connected account.

Read only: no. Destructive: yes. Idempotent (safe to retry): yes.

Inputs:

- `delete_all` (`boolean`, optional): Set to true to delete every record in the namespace. Cannot be combined with ids or filter. Example: true
- `filter` (`object`, optional): Metadata filter that limits which records are deleted, written in Pinecone's filter language: a field name maps to a value or to an operator object such as $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin or $exists, and $and / $or combine conditions. Example: {"genre": {"$eq": "documentary"}, "year": {"$gte": 2020}}
- `ids` (`array`, optional): IDs of the records to delete, up to 1000. Give exactly one of ids, filter or delete_all. Example: ["doc1#chunk1", "doc1#chunk2"]
- `namespace` (`string`, optional): Namespace to delete from. Leave empty to use the index's default namespace. Namespaces are listed by pinecone_namespaces_list. Example: example-namespace

Example input: `{}`

## Related

Other Databases connectors ([all 39](/agentkit/connectors/?category=databases)):

- [AWS Redshift](/agentkit/connectors/redshift/): Scalekit connector, Trusted identity provider, 10 tools
- [Google BigQuery](/agentkit/connectors/bigquery/): Scalekit connector, OAuth, 47 tools
- [Airtable](/agentkit/connectors/airtable/): Scalekit connector, OAuth, 26 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |
