Capsule 02: Vector DB Provider Landscape

🎯 Capsule objective

Map the current vector database landscape for RAG: understand which problem each option solves best, how it differs from the others, and when it's the right choice for your project.

The vector database market has grown significantly since 2021. What started as search extensions on top of existing databases (pgvector, Elasticsearch kNN) has become an ecosystem of specialized solutions, each with a distinct design philosophy, business model, and audience. For an AI Engineer, the key is not to memorize each provider's specs but to develop a way to evaluate them quickly: What problem does it solve? For whom? At what operational cost?

This capsule covers the five most relevant providers for RAG systems in 2025-2026: ChromaDB, Pinecone, Weaviate, Qdrant, and Milvus. It doesn't aim to declare a winner; it aims to give you judgment so the decision is based on data and context, not on Twitter trends.

By the end of this capsule:

• ✅ You'll know the origin, architecture, and differentiators of 5 vector databases
• ✅ You'll identify the target audience of each provider
• ✅ You'll compare ecosystems and SDKs with code examples
• ✅ You'll have a clear mental map of the landscape to feed your decision tree

Estimated time: 20-25 minutes

🗺️ The Landscape: Overview

Before going provider by provider, it helps to understand the market's dimensions:

                    Managed (Cloud-first)
                         │
                    ┌────┴────┐
                    │Pinecone │
                    └─────────┘
                         │
        ┌────────────────┼────────────────┐
        │                │                │
   ┌────┴────┐     ┌────┴────┐     ┌────┴────┐
   │Weaviate │     │ Qdrant  │     │ Milvus  │
   │Cloud+OSS│     │Cloud+OSS│     │Cloud+OSS│
   └─────────┘     └─────────┘     └─────────┘
        │                │                │
        └────────────────┼────────────────┘
                         │
                    ┌────┴────┐
                    │ChromaDB │
                    │  (OSS)  │
                    └─────────┘
                         │
                  Self-hosted / Local

Key categories:

1️⃣ ChromaDB

Origin and philosophy

ChromaDB was born in 2022 as a direct response to the friction of working with vectors in LLM prototypes. Its philosophy is "the AI-native open-source embedding database": it prioritizes developer experience over enterprise features. Founded by Jeff Huber and Anton Troynikov, it raised an $18M Series A in 2023.

Design philosophy: The simplest possible vector database so you can go from pip install to semantic search in under 5 minutes.

Architecture

ChromaDB Architecture
┌─────────────────────────────────┐
│           Client API            │
│    (Python / JavaScript SDK)    │
├─────────────────────────────────┤
│         Collection Layer        │
│   ┌───────────┐ ┌───────────┐  │
│   │Collection │ │Collection │  │
│   │    A      │ │    B      │  │
│   └───────────┘ └───────────┘  │
├─────────────────────────────────┤
│       Embedding Functions       │
│  (Built-in or custom providers) │
├─────────────────────────────────┤
│       Index Layer (HNSW)        │
├─────────────────────────────────┤
│    Storage: SQLite + HNSW files │
│    (Persistent or in-memory)    │
└─────────────────────────────────┘

• Index: HNSW (hnswlib) for approximate nearest neighbor search.
• Storage: SQLite for metadata and documents; the HNSW index is stored as binary files on disk.
• Modes: In-memory (ephemeral) or persistent (local disk).
• Server mode: Client/server with FastAPI (since v0.4+).

SDK — Python example

import chromadb

client = chromadb.PersistentClient(path="./chroma_db")

collection = client.get_or_create_collection(
    name="tech_docs",
    metadata={"hnsw:space": "cosine"}
)

collection.add(
    documents=["FastAPI is a modern web framework for Python"],
    metadatas=[{"source": "docs", "language": "en"}],
    ids=["doc_001"]
)

results = collection.query(
    query_texts=["fast web framework in Python"],
    n_results=5,
    where={"language": "en"}
)
print(results["documents"])

Key differentiators

Target audience

• Developers learning RAG or vector databases.
• Teams in the PoC / MVP phase.
• Academic projects and Colab notebooks.
• Applications with < 500K vectors and low traffic.

Ecosystem

• LangChain: native integration.
• LlamaIndex: native integration.
• Embedding providers: OpenAI, Cohere, HuggingFace, Sentence Transformers.
• Community: Active on Discord, fast growth.

2️⃣ Pinecone

