Articles

LangChain Vector Stores: Pinecone vs Chroma vs Weaviate (2026)

April 18, 2026 6 min read

Pinecone, Chroma, and Weaviate are all popular vector stores, but they approach the problem of storing and querying high-dimensional embeddings with fundamentally different trade-offs in terms of performance, scalability, and operational overhead.

Let’s see how these differences play out in practice. Imagine we have a small dataset of product descriptions and we want to find similar products using their embeddings.

First, we need to generate embeddings. For simplicity, we’ll use a hypothetical embedding_model that outputs 5-dimensional vectors.

# Assume this function exists and returns a list of embeddings
def get_embeddings(texts):
    # In a real scenario, this would be a call to an embedding model like Sentence-BERT
    # For demonstration, we'll create dummy embeddings
    import random
    return [[random.random() for _ in range(5)] for _ in texts]

products = [
    {"id": "p1", "description": "A comfortable cotton t-shirt."},
    {"id": "p2", "description": "A durable denim jacket."},
    {"id": "p3", "description": "A soft, breathable linen shirt."},
    {"id": "p4", "description": "A warm wool sweater."},
    {"id": "p5", "description": "A stylish leather handbag."},
]

embeddings = get_embeddings([p["description"] for p in products])

# Combine products with their embeddings
data_to_index = []
for i, p in enumerate(products):
    data_to_index.append({"id": p["id"], "embedding": embeddings[i], "metadata": {"description": p["description"]}})

Now, let’s index this data into each vector store.

Pinecone

Pinecone is a fully managed, cloud-native vector database. You don’t manage any infrastructure.

Setup: You’ll need a Pinecone API key and environment, and you create an "index" which is essentially a collection of vectors.

from pinecone import Pinecone, ServerlessSpec
import os

# Initialize Pinecone (replace with your actual API key and environment)
api_key = os.environ.get("PINECONE_API_KEY", "YOUR_PINECONE_API_KEY")
environment = os.environ.get("PINECONE_ENVIRONMENT", "YOUR_PINECONE_ENVIRONMENT") # e.g., "gcp-starter"

pc = Pinecone(api_key=api_key, environment=environment)

index_name = "my-product-index"
dimension = 5 # Matches our dummy embeddings

if index_name not in pc.list_indexes().names:
    pc.create_index(
        name=index_name,
        dimension=dimension,
        metric="cosine", # Common metric for embeddings
        spec=ServerlessSpec(cloud="aws", region="us-east-1") # Or your preferred cloud/region
    )

index = pc.Index(index_name)

# Upsert data
index.upsert(
    vectors=[(d["id"], d["embedding"], d["metadata"]) for d in data_to_index],
    namespace="products" # Optional namespace for organization
)

Querying: To find similar products, you embed a query and search.

query_embedding = get_embeddings(["looking for a shirt"])[0]
results = index.query(
    vector=query_embedding,
    top_k=2,
    include_metadata=True,
    namespace="products"
)

print("Pinecone Results:", results)

Mental Model: Pinecone is like a highly optimized, cloud-hosted search engine for vectors. You pay for usage and don’t worry about servers, scaling, or maintenance. It’s built for massive scale and low latency.

Chroma

Chroma is an open-source, embeddable vector database. It can run in-memory, as a client/server, or with persistence to disk.

Setup: You can run it locally with minimal setup.

from chromadb import Client, PersistentClient
from chromadb.utils import embedding_functions

# Option 1: In-memory (data lost on exit)
# client = Client()

# Option 2: Persistent client (saves to disk)
client = PersistentClient(path="./chroma_db") # Data will be stored in './chroma_db' directory

# Define an embedding function (Chroma can use Sentence-Transformers or OpenAI)
# For this example, we'll use a dummy one that just returns the provided vector
class DummyEmbeddingFunction:
    def __call__(self, texts):
        return get_embeddings(texts) # Reusing our dummy embedding generator

# Create or get a collection
collection_name = "product_collection"
try:
    collection = client.get_collection(name=collection_name)
except: # Handle case where collection doesn't exist
    collection = client.create_collection(
        name=collection_name,
        embedding_function=DummyEmbeddingFunction() # Use our dummy function
    )

# Add data
collection.add(
    embeddings=[d["embedding"] for d in data_to_index],
    metadatas=[d["metadata"] for d in data_to_index],
    ids=[d["id"] for d in data_to_index]
)

