Chroma vs FAISS vs Qdrant vs Weaviate: Vector Database Comparison

Quick Comparison

Chroma - Best for Beginners

Setup

pip install chromadb

Usage

import chromadb
from chromadb.utils import embedding_functions

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

# Use Ollama embeddings
ollama_ef = embedding_functions.OllamaEmbeddingFunction(
    model_name="nomic-embed-text",
    url="http://localhost:11434"
)

# Create collection
collection = client.get_or_create_collection(
    name="documents",
    embedding_function=ollama_ef
)

# Add documents
collection.add(
    documents=["Document 1 content", "Document 2 content"],
    ids=["doc1", "doc2"]
)

# Query
results = collection.query(query_texts=["search query"], n_results=5)

Pros: Zero config, in-memory or persistent, great for learning Cons: Limited scaling, basic filtering

FAISS - Best for Speed

Setup

pip install faiss-cpu  # or faiss-gpu for NVIDIA

Usage

import faiss
import numpy as np

# Create index
dimension = 768
index = faiss.IndexFlatIP(dimension)  # Inner product (cosine with normalized vectors)

# Add vectors
vectors = np.random.random((1000, dimension)).astype('float32')
faiss.normalize_L2(vectors)  # Normalize for cosine similarity
index.add(vectors)

# Search
query = np.random.random((1, dimension)).astype('float32')
faiss.normalize_L2(query)
distances, indices = index.search(query, k=5)

# Save/Load
faiss.write_index(index, "index.faiss")
index = faiss.read_index("index.faiss")

Pros: Fastest search, GPU acceleration, handles billions of vectors Cons: No built-in persistence, manual filtering

Qdrant - Best for Production

Setup

# Docker
docker run -p 6333:6333 qdrant/qdrant

# Or Python client only
pip install qdrant-client

Usage

from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance, PointStruct

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

# Create collection
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(size=768, distance=Distance.COSINE)
)

# Add vectors with metadata
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, ...],  # 768-dim vector
            payload={"source": "file1.pdf", "page": 1}
        )
    ]
)

# Search with filtering
results = client.search(
    collection_name="documents",
    query_vector=[0.1, 0.2, ...],
    query_filter={"must": [{"key": "source", "match": {"value": "file1.pdf"}}]},
    limit=5
)

Pros: Full filtering, excellent scaling, production-ready Cons: Requires Docker or server process

Weaviate - Best for Enterprise

Setup

docker run -p 8080:8080 semitechnologies/weaviate
pip install weaviate-client

Usage

import weaviate

client = weaviate.Client("http://localhost:8080")

# Create schema
client.schema.create_class({
    "class": "Document",
    "vectorizer": "none",  # We'll provide vectors
    "properties": [
        {"name": "content", "dataType": ["text"]},
        {"name": "source", "dataType": ["string"]}
    ]
})

# Add data
client.data_object.create(
    class_name="Document",
    data_object={"content": "...", "source": "file.pdf"},
    vector=[0.1, 0.2, ...]
)

# Search
result = client.query.get("Document", ["content", "source"]) \
    .with_near_vector({"vector": query_vector}) \
    .with_limit(5) \
    .do()

Pros: GraphQL API, modules for ML, enterprise features Cons: More complex, heavier resource usage

Benchmark Results

Query Speed (1M vectors, 768 dimensions)

Memory Usage

Decision Guide

Learning/Prototyping → Chroma
Maximum Speed → FAISS
Production RAG → Qdrant
Enterprise/Complex Queries → Weaviate

Key Takeaways

1. Chroma is perfect for getting started quickly
2. FAISS wins on raw performance with GPU support
3. Qdrant is the best all-around for production
4. Weaviate excels for enterprise with GraphQL and modules
5. All work great with Ollama and LangChain

Next Steps

1. Set up RAG locally with your chosen database
2. Build AI agents with vector memory
3. Choose embedding models for your vectors

---

Vector databases are the backbone of RAG systems. Choose based on your scale and requirements—all these options run fully locally.