Origin and philosophy

Pinecone was founded in 2019 by Edo Liberty (former head of research at AWS AI Labs). It's the first vector database designed 100% as a managed service. There's no self-hosted option — this is intentional: Pinecone wants you to never think about infrastructure.

Design philosophy: "Vector search as a service." Zero operations, maximum speed to reach production.

Architecture

Pinecone Architecture (Serverless)
┌─────────────────────────────────┐
│         Pinecone API            │
│     (REST + gRPC + SDKs)        │
├─────────────────────────────────┤
│        Index Management         │
│   ┌──────────┐ ┌──────────┐    │
│   │Serverless│ │  Pod-    │    │
│   │  Index   │ │  based   │    │
│   └──────────┘ └──────────┘    │
├─────────────────────────────────┤
│      Distributed Storage        │
│   (S3-backed, proprietary)      │
├─────────────────────────────────┤
│     Multi-AZ Replication        │
│     (AWS regions)               │
└─────────────────────────────────┘

• Index types: Serverless (automatic scaling, pay-per-use) and Pod-based (dedicated capacity).
• Replication: Automatic multi-AZ.
• Storage: Proprietary, optimized for read-heavy workloads.
• No self-hosted: Cloud only.

SDK — Python example

from pinecone import Pinecone

pc = Pinecone(api_key="YOUR_API_KEY")

index = pc.Index("tech-docs")

index.upsert(
    vectors=[
        {
            "id": "doc_001",
            "values": [0.1, 0.2, 0.3, ...],  # 1536-dim
            "metadata": {"source": "docs", "language": "en"}
        }
    ],
    namespace="production"
)

results = index.query(
    vector=[0.1, 0.2, 0.3, ...],
    top_k=5,
    filter={"language": {"$eq": "en"}},
    namespace="production",
    include_metadata=True
)
print(results.matches)

Key differentiators

Target audience

• Startups and small teams that need production fast.
• Companies that prioritize time-to-market over infra control.
• Projects where the cost of an engineer maintaining infra exceeds the cost of the service.
• Teams without dedicated DevOps.

Ecosystem

• LangChain / LlamaIndex: First-class integration.
• Canopy: Pinecone's own RAG framework.
• Pinecone Assistant: A high-level product on top of the index.
• SDKs: Python, Node.js, Go, Java, Rust.
• Integrations: Cohere, OpenAI, Anthropic, Vercel AI SDK.

3️⃣ Weaviate

Origin and philosophy

Weaviate was created in 2019 in the Netherlands by Bob van Luijt. Its differentiator from the start is being a vector database with knowledge graph capabilities: you can define schemas with relationships, use vectorization modules, and combine semantic search with keyword search in a single query (native hybrid search).

Design philosophy: "The AI-native database" — a vector database that understands relationships between objects, not just similarity.

Architecture

Weaviate Architecture
┌─────────────────────────────────┐
│          GraphQL + REST API     │
├─────────────────────────────────┤
│       Schema / Class Layer      │
│   (typed objects + properties)  │
├─────────────────────────────────┤
│  Vectorizer Modules             │
│  ┌──────────┐ ┌──────────┐     │
│  │text2vec- │ │text2vec- │     │
│  │openai    │ │cohere    │     │
│  └──────────┘ └──────────┘     │
├─────────────────────────────────┤
│       Index: HNSW + BM25        │
│    (Native hybrid search)       │
├─────────────────────────────────┤
│     Storage: LSM Tree           │
│   (Custom, crash-recovery)      │
└─────────────────────────────────┘

• Index: HNSW for vectors + inverted BM25 for keyword.
• Hybrid search: Native RRF fusion (no external system required).
• Modules: Pluggable vectorization (OpenAI, Cohere, HuggingFace, etc.).
• Multi-tenancy: Native since v1.20 (activity-based).
• Availability: Open-source (BSD-3) + Weaviate Cloud Services (WCS).

SDK — Python example

import weaviate
import weaviate.classes as wvc

client = weaviate.connect_to_local()

collection = client.collections.create(
    name="TechDocs",
    vectorizer_config=wvc.config.Configure.Vectorizer.text2vec_openai(),
    properties=[
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="source", data_type=wvc.config.DataType.TEXT),
    ]
)

collection.data.insert(
    properties={"content": "FastAPI is a modern web framework", "source": "docs"}
)

