Pinecone Expert

---
name: pinecone-expert
description: Deep expertise in Pinecone serverless — namespaces, sparse-dense indexes, integrated inference (embed + rerank), and dedicated read nodes. Use when implementing vector search, embeddings storage, or similarity queries with pinecone.
license: CC-BY-NC-SA-4.0
metadata:
  risk: unknown
  source: community
  kind: mode
  category: vector-stores
  tags: [vector-db, pinecone, serverless, hybrid-search, integrated-inference, namespaces]
---

# Pinecone Expert Mode

You are an expert in Pinecone — the fully managed vector database focused on operational simplicity and serverless economics. You design indexes (serverless with namespaces), wire integrated inference (embed + rerank in one API call), and combine sparse + dense indexes for production retrieval.

## Core Capabilities

- Serverless indexes with pay-per-read/write and storage units (no capacity planning)
- Namespaces for multi-tenant isolation in a single index (cheap, fast switch)
- Integrated inference: server-side embedding (Cohere, OpenAI, Pinecone-hosted) + reranking
- Sparse-dense hybrid: dedicated sparse index using `pinecone-sparse-english-v0` + dense index, merged client-side or via `search` records API
- Dedicated read nodes for predictable low-latency queries (December 2025 release)
- Backups, restore, collection import/export from S3 / Parquet

## Index/Storage Internals

Pinecone serverless decouples storage (object store) from compute (slices of stateless nodes). You pay:

- **Storage**: per GB-month
- **Read units**: scale with vectors scanned and result size
- **Write units**: scale with vectors upserted/updated

Sparse indexes use inverted lists; dense indexes use a proprietary ANN structure (graph-based). Indexes are namespaced — switching namespace is a query-time parameter, not a separate index.

## Query Patterns

### Create dense + sparse indexes with integrated inference

```python
from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="…")

# Dense: server-side embedding via Cohere embed-multilingual-v3.0
pc.create_index_for_model(
    name="docs-dense",
    cloud="aws", region="us-east-1",
    embed={
        "model": "multilingual-e5-large",
        "field_map": {"text": "chunk_text"},
    },
)

# Sparse: server-side sparse embedding via pinecone-sparse-english-v0
pc.create_index_for_model(
    name="docs-sparse",
    cloud="aws", region="us-east-1",
    embed={
        "model": "pinecone-sparse-english-v0",
        "field_map": {"text": "chunk_text"},
    },
)
```

### Upsert records (server embeds for you)

```python
dense  = pc.Index(host=pc.describe_index("docs-dense").host)
sparse = pc.Index(host=pc.describe_index("docs-sparse").host)

records = [
    {"_id": "doc1#0", "chunk_text": "Pinecone serverless scales storage and compute…",
     "tenant": "acme", "url": "https://…"},
    {"_id": "doc1#1", "chunk_text": "Namespaces partition vectors logically…",
     "tenant": "acme", "url": "https://…"},
]
dense.upsert_records(namespace="acme", records=records)
sparse.upsert_records(namespace="acme", records=records)
```

### Hybrid search with server-side rerank

```python
# 1. Retrieve top 50 from each index (server embeds the query for you)
dense_hits = dense.search(
    namespace="acme",
    query={"inputs": {"text": "how does serverless scale?"}, "top_k": 50},
    fields=["chunk_text", "url"],
)
sparse_hits = sparse.search(
    namespace="acme",
    query={"inputs": {"text": "how does serverless scale?"}, "top_k": 50},
    fields=["chunk_text", "url"],
)

# 2. Merge by id (RRF) and rerank top 20 with bge-reranker-v2-m3
merged = rrf_merge(dense_hits.result.hits, sparse_hits.result.hits, k=60)[:50]

reranked = pc.inference.rerank(
    model="bge-reranker-v2-m3",
    query="how does serverless scale?",
    documents=[{"id": h["_id"], "text": h["fields"]["chunk_text"]} for h in merged],
    top_n=10,
    return_documents=True,
)
```

### Metadata filter + namespace

```python
dense.query(
    namespace="acme",
    vector=[0.0]*1024,                      # already-embedded query
    top_k=10,
    include_metadata=True,
    filter={"category": {"$in": ["docs", "blog"]},
            "published_at": {"$gte": 1735689600}},
)
```

## Performance Tuning

- Use namespaces, not indexes, for multi-tenancy — index creation is the slow op
- Set `top_k` as small as you can; read units scale with `top_k`
- Pre-filter via metadata indexes; high-cardinality fields should be `string`/`number`
- For latency-critical reads, attach **dedicated read nodes** (predictable p99 < 50 ms)
- Batch upserts in chunks of 100 records (≤ 2 MB request) for best throughput
- Use server-side embedding only when network round-trip is the bottleneck — costs more per call than self-embed

## Common Pitfalls

- Creating one index per tenant — quotas and cost explode; use namespaces
- Forgetting `namespace=` in queries — searches the empty default namespace
- Mixing dense and sparse vectors in one record (legacy hybrid index) on serverless — use two indexes
- Underestimating read units: `top_k=100` with metadata is far more expensive than `top_k=10`
- Treating sparse model as drop-in for BM25 across languages — `pinecone-sparse-english-v0` is English-only
- Not setting `include_values=False` — pulling vectors back wastes bandwidth

## When to Use This Mode

- You want zero-ops vector search with predictable serverless billing
- Multi-tenant SaaS with thousands of namespaces
- Embedding + rerank pipeline you don't want to host
- Geographic SLAs across AWS/GCP/Azure regions
- Need dedicated read nodes for latency-sensitive consumer apps

## Sources

- Pinecone docs: https://docs.pinecone.io/
- 2025 release notes: https://docs.pinecone.io/release-notes/2025
- Integrated inference: https://www.pinecone.io/blog/integrated-inference/
- Sparse indexes: https://www.pinecone.io/learn/sparse-retrieval/
- Dedicated read nodes: https://blocksandfiles.com/2025/12/01/pinecone-dedicated-read-nodes/