<< All versions
Skill v1.0.1
currentAutomated scan100/100yousufkidiya17/hermes-mobile-modified/pinecone
──Details
PublishedNovember 21, 2026 at 02:14 AM
Content Hashsha256:7947f49681dd4107...
Git SHA6160948fb0e5
──Files
Files (1 file, 8.3 KB)
SKILL.md8.3 KBactive
SKILL.md · 382 lines · 8.3 KB
name: pinecone description: Managed vector DB for production RAG and search. version: 1.0.1 author: Orchestra Research license: MIT dependencies: [pinecone] platforms: [linux, macos, windows] metadata: hermes: tags: [RAG, Pinecone, Vector Database, Managed Service, Serverless, Hybrid Search, Production, Auto-Scaling, Low Latency, Recommendations]
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
bash
pip install pinecone
Note: the oldpinecone-clientpackage is deprecated. Installpinecone(v5+; current 9.x). The import staysfrom pinecone import Pinecone.
Basic usage
python
from pinecone import Pinecone, ServerlessSpec# Initializepc = Pinecone(api_key="your-api-key")# Create indexpc.create_index(name="my-index",dimension=1536, # Must match embedding dimensionmetric="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
python
# 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
python
# 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
python
# 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
python
# 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
python
# 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)
python
# 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 query# NOTE: index.query() does NOT accept an `alpha` kwarg. Pinecone stores a# single sparse-dense vector, so weighting must be applied by pre-scaling the# query vectors before sending them. Use the hybrid_score_norm helper below# (alpha * dense + (1 - alpha) * sparse; alpha=1 → pure dense, 0 → pure sparse).def hybrid_score_norm(dense, sparse, alpha: float):"""Scale dense/sparse query vectors for weighted hybrid search."""if not 0 <= alpha <= 1:raise ValueError("alpha must be between 0 and 1")scaled_sparse = {"indices": sparse["indices"],"values": [v * (1 - alpha) for v in sparse["values"]],}return [v * alpha for v in dense], scaled_sparsehdense, hsparse = hybrid_score_norm(dense=[0.1, 0.2, ...],sparse={"indices": [10, 45], "values": [0.5, 0.3]},alpha=0.5, # 0=sparse, 1=dense, 0.5=balanced)results = index.query(vector=hdense,sparse_vector=hsparse,top_k=5,)
LangChain integration
python
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
python
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
python
# 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
python
# 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
- Use serverless - Auto-scaling, cost-effective
- Batch upserts - More efficient (100-200 per batch)
- Add metadata - Enable filtering
- Use namespaces - Isolate data by user/tenant
- Monitor usage - Check Pinecone dashboard
- Optimize filters - Index frequently filtered fields
- Test with free tier - 1 index, 100K vectors free
- Use hybrid search - Better quality
- Set appropriate dimensions - Match embedding model
- Regular backups - Export important data
Performance
| Operation | Latency | Notes | |
|---|---|---|---|
| Upsert | ~50-100ms | Per batch | |
| Query (p50) | ~50ms | Depends on index size | |
| Query (p95) | ~100ms | SLA target | |
| Metadata filter | ~+10-20ms | Additional overhead |
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