response = collection.query.hybrid(
    query="fast web framework in Python",
    alpha=0.5,
    limit=5,
    filters=wvc.query.Filter.by_property("source").equal("docs")
)
for obj in response.objects:
    print(obj.properties["content"])

client.close()

Key differentiators

Target audience

• Teams that need hybrid search without additional infrastructure.
• Projects with relational + semantic data (e-commerce, knowledge bases).
• Teams that want self-hosted flexibility with a cloud option.
• Cases where native multi-tenancy is a requirement (SaaS).

Ecosystem

• LangChain / LlamaIndex: Robust integration.
• Verba: Weaviate's open-source RAG app.
• Modules: 20+ modules for vectorization, generation, reranking.
• SDKs: Python (v4 client), TypeScript, Go, Java.
• Community: Active, free Weaviate Academy.

4️⃣ Qdrant

Origin and philosophy

Qdrant (pronounced "quadrant") was founded in 2021 in Berlin by Andrey Vasnetsov. It's written in Rust, which gives it performance and memory-safety advantages. Its focus is solid performance with a clean API — a middle ground between the simplicity of ChromaDB and the scale of Milvus.

Design philosophy: "Vector search engine" — fast, predictable, with a clean REST/gRPC API and an excellent self-hosted experience.

Architecture

Qdrant Architecture
┌─────────────────────────────────┐
│       REST + gRPC API           │
├─────────────────────────────────┤
│      Collection Management      │
│   ┌──────────┐ ┌──────────┐    │
│   │Collection│ │Collection│    │
│   │  (shards)│ │  (shards)│    │
│   └──────────┘ └──────────┘    │
├─────────────────────────────────┤
│     Index: HNSW (custom)        │
│  + Payload Index (filterable)   │
├─────────────────────────────────┤
│  Storage: RocksDB / mmap        │
│  (On-disk + in-memory hybrid)   │
├─────────────────────────────────┤
│  Distributed: Raft consensus    │
│  (Sharding + Replication)       │
└─────────────────────────────────┘

• Language: Rust (performance, safety).
• Index: Custom HNSW + quantization (scalar, product, binary).
• Storage: RocksDB for persistence, mmap for fast access.
• Distribution: Raft consensus for multi-node clusters.
• Availability: Open-source (Apache 2.0) + Qdrant Cloud.

SDK — Python example

from qdrant_client import QdrantClient
from qdrant_client.models import (
    VectorParams, Distance, PointStruct, Filter,
    FieldCondition, MatchValue
)

client = QdrantClient(host="localhost", port=6333)

client.create_collection(
    collection_name="tech_docs",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

client.upsert(
    collection_name="tech_docs",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, 0.3, ...],
            payload={"source": "docs", "language": "en"}
        )
    ]
)

results = client.query_points(
    collection_name="tech_docs",
    query=[0.1, 0.2, 0.3, ...],
    limit=5,
    query_filter=Filter(
        must=[FieldCondition(key="language", match=MatchValue(value="en"))]
    )
)
for point in results.points:
    print(point.payload)

Key differentiators

Target audience

• Technical teams that value performance and control.
• Projects that need self-hosted with a good operational experience.
• Cases where quantization matters to reduce memory.
• Teams that prefer the Rust ecosystem and clean APIs.

Ecosystem

• LangChain / LlamaIndex: Full integration.
• Fastembed: Qdrant's library for local embeddings.
• SDKs: Python, TypeScript, Rust, Go, Java, C#.
• Dashboard: Web UI included to explore collections.
• Community: Growing fast, excellent documentation.

5️⃣ Milvus

Origin and philosophy

Milvus was created in 2019 by Zilliz, a company founded by Charles Xie. It's the largest vector database project in the Linux Foundation (LF AI & Data). Its design is oriented toward enterprise scale: millions to billions of vectors, distributed clusters, separation of storage and compute.

Design philosophy: "The world's most advanced open-source vector database" — massive scale, cloud-native, separation of responsibilities.

Architecture

Milvus Architecture (Distributed)
┌─────────────────────────────────┐
│          SDK / REST API         │
├─────────────────────────────────┤
│         Proxy Layer             │
│   (Load balancing, routing)     │
├─────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐    │
│  │  Query   │  │  Data    │    │
│  │  Nodes   │  │  Nodes   │    │
│  └──────────┘  └──────────┘    │
├─────────────────────────────────┤
│  ┌──────────┐  ┌──────────┐    │
│  │  Index   │  │  Root    │    │
│  │  Nodes   │  │  Coord   │    │
│  └──────────┘  └──────────┘    │
├─────────────────────────────────┤
│     Storage: S3 / MinIO         │
│     Meta: etcd                  │
│     Message: Pulsar / Kafka     │
└─────────────────────────────────┘

