pinecone

Pinecone - Managed Vector Database

The vector database for production AI applications.

When to use Pinecone

Use when:

• Need managed, serverless vector database
• Production RAG applications
• Auto-scaling required
• Low latency critical (<100ms)
• Don't want to manage infrastructure
• Need hybrid search (dense + sparse vectors)

Metrics:

• Fully managed SaaS
• Auto-scales to billions of vectors
• p95 latency <100ms
• 99.9% uptime SLA

Use alternatives instead:

• Chroma: Self-hosted, open-source
• FAISS: Offline, pure similarity search
• Weaviate: Self-hosted with more features

Quick start

Installation

pip install pinecone-client

Basic usage

from pinecone import Pinecone, ServerlessSpec# Initializepc = Pinecone(api_key="your-api-key")# Create indexpc.create_index(    name="my-index",    dimension=1536,  # Must match embedding dimension    metric="cosine",  # or "euclidean", "dotproduct"    spec=ServerlessSpec(cloud="aws", region="us-east-1"))# Connect to indexindex = pc.Index("my-index")# Upsert vectorsindex.upsert(vectors=[    {"id": "vec1", "values": [0.1, 0.2, ...], "metadata": {"category": "A"}},    {"id": "vec2", "values": [0.3, 0.4, ...], "metadata": {"category": "B"}}])# Queryresults = index.query(    vector=[0.1, 0.2, ...],    top_k=5,    include_metadata=True)print(results["matches"])

Core operations

Create index

# Serverless (recommended)pc.create_index(    name="my-index",    dimension=1536,    metric="cosine",    spec=ServerlessSpec(        cloud="aws",         # or "gcp", "azure"        region="us-east-1"    ))# Pod-based (for consistent performance)from pinecone import PodSpecpc.create_index(    name="my-index",    dimension=1536,    metric="cosine",    spec=PodSpec(        environment="us-east1-gcp",        pod_type="p1.x1"    ))

Upsert vectors

# Single upsertindex.upsert(vectors=[    {        "id": "doc1",        "values": [0.1, 0.2, ...],  # 1536 dimensions        "metadata": {            "text": "Document content",            "category": "tutorial",            "timestamp": "2025-01-01"        }    }])# Batch upsert (recommended)vectors = [    {"id": f"vec{i}", "values": embedding, "metadata": metadata}    for i, (embedding, metadata) in enumerate(zip(embeddings, metadatas))]index.upsert(vectors=vectors, batch_size=100)

Query vectors

# Basic queryresults = index.query(    vector=[0.1, 0.2, ...],    top_k=10,    include_metadata=True,    include_values=False)# With metadata filteringresults = index.query(    vector=[0.1, 0.2, ...],    top_k=5,    filter={"category": {"$eq": "tutorial"}})# Namespace queryresults = index.query(    vector=[0.1, 0.2, ...],    top_k=5,    namespace="production")# Access resultsfor match in results["matches"]:    print(f"ID: {match['id']}")    print(f"Score: {match['score']}")    print(f"Metadata: {match['metadata']}")

Metadata filtering

# Exact matchfilter = {"category": "tutorial"}# Comparisonfilter = {"price": {"$gte": 100}}  # $gt, $gte, $lt, $lte, $ne# Logical operatorsfilter = {    "$and": [        {"category": "tutorial"},        {"difficulty": {"$lte": 3}}    ]}  # Also: $or# In operatorfilter = {"tags": {"$in": ["python", "ml"]}}

Namespaces

# Partition data by namespaceindex.upsert(    vectors=[{"id": "vec1", "values": [...]}],    namespace="user-123")# Query specific namespaceresults = index.query(    vector=[...],    namespace="user-123",    top_k=5)# List namespacesstats = index.describe_index_stats()print(stats['namespaces'])

Hybrid search (dense + sparse)

# Upsert with sparse vectorsindex.upsert(vectors=[    {        "id": "doc1",        "values": [0.1, 0.2, ...],  # Dense vector        "sparse_values": {            "indices": [10, 45, 123],  # Token IDs            "values": [0.5, 0.3, 0.8]   # TF-IDF scores        },        "metadata": {"text": "..."}    }])# Hybrid queryresults = index.query(    vector=[0.1, 0.2, ...],    sparse_vector={        "indices": [10, 45],        "values": [0.5, 0.3]    },    top_k=5,    alpha=0.5  # 0=sparse, 1=dense, 0.5=hybrid)

LangChain integration

from langchain_pinecone import PineconeVectorStorefrom langchain_openai import OpenAIEmbeddings# Create vector storevectorstore = PineconeVectorStore.from_documents(    documents=docs,    embedding=OpenAIEmbeddings(),    index_name="my-index")# Queryresults = vectorstore.similarity_search("query", k=5)# With metadata filterresults = vectorstore.similarity_search(    "query",    k=5,    filter={"category": "tutorial"})# As retrieverretriever = vectorstore.as_retriever(search_kwargs={"k": 10})

LlamaIndex integration

from llama_index.vector_stores.pinecone import PineconeVectorStore# Connect to Pineconepc = Pinecone(api_key="your-key")pinecone_index = pc.Index("my-index")# Create vector storevector_store = PineconeVectorStore(pinecone_index=pinecone_index)# Use in LlamaIndexfrom llama_index.core import StorageContext, VectorStoreIndexstorage_context = StorageContext.from_defaults(vector_store=vector_store)index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

Index management

# List indicesindexes = pc.list_indexes()# Describe indexindex_info = pc.describe_index("my-index")print(index_info)# Get index statsstats = index.describe_index_stats()print(f"Total vectors: {stats['total_vector_count']}")print(f"Namespaces: {stats['namespaces']}")# Delete indexpc.delete_index("my-index")

Delete vectors

# Delete by IDindex.delete(ids=["vec1", "vec2"])# Delete by filterindex.delete(filter={"category": "old"})# Delete all in namespaceindex.delete(delete_all=True, namespace="test")# Delete entire indexindex.delete(delete_all=True)

Best practices

1. Use serverless - Auto-scaling, cost-effective
2. Batch upserts - More efficient (100-200 per batch)
3. Add metadata - Enable filtering
4. Use namespaces - Isolate data by user/tenant
5. Monitor usage - Check Pinecone dashboard
6. Optimize filters - Index frequently filtered fields
7. Test with free tier - 1 index, 100K vectors free
8. Use hybrid search - Better quality
9. Set appropriate dimensions - Match embedding model
10. Regular backups - Export important data

Performance

Pricing (as of 2025)

Serverless:

• $0.096 per million read units
• $0.06 per million write units
• $0.06 per GB storage/month

Free tier:

• 1 serverless index
• 100K vectors (1536 dimensions)
• Great for prototyping

Resources

• Website: https://www.pinecone.io
• Docs: https://docs.pinecone.io
• Console: https://app.pinecone.io
• Pricing: https://www.pinecone.io/pricing