Pinecone Tutorial: Getting Started with Vector Search in Python (2026)

pip install pinecone sentence-transformers

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")

# Create a serverless index (AWS us-east-1 is available on the free tier)
pc.create_index(
    name="demo",
    dimension=384,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1"),
)

# Connect to the index
index = pc.Index("demo")
print(index.describe_index_stats())

existing = [i.name for i in pc.list_indexes()]
if "demo" not in existing:
    pc.create_index(
        name="demo",
        dimension=384,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
    )

index = pc.Index("demo")

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-MiniLM-L6-v2")

texts = [
    "Python is a high-level programming language.",
    "Machine learning models require training data.",
    "Vector databases store embeddings for similarity search.",
    "LLMs generate text by predicting the next token.",
    "Pinecone is a managed vector database for production use.",
]

embeddings = model.encode(texts)
print(f"Shape: {embeddings.shape}")  # (5, 384)

vectors = [
    {
        "id": f"doc{i}",
        "values": embeddings[i].tolist(),
        "metadata": {"text": texts[i], "source": "docs"},
    }
    for i in range(len(texts))
]

index.upsert(vectors=vectors)
print(index.describe_index_stats())

def upsert_in_batches(index, vectors, batch_size=100):
    for i in range(0, len(vectors), batch_size):
        batch = vectors[i : i + batch_size]
        index.upsert(vectors=batch)
        print(f"  Upserted {min(i + batch_size, len(vectors))}/{len(vectors)}")

query_text = "What is a vector database?"
query_emb = model.encode([query_text])[0].tolist()

results = index.query(
    vector=query_emb,
    top_k=3,
    include_metadata=True,
)

for match in results["matches"]:
    print(f"Score: {match['score']:.4f}  |  {match['metadata']['text']}")

results = index.query(
    vector=query_emb,
    top_k=5,
    include_metadata=True,
    filter={"source": {"$eq": "docs"}},
)

from pinecone import Pinecone, ServerlessSpec
from sentence_transformers import SentenceTransformer

PINECONE_API_KEY = "YOUR_PINECONE_API_KEY"
INDEX_NAME = "semantic-search-demo"

articles = [
    "Pinecone is a managed vector database optimised for high-speed similarity search.",
    "ChromaDB is an open-source vector store that runs locally without any API key.",
    "FAISS is a Facebook AI library for efficient exact and approximate nearest neighbour search.",
    "Sentence Transformers convert text to dense embedding vectors for semantic similarity.",
    "RAG combines retrieval with generation to ground LLM answers in real documents.",
    "Python is the dominant language for machine learning and AI development in 2026.",
    "Claude is Anthropic's family of AI assistants based on Constitutional AI training.",
    "LangChain provides tools for composing LLM pipelines using a pipe-operator syntax.",
    "LlamaIndex specialises in document ingestion and advanced retrieval for RAG systems.",
    "Cosine similarity measures the angle between two vectors, ignoring their magnitude.",
]

model = SentenceTransformer("all-MiniLM-L6-v2")
embeddings = model.encode(articles)

pc = Pinecone(api_key=PINECONE_API_KEY)
existing = [i.name for i in pc.list_indexes()]
if INDEX_NAME not in existing:
    pc.create_index(
        name=INDEX_NAME,
        dimension=384,
        metric="cosine",
        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
    )

index = pc.Index(INDEX_NAME)

vectors = [
    {"id": f"article{i}", "values": embeddings[i].tolist(), "metadata": {"text": articles[i]}}
    for i in range(len(articles))
]
index.upsert(vectors=vectors)
print(f"Indexed {len(articles)} articles\n")

queries = [
    "Which vector database works offline?",
    "How does semantic search differ from keyword search?",
    "What tool helps build RAG pipelines?",
]

for query in queries:
    qvec = model.encode([query])[0].tolist()
    results = index.query(vector=qvec, top_k=2, include_metadata=True)
    print(f"Query: {query}")
    for r in results["matches"]:
        print(f"  [{r['score']:.3f}] {r['metadata']['text']}")
    print()

import anthropic
from pinecone import Pinecone
from sentence_transformers import SentenceTransformer

pc = Pinecone(api_key="YOUR_PINECONE_API_KEY")
index = pc.Index("semantic-search-demo")
model = SentenceTransformer("all-MiniLM-L6-v2")
claude = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from env


def rag_query(question: str, top_k: int = 3) -> str:
    qvec = model.encode([question])[0].tolist()
    results = index.query(vector=qvec, top_k=top_k, include_metadata=True)
    context = "\n".join(r["metadata"]["text"] for r in results["matches"])

    prompt = (
        f"Answer the question using only the context below.\n\n"
        f"Context:\n{context}\n\n"
        f"Question: {question}"
    )

    message = claude.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        messages=[{"role": "user", "content": prompt}],
    )
    return message.content[0].text


print(rag_query("What is the difference between Pinecone and ChromaDB?"))