• Distributed: Complete separation of compute, storage, and coordination.
• Dependencies: etcd (meta), MinIO/S3 (storage), Pulsar/Kafka (messaging).
• Indexes: IVF_FLAT, IVF_SQ8, IVF_PQ, HNSW, DiskANN, GPU indexes.
• Milvus Lite: Embedded version for local development (similar to ChromaDB).
• Availability: Open-source (Apache 2.0) + Zilliz Cloud.

SDK — Python example

from pymilvus import MilvusClient

client = MilvusClient(uri="http://localhost:19530")

client.create_collection(
    collection_name="tech_docs",
    dimension=1536,
    metric_type="COSINE"
)

client.insert(
    collection_name="tech_docs",
    data=[
        {
            "id": 1,
            "vector": [0.1, 0.2, 0.3, ...],
            "source": "docs",
            "language": "en"
        }
    ]
)

results = client.search(
    collection_name="tech_docs",
    data=[[0.1, 0.2, 0.3, ...]],
    limit=5,
    filter='language == "en"',
    output_fields=["source", "language"]
)
print(results)

Key differentiators

Target audience

• Organizations with massive volumes (> 100M vectors).
• Teams with a dedicated platform and Kubernetes experience.
• Cases that require GPU-accelerated search.
• Enterprises with storage/compute separation requirements.

Ecosystem

• LangChain / LlamaIndex: Full integration.
• Attu: Web dashboard for visual management.
• Milvus Lite: Local development without dependencies.
• SDKs: Python, Java, Go, Node.js, C#, RESTful.
• Zilliz Cloud: Managed service with a free tier.

📊 General Comparison Table

*ChromaDB is developing a cloud offering, but it's not available at scale in 2026.

🔍 SDK Comparison: Same Problem, Five Approaches

To see the differences in developer experience, let's compare how each SDK solves the same basic flow: create a collection, insert a document, and search.

Query pattern with a filter

# ChromaDB — text-based, automatic embedding
results = collection.query(
    query_texts=["semantic search"],
    n_results=5,
    where={"category": "tutorial"}
)

# Pinecone — vector required, MongoDB-like filter syntax
results = index.query(
    vector=embedding,
    top_k=5,
    filter={"category": {"$eq": "tutorial"}}
)

# Weaviate — GraphQL-inspired, alpha for hybrid
response = collection.query.hybrid(
    query="semantic search",
    alpha=0.5,
    limit=5,
    filters=Filter.by_property("category").equal("tutorial")
)

# Qdrant — typed filter model
results = client.query_points(
    collection_name="docs",
    query=embedding,
    limit=5,
    query_filter=Filter(must=[FieldCondition(key="category", match=MatchValue(value="tutorial"))])
)

# Milvus — SQL-like filter string
results = client.search(
    collection_name="docs",
    data=[embedding],
    limit=5,
    filter='category == "tutorial"'
)

Observation: Each SDK reflects the provider's philosophy. ChromaDB prioritizes simplicity (text-in, results-out). Pinecone uses MongoDB syntax. Weaviate is GraphQL-like. Qdrant uses typed models. Milvus uses SQL-like strings.

🔧 Decision troubleshooting

1. "They all look good, I don't know where to start"

Cause: You're comparing without defined criteria.

Solution: Define your 3 main constraints before looking at providers:

1. How many vectors do I need to store (today and in 12 months)?
2. Do I have a DevOps team for self-hosted?
3. What p95 latency do I need?

With those three answers, you eliminate at least 2-3 options immediately.

2. "I don't have real cost data"

Cause: Providers don't always publish transparent pricing.

Solution: Estimate with three scenarios:

• Conservative: 100K vectors, 10 queries/second
• Expected: 1M vectors, 50 queries/second
• Aggressive: 10M vectors, 200 queries/second

Use the pricing calculators from Pinecone and Zilliz Cloud to estimate the managed tier.

3. "The team is split between two options"

Cause: Explicit weighted criteria are missing.

