# Pinecone All-in-One Integration (`brilliant_gum/pinecone-integration`) Actor

Crawl websites, store datasets, run semantic searches, delete vectors, and check index stats — all in one actor. Uses Pinecone Integrated Inference by default — no OpenAI key needed. Bring your own Pinecone API key and start in minutes.

- **URL**: https://apify.com/brilliant\_gum/pinecone-integration.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** AI, Developer tools, Integrations
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / page crawled & stored

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Pinecone All-in-One Integration

![Pinecone All-in-One Integration](https://i.imgur.com/GIfR5UN.jpg)

The only Pinecone actor you'll ever need. Crawl websites, store datasets, run semantic searches, delete vectors, and check index stats — all from a single tool. No OpenAI key required.

---

### What You Get

Connect your Pinecone vector database to the web in minutes. Give us a URL (or a sitemap, or an existing dataset) and we handle everything: crawling, content extraction, chunking, embedding, and storage. Then search your data with natural language — right from the same actor.

**5 modes. 1 actor. Zero unnecessary API keys.**

---

### Features

#### 🔍 Crawl & Store
Point it at any website. The actor crawls pages with a real browser (Playwright), converts HTML to clean Markdown, splits content into smart chunks, and stores everything as vectors in your Pinecone index. Supports multiple start URLs and XML sitemaps.

#### 📦 Store Dataset
Already have data from another Apify scraper? Skip the crawl — load any dataset directly into Pinecone. Works with any actor output.

#### 🔎 Semantic Search
Ask questions in plain English. Get ranked results with scores, metadata, and full chunk text. Add metadata filters and optional reranking (BGE Reranker v2 M3 or Pinecone Rerank v0) for precision results.

#### 🗑️ Delete Vectors
Remove specific vectors by ID, wipe everything matching a metadata filter, or clear an entire namespace. Full control over your index.

#### 📊 Index Stats
Check dimensions, record count, metric type, and per-namespace breakdown instantly. No Pinecone Console needed.

---

### What You Need

#### Your Pinecone API Key (required)
This actor stores and retrieves data from **your** Pinecone index — you bring your own key.

1. Sign up for free at [app.pinecone.io](https://app.pinecone.io) — no credit card needed
2. Go to **API Keys** in the left sidebar
3. Copy your key and paste it into the `pineconeApiKey` field

> 💡 Pinecone's free plan includes 1 index and ~100,000 vectors — more than enough to get started.

#### OpenAI or Cohere Key (optional)
Only needed if you choose OpenAI or Cohere as your embedding provider. **With Pinecone Integrated Inference (the default), no extra API key is required at all.**

---

### Quick Start

#### Crawl a website and store in Pinecone

```json
{
    "mode": "crawl-and-store",
    "pineconeApiKey": "YOUR_PINECONE_API_KEY",
    "pineconeIndexName": "my-docs",
    "startUrls": [{ "url": "https://docs.example.com" }],
    "maxPages": 50,
    "embeddingProvider": "pinecone"
}
````

That's it. No OpenAI key. The index is created automatically.

#### Search your data

```json
{
    "mode": "query",
    "pineconeApiKey": "YOUR_PINECONE_API_KEY",
    "pineconeIndexName": "my-docs",
    "queryText": "How do I configure authentication?",
    "topK": 5
}
```

#### Store an existing Apify dataset

```json
{
    "mode": "store-dataset",
    "pineconeApiKey": "YOUR_PINECONE_API_KEY",
    "pineconeIndexName": "my-docs",
    "datasetId": "YOUR_DATASET_ID",
    "datasetFields": ["text"],
    "metadataFields": { "pageUrl": "url", "pageTitle": "title" }
}
```

#### Delete old vectors by URL

```json
{
    "mode": "delete",
    "pineconeApiKey": "YOUR_PINECONE_API_KEY",
    "pineconeIndexName": "my-docs",
    "deleteMode": "by-filter",
    "deleteFilter": { "url": { "$eq": "https://docs.example.com/old-page" } }
}
```

***

### Embedding Providers

| Provider | Extra Key Needed | Default Model | Cost |
|----------|:---------------:|---------------|------|
| **Pinecone** *(recommended)* | ❌ No | multilingual-e5-large | Included in Pinecone plan |
| OpenAI | ✅ Yes | text-embedding-3-small | ~$0.02 / 1M tokens |
| Cohere | ✅ Yes | embed-english-v3.0 | ~$0.10 / 1M tokens |

***

### Pricing

| Event | Price |
|-------|-------|
| Page crawled & stored in Pinecone | **$0.01** |
| Dataset item stored in Pinecone | **$0.005** |
| Semantic search query | **$0.02** |

> Delete and Index Stats modes are **free** — no charge for management operations.
>
> 💡 **Example:** Crawl 200 pages = **$2.00** · Run 50 searches = **$1.00**

***

### How We Compare

| Feature | Official Apify Integration | Other Actors | **This Actor** |
|---------|:---------:|:------:|:-----------:|
| Crawl + Store + Query + Delete + Stats | ❌ | ❌ | ✅ **5 modes** |
| No OpenAI key needed | ❌ | ❌ | ✅ |
| Semantic search built-in | ❌ | ❌ | ✅ |
| Delete by filter or ID | ❌ | ❌ | ✅ |
| Auto-create index | ❌ | Partial | ✅ |
| Dimension validation | ❌ | ❌ | ✅ |
| Reranking support | ❌ | ❌ | ✅ |
| Sitemap support | ❌ | ❌ | ✅ |

***

### Output

#### Crawl & Store / Store Dataset

Every chunk pushed to the dataset:

| Field | Description |
|-------|-------------|
| `vectorId` | Deterministic SHA-256 ID |
| `url` | Source page URL |
| `title` | Page title |
| `chunkIndex` | Chunk number |
| `totalChunks` | Total chunks from this page |
| `chunkText` | Full text content |
| `contentHash` | SHA-256 for change detection |
| `storedAt` | Timestamp |

#### Query

| Field | Description |
|-------|-------------|
| `id` | Vector ID |
| `score` | Relevance score (0–1) |
| `metadata` | Stored metadata + chunk text |

***

### Tips

- **Same URL = same vector ID.** Re-crawling overwrites the same vectors — safe to re-run anytime.
- **Large sites?** Use `sitemapUrl` to crawl complete websites from one XML sitemap.
- **Dynamic content?** `renderJavaScript: true` (default) handles React, Next.js, and SPAs.
- **Chaining scrapers?** Run any scraper first, then use `store-dataset` mode with its dataset ID.
- **Cost-free embeddings?** Keep `embeddingProvider: "pinecone"` — no extra API costs.

# Actor input Schema

## `mode` (type: `string`):

Operation mode: crawl-and-store (crawl URLs and store in Pinecone), store-dataset (store Apify dataset), query (semantic search), delete (remove vectors), index-stats (index info).

## `pineconeApiKey` (type: `string`):

Your Pinecone API key. Get it from https://app.pinecone.io/

## `pineconeIndexName` (type: `string`):

Name of the Pinecone index to use. Will be auto-created if it doesn't exist (when autoCreateIndex is enabled).

## `pineconeNamespace` (type: `string`):

Pinecone namespace to target. Leave empty for the default namespace.

## `startUrls` (type: `array`):

URLs to start crawling from. Supports direct URLs or request list sources.

## `sitemapUrl` (type: `string`):

URL to an XML sitemap. All URLs from the sitemap will be crawled.

## `maxPages` (type: `integer`):

Maximum number of pages to crawl.

## `maxDepth` (type: `integer`):

Maximum link depth to follow from start URLs. 0 = only start URLs.

## `contentSelector` (type: `string`):

CSS selectors for the main content area. Multiple selectors separated by commas. The first match is used.

## `excludeSelectors` (type: `array`):

CSS selectors for elements to remove before extracting content.

## `renderJavaScript` (type: `boolean`):

Use a headless browser to render JavaScript. Needed for SPAs and dynamic content.

## `proxyConfiguration` (type: `object`):

Proxy settings for crawling.

## `datasetId` (type: `string`):

Apify dataset ID or name to load data from.

## `datasetFields` (type: `array`):

Dataset fields to extract text from. Content from all specified fields is concatenated.

## `metadataFields` (type: `object`):

Map of dataset field names to Pinecone metadata keys. Example: {"pageUrl": "url", "pageTitle": "title"}

## `embeddingProvider` (type: `string`):

Which embedding provider to use. 'pinecone' uses Pinecone Integrated Inference (no extra API key needed!). 'openai' and 'cohere' require their respective API keys.

## `embeddingModel` (type: `string`):

Embedding model name. Leave empty for auto-selection: Pinecone → multilingual-e5-large, OpenAI → text-embedding-3-small, Cohere → embed-english-v3.0

## `embeddingsApiKey` (type: `string`):

API key for OpenAI or Cohere. Not needed when using Pinecone Integrated Inference.

## `pineconeCloud` (type: `string`):

Cloud provider for index creation (only used when auto-creating a new index).

## `pineconeRegion` (type: `string`):

Cloud region for index creation (only used when auto-creating a new index).

## `autoCreateIndex` (type: `boolean`):

Automatically create the Pinecone index if it doesn't exist.

## `chunkSize` (type: `integer`):

Maximum number of characters per text chunk.

## `chunkOverlap` (type: `integer`):

Number of overlapping characters between consecutive chunks.

## `prependContext` (type: `boolean`):

Prepend the page title and URL to each chunk for better search relevance.

## `queryText` (type: `string`):

The text to search for in your Pinecone index.

## `topK` (type: `integer`):

How many results to return.

## `metadataFilter` (type: `object`):

Pinecone metadata filter in JSON format. Example: {"url": {"$eq": "https://example.com"}}

## `includeMetadata` (type: `boolean`):

Include metadata in query results.

## `rerankModel` (type: `string`):

Optional reranking model to improve result relevance.

## `rerankTopN` (type: `integer`):

Number of results to return after reranking.

## `deleteMode` (type: `string`):

How to select vectors for deletion.

## `deleteIds` (type: `array`):

List of vector IDs to delete.

## `deleteFilter` (type: `object`):

Metadata filter for deletion in JSON format. Example: {"url": {"$eq": "https://example.com"}}

## Actor input object example

```json
{
  "mode": "crawl-and-store",
  "pineconeNamespace": "",
  "maxPages": 100,
  "maxDepth": 3,
  "contentSelector": "main, article, .content, .post, #content",
  "excludeSelectors": [
    "nav",
    "footer",
    "header",
    "aside",
    ".sidebar",
    ".menu",
    ".cookie",
    "script",
    "style",
    "noscript"
  ],
  "renderJavaScript": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "datasetFields": [
    "text"
  ],
  "metadataFields": {},
  "embeddingProvider": "pinecone",
  "embeddingModel": "",
  "pineconeCloud": "aws",
  "pineconeRegion": "us-east-1",
  "autoCreateIndex": true,
  "chunkSize": 2000,
  "chunkOverlap": 200,
  "prependContext": true,
  "topK": 10,
  "includeMetadata": true,
  "rerankModel": "none",
  "rerankTopN": 5
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "crawl-and-store"
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/pinecone-integration").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "mode": "crawl-and-store" }

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/pinecone-integration").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "crawl-and-store"
}' |
apify call brilliant_gum/pinecone-integration --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=brilliant_gum/pinecone-integration",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinecone All-in-One Integration",
        "description": "Crawl websites, store datasets, run semantic searches, delete vectors, and check index stats — all in one actor. Uses Pinecone Integrated Inference by default — no OpenAI key needed. Bring your own Pinecone API key and start in minutes.",
        "version": "1.0",
        "x-build-id": "bopn1XRJA3jNtnta9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/brilliant_gum~pinecone-integration/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-brilliant_gum-pinecone-integration",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/brilliant_gum~pinecone-integration/runs": {
            "post": {
                "operationId": "runs-sync-brilliant_gum-pinecone-integration",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/brilliant_gum~pinecone-integration/run-sync": {
            "post": {
                "operationId": "run-sync-brilliant_gum-pinecone-integration",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode",
                    "pineconeApiKey",
                    "pineconeIndexName"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "crawl-and-store",
                            "store-dataset",
                            "query",
                            "delete",
                            "index-stats"
                        ],
                        "type": "string",
                        "description": "Operation mode: crawl-and-store (crawl URLs and store in Pinecone), store-dataset (store Apify dataset), query (semantic search), delete (remove vectors), index-stats (index info).",
                        "default": "crawl-and-store"
                    },
                    "pineconeApiKey": {
                        "title": "Pinecone API Key",
                        "type": "string",
                        "description": "Your Pinecone API key. Get it from https://app.pinecone.io/"
                    },
                    "pineconeIndexName": {
                        "title": "Pinecone Index Name",
                        "type": "string",
                        "description": "Name of the Pinecone index to use. Will be auto-created if it doesn't exist (when autoCreateIndex is enabled)."
                    },
                    "pineconeNamespace": {
                        "title": "Namespace",
                        "type": "string",
                        "description": "Pinecone namespace to target. Leave empty for the default namespace.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start crawling from. Supports direct URLs or request list sources.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "sitemapUrl": {
                        "title": "Sitemap URL",
                        "type": "string",
                        "description": "URL to an XML sitemap. All URLs from the sitemap will be crawled."
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl.",
                        "default": 100
                    },
                    "maxDepth": {
                        "title": "Max Crawl Depth",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum link depth to follow from start URLs. 0 = only start URLs.",
                        "default": 3
                    },
                    "contentSelector": {
                        "title": "Content CSS Selector",
                        "type": "string",
                        "description": "CSS selectors for the main content area. Multiple selectors separated by commas. The first match is used.",
                        "default": "main, article, .content, .post, #content"
                    },
                    "excludeSelectors": {
                        "title": "Exclude CSS Selectors",
                        "type": "array",
                        "description": "CSS selectors for elements to remove before extracting content.",
                        "default": [
                            "nav",
                            "footer",
                            "header",
                            "aside",
                            ".sidebar",
                            ".menu",
                            ".cookie",
                            "script",
                            "style",
                            "noscript"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "renderJavaScript": {
                        "title": "Render JavaScript",
                        "type": "boolean",
                        "description": "Use a headless browser to render JavaScript. Needed for SPAs and dynamic content.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for crawling.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Apify dataset ID or name to load data from."
                    },
                    "datasetFields": {
                        "title": "Text Fields",
                        "type": "array",
                        "description": "Dataset fields to extract text from. Content from all specified fields is concatenated.",
                        "default": [
                            "text"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "metadataFields": {
                        "title": "Metadata Field Mapping",
                        "type": "object",
                        "description": "Map of dataset field names to Pinecone metadata keys. Example: {\"pageUrl\": \"url\", \"pageTitle\": \"title\"}",
                        "default": {}
                    },
                    "embeddingProvider": {
                        "title": "Embedding Provider",
                        "enum": [
                            "pinecone",
                            "openai",
                            "cohere"
                        ],
                        "type": "string",
                        "description": "Which embedding provider to use. 'pinecone' uses Pinecone Integrated Inference (no extra API key needed!). 'openai' and 'cohere' require their respective API keys.",
                        "default": "pinecone"
                    },
                    "embeddingModel": {
                        "title": "Embedding Model",
                        "type": "string",
                        "description": "Embedding model name. Leave empty for auto-selection: Pinecone → multilingual-e5-large, OpenAI → text-embedding-3-small, Cohere → embed-english-v3.0",
                        "default": ""
                    },
                    "embeddingsApiKey": {
                        "title": "Embeddings API Key",
                        "type": "string",
                        "description": "API key for OpenAI or Cohere. Not needed when using Pinecone Integrated Inference."
                    },
                    "pineconeCloud": {
                        "title": "Cloud Provider",
                        "enum": [
                            "aws",
                            "gcp",
                            "azure"
                        ],
                        "type": "string",
                        "description": "Cloud provider for index creation (only used when auto-creating a new index).",
                        "default": "aws"
                    },
                    "pineconeRegion": {
                        "title": "Cloud Region",
                        "type": "string",
                        "description": "Cloud region for index creation (only used when auto-creating a new index).",
                        "default": "us-east-1"
                    },
                    "autoCreateIndex": {
                        "title": "Auto-Create Index",
                        "type": "boolean",
                        "description": "Automatically create the Pinecone index if it doesn't exist.",
                        "default": true
                    },
                    "chunkSize": {
                        "title": "Chunk Size (chars)",
                        "minimum": 200,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of characters per text chunk.",
                        "default": 2000
                    },
                    "chunkOverlap": {
                        "title": "Chunk Overlap (chars)",
                        "minimum": 0,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Number of overlapping characters between consecutive chunks.",
                        "default": 200
                    },
                    "prependContext": {
                        "title": "Prepend Source Context",
                        "type": "boolean",
                        "description": "Prepend the page title and URL to each chunk for better search relevance.",
                        "default": true
                    },
                    "queryText": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "The text to search for in your Pinecone index."
                    },
                    "topK": {
                        "title": "Number of Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many results to return.",
                        "default": 10
                    },
                    "metadataFilter": {
                        "title": "Metadata Filter",
                        "type": "object",
                        "description": "Pinecone metadata filter in JSON format. Example: {\"url\": {\"$eq\": \"https://example.com\"}}"
                    },
                    "includeMetadata": {
                        "title": "Include Metadata",
                        "type": "boolean",
                        "description": "Include metadata in query results.",
                        "default": true
                    },
                    "rerankModel": {
                        "title": "Rerank Model",
                        "enum": [
                            "none",
                            "bge-reranker-v2-m3",
                            "pinecone-rerank-v0"
                        ],
                        "type": "string",
                        "description": "Optional reranking model to improve result relevance.",
                        "default": "none"
                    },
                    "rerankTopN": {
                        "title": "Results After Reranking",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of results to return after reranking.",
                        "default": 5
                    },
                    "deleteMode": {
                        "title": "Delete Mode",
                        "enum": [
                            "by-ids",
                            "by-filter",
                            "all-namespace"
                        ],
                        "type": "string",
                        "description": "How to select vectors for deletion."
                    },
                    "deleteIds": {
                        "title": "Vector IDs to Delete",
                        "type": "array",
                        "description": "List of vector IDs to delete.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "deleteFilter": {
                        "title": "Delete Filter",
                        "type": "object",
                        "description": "Metadata filter for deletion in JSON format. Example: {\"url\": {\"$eq\": \"https://example.com\"}}"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```