title: Pinecone description: Managed vector database — Pinecone for RAG: serverless indexes, namespaces, metadata filtering, hybrid search, and zero-ops deployment. category: 09-RAG tags: [pinecone, vector-store, managed, serverless, rag] status: ready last_updated: 2026-09-06

Pinecone¶

Pinecone is a fully managed vector database — no servers to run, no indexes to manage. It offers serverless deployment, metadata filtering, namespaces for multi-tenancy, and hybrid search. Use Pinecone when you want zero-ops vector search in production.

Installation / Setup¶

pip install pinecone-client             # or: uv add pinecone-client
# sign up at https://www.pinecone.io/

Core Syntax¶

Client setup¶

from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

Create index¶

from pinecone import ServerlessSpec

pc.create_index(
    name="documents",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)

Connect to index¶

index = pc.Index("documents")

Upsert vectors¶

index.upsert(vectors=[
    {"id": "doc1", "values": [0.1]*1536, "metadata": {"source": "report", "year": 2025}},
    {"id": "doc2", "values": [0.2]*1536, "metadata": {"source": "docs", "year": 2024}},
])

Search¶

results = index.query(
    vector=[0.1]*1536,
    top_k=5,
    include_metadata=True,
)
for match in results["matches"]:
    print(f"Score: {match['score']:.3f}, ID: {match['id']}, Metadata: {match['metadata']}")

LangChain + Pinecone¶

from langchain_community.vectorstores import Pinecone
from langchain_openai import OpenAIEmbeddings
from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")
index = pc.Index("documents")

vectorstore = Pinecone(index, OpenAIEmbeddings(), "text")

# search with filter
docs = vectorstore.similarity_search(
    "query", k=5, filter={"source": "report"}
)

Common Operations¶

Metadata filtering¶

# exact match
results = index.query(
    vector=[0.1]*1536,
    top_k=5,
    filter={"source": {"$eq": "report"}},
    include_metadata=True,
)

# comparison
results = index.query(
    vector=[0.1]*1536,
    top_k=5,
    filter={"year": {"$gte": 2024}},
    include_metadata=True,
)

# logical operators
results = index.query(
    vector=[0.1]*1536,
    top_k=5,
    filter={"$and": [{"source": "report"}, {"year": {"$gte": 2024}}]},
)

Namespaces (multi-tenancy)¶

# upsert to a namespace
index.upsert(vectors=[
    {"id": "doc1", "values": [0.1]*1536, "metadata": {"source": "docs"}},
], namespace="tenant-123")

# search within a namespace
results = index.query(
    vector=[0.1]*1536, top_k=5, namespace="tenant-123"
)

Delete vectors¶

# delete by IDs
index.delete(ids=["doc1", "doc2"])

# delete by metadata filter
index.delete(filter={"source": "old_docs"})

# delete entire namespace
index.delete(delete_all=True, namespace="tenant-123")

Index management¶

# describe index
stats = index.describe_index_stats()
print(stats)

# list indexes
indexes = pc.list_indexes()

Practical Examples¶

Example 1 — Pinecone RAG pipeline¶

from pinecone import Pinecone
from langchain_community.vectorstores import Pinecone as LangPinecone
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

pc = Pinecone(api_key="YOUR_API_KEY")
index = pc.Index("documents")
vectorstore = LangPinecone(index, OpenAIEmbeddings(), "text")
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

rag = (
    {"context": retriever | (lambda d: "\n\n".join(x.page_content for x in d)),
     "question": RunnablePassthrough()}
    | ChatPromptTemplate.from_template("Answer:\n{context}\n\nQ: {question}")
    | ChatOpenAI(model="gpt-4o")
    | StrOutputParser()
)

Common Patterns¶

Pattern: multi-tenant RAG¶

# separate namespace per tenant
def get_retriever(tenant_id):
    return vectorstore.as_retriever(
        search_kwargs={"k": 5, "namespace": tenant_id}
    )

Pattern: incremental indexing¶

# upsert new documents without deleting old ones
def index_documents(docs, embeddings_model, namespace="default"):
    vectors = []
    for doc in docs:
        emb = embeddings_model.embed(doc.page_content)
        vectors.append({
            "id": doc.metadata["id"],
            "values": emb,
            "metadata": doc.metadata,
        })
    index.upsert(vectors=vectors, namespace=namespace)

Best Practices¶

Use Pinecone for production zero-ops vector search.
Use namespaces for multi-tenancy — isolate data per customer.
Use metadata filtering to narrow search scope.
Pinecone is serverless — you only pay for what you use.
Use hybrid search (dense + sparse) for better retrieval quality.

Common Mistakes¶

Mistake	Fix
Not using namespaces for multi-tenancy	Separate data per namespace
Ignoring metadata filtering	Add metadata for filtering — key advantage
Over-provisioning	Pinecone serverless scales automatically

Troubleshooting¶

Symptom	Cause / Fix
`Invalid API key`	Check Pinecone dashboard for correct key
`Index not found`	Create index or check name
Dimension mismatch	Vector size must match index dimension
Quota exceeded	Upgrade plan or reduce vectors

qdrant.md — self-hosted alternative
chroma.md — local alternative
faiss.md — local alternative
rag.md — the complete pipeline

Official Documentation¶

Pinecone docs — https://docs.pinecone.io/
Pinecone Python SDK — <https://docs.pinecone.io/reference/python-sdk/

Last Updated¶

2026-09-06 — Initial version.