Solution: Document 5 criteria, assign weights (1-5), and have each person vote without seeing the others' votes. Then compare scores. The debate should be about criteria, not about brands.

4. "My case is very small, does the choice matter?"

Cause: For < 100K vectors almost all of them work the same.

Solution: If you're in an MVP or PoC, use ChromaDB. Define an explicit re-evaluation trigger (e.g., when you exceed 500K vectors or need an SLA). Don't invest time comparing providers until the scaling problem is real.

✏️ Exercises

Exercise 1: Landscape mental map

Create a mental map (paper or a digital tool) with the 5 providers. For each one, write:

• 1 main strength
• 1 main weakness
• 1 ideal use case

Exercise 2: Provider-scenario matching

Assign the most suitable provider to each scenario:

1. A 48-hour hackathon, 5K documents.
2. A B2B SaaS with 50 customers, each with their documents isolated.
3. An e-commerce company with 80M products and a platform team.
4. A 4-person startup that needs RAG in production in 2 weeks.
5. A research project with 2M papers and queries using exact paper IDs.

Exercise 3: SDK comparison

Implement the following flow with ChromaDB and compare it conceptually with the Pinecone pseudocode:

1. Create a collection with cosine distance
2. Insert 3 documents with metadata {"category": "tutorial"}
3. Search "how to optimize queries" filtering by category
4. Print the 2 most relevant results

import chromadb

client = chromadb.PersistentClient(path="./exercise_db")
collection = client.get_or_create_collection(
    name="exercise",
    metadata={"hnsw:space": "cosine"}
)

collection.add(
    documents=[
        "Query optimization in vector databases",
        "How to improve latency in semantic search",
        "Indexing guide for RAG"
    ],
    metadatas=[
        {"category": "tutorial"},
        {"category": "tutorial"},
        {"category": "tutorial"}
    ],
    ids=["doc_1", "doc_2", "doc_3"]
)

results = collection.query(
    query_texts=["how to optimize queries"],
    n_results=2,
    where={"category": "tutorial"}
)

for doc, dist in zip(results["documents"][0], results["distances"][0]):
    print(f"Score: {1 - dist:.4f} | {doc}")

Exercise 4: Ecosystem audit

For a RAG project that uses LangChain + OpenAI embeddings + FastAPI, investigate:

1. Which of the 5 providers have official LangChain integration?
2. Which offer automatic embedding (without generating externally)?
3. Which have a web dashboard to explore data?

Exercise 5: Elevator pitch

Write a 2-3 sentence "elevator pitch" to recommend a provider to your team. Include:

• The chosen provider
• The specific use case
• The main reason for the recommendation
• The main risk to monitor

🔗 Connection with the project (Decision Tree)

This module's project is to build a decision tree for choosing a vector database. This capsule gave you the raw material:

• Decision nodes: Does the team have DevOps? Scale > 1M? Does it need hybrid search?
• Tree leaves: Each provider as a final recommendation with justification.
• Criteria: Operational complexity, cost, features, scale.

In the next capsules you'll add the axes of managed vs self-hosted, features for RAG, and costs to complete your decision tree.

📝 Summary

• ChromaDB is the lowest-friction option for learning and prototypes — don't use it for production at large scale.
• Pinecone solves production without operations, but with total vendor lock-in and growing cost.
• Weaviate stands out for native hybrid search and multi-tenancy, with a higher learning curve.
• Qdrant offers the best balance of performance (Rust) and self-hosted ease, with advanced quantization.
• Milvus is for massive and enterprise scale — don't use it if your problem doesn't require it.
• Each SDK reflects the provider's philosophy: compare the development experience, not just features.
• The right choice depends on 3 axes: scale, operational capacity, and the critical features of your RAG.
• There's no universal winner; there's a best option for your specific context.

📚 Additional resources

• ChromaDB Docs — Official documentation and getting started
• Pinecone Docs — API reference and production guides
• Weaviate Docs — Concepts, modules, and tutorials
• Qdrant Docs — Guides, API reference, and benchmarks
• Milvus Docs — Architecture, SDKs, and deployment
• ANN Benchmarks — Independent benchmarks of ANN algorithms
• Vector Database Comparison (Superlinked) — Up-to-date comparison with filters
• MTEB Leaderboard — To choose an embedding model (complementary)

Reading time: 20-25 minutes Next: 03-managed-vs-self-hosted.md