Querying: Similar to Pinecone, you embed your query.

query_embedding = get_embeddings(["looking for a shirt"])[0]
results = collection.query(
    query_embeddings=[query_embedding],
    n_results=2,
    include=['metadatas']
)

print("Chroma Results:", results)

Mental Model: Chroma is like an SQLite database for embeddings. It’s lightweight, easy to integrate into your Python application, and you control its deployment. It’s excellent for development, smaller-scale applications, or when you want full control over your data and infrastructure.

Weaviate

Weaviate is an open-source, cloud-native vector database that is also a GraphQL-native API. It supports hybrid search (vector + keyword) and has built-in modules for vectorization.

Setup: Weaviate can be run via Docker Compose or as a managed service.

import weaviate
import os

# Option 1: Connect to a local Docker instance
# client = weaviate.Client("http://localhost:8080")

# Option 2: Connect to a Weaviate Cloud Services (WCS) instance
# Replace with your WCS endpoint and API key
WCS_URL = os.environ.get("WCS_URL", "YOUR_WCS_URL")
WCS_API_KEY = os.environ.get("WCS_API_KEY", "YOUR_WEAVIATE_API_KEY")
client = weaviate.Client(url=WCS_URL, auth_client_secret=weaviate.AuthApiKey(api_key=WCS_API_KEY))


# Define the schema
class_name = "Product"
schema = {
    "classes": [
        {
            "class": class_name,
            "description": "A product with a description",
            "vectorizer": "none", # We are providing vectors manually, so no auto-vectorization
            "properties": [
                {"name": "description", "dataType": ["text"]},
            ],
        }
    ]
}
client.schema.create(schema)

# Add data
with client.batch as batch:
    batch.batch_size = 100
    for d in data_to_index:
        properties = {
            "description": d["metadata"]["description"],
        }
        batch.add_data_object(
            data_object=properties,
            class_name=class_name,
            vector=d["embedding"] # Provide the vector directly
        )

Querying: Weaviate uses a GraphQL-like query language.

# Weaviate needs the query vector to be the same dimension as the indexed vectors.
# For simplicity, we'll use the dummy embedding function again.
query_embedding = get_embeddings(["looking for a shirt"])[0]

# Construct the query
query = {
    "query": """
    {
      Get {
        Product(
          nearVector: {
            vector: """ + str(query_embedding) + """,
            distance: 0.6 # Optional: filter by distance threshold
          }
          limit: 2
        ) {
          description
          _additional {
            distance
          }
        }
      }
    }
    """
}

results = client.query_json(query)
print("Weaviate Results:", results)

Mental Model: Weaviate is a powerful, feature-rich vector database that excels at hybrid search and offers a flexible GraphQL API. It can handle complex data relationships and provides a rich set of modules for tasks like auto-vectorization or question answering, abstracting away much of the complexity.

Key Differentiators

  • Management: Pinecone is fully managed. Chroma can be embedded or client/server. Weaviate is self-hosted (Docker) or managed (WCS).
  • Scalability: Pinecone is designed for hyperscale. Weaviate scales well and offers enterprise features. Chroma is great for development and smaller deployments, with options for scaling.
  • Features: Weaviate’s GraphQL API and hybrid search are standout features. Pinecone is highly optimized for pure vector search. Chroma is simple and embeddable.
  • Cost: Pinecone has usage-based pricing. Chroma is open-source and free, with infrastructure costs. Weaviate is open-source and free, with infrastructure costs or WCS pricing.

The choice often comes down to your operational preferences, the scale of your project, and the specific features you need.

One subtle but powerful aspect of these vector stores is how they handle indexing and retrieval. While they all use Approximate Nearest Neighbor (ANN) algorithms to speed up search, the specific algorithms and their configurations (e.g., HNSW parameters in Weaviate, or the internal indexing in Pinecone) can dramatically impact search latency and recall. This means that for a given dataset and query workload, one store might offer significantly better performance or accuracy than another, even with identical vector dimensions and similarity metrics, due to internal optimizations and trade-offs.

If you’re building a simple RAG application for a few thousand documents and want to keep it all within your Python project, Chroma is often the easiest to get started with. For production systems needing high availability and massive scale without managing infrastructure, Pinecone is a strong contender. If you need advanced search capabilities like hybrid search or a rich API for complex data interactions, Weaviate is worth a deep dive.

Want structured learning?

Take the full Langchain course →