Vector Database Complete Comparison - Chroma, Milvus, Pinecone, Qdrant, Weaviate, pgvector

# Install via pip
pip install chromadb
 
# Or run as server with Docker
docker run -p 8000:8000 chromadb/chroma

import chromadb
 
# Embedded mode (no server needed)
client = chromadb.Client()
 
# Or connect to server
# client = chromadb.HttpClient(host="localhost", port=8000)
 
# Create a collection
collection = client.create_collection(
    name="documents",
    metadata={"hnsw:space": "cosine"}
)
 
# Insert vectors with metadata
collection.add(
    ids=["doc1", "doc2", "doc3"],
    embeddings=[
        [0.1, 0.2, 0.3, 0.4],
        [0.5, 0.6, 0.7, 0.8],
        [0.9, 0.1, 0.2, 0.3]
    ],
    metadatas=[
        {"source": "wiki", "topic": "AI"},
        {"source": "arxiv", "topic": "ML"},
        {"source": "blog", "topic": "AI"}
    ],
    documents=["doc about AI", "doc about ML", "another AI doc"]
)
 
# Search for similar vectors
results = collection.query(
    query_embeddings=[[0.1, 0.2, 0.3, 0.4]],
    n_results=2,
    where={"topic": "AI"}
)
print(results)

pip install pinecone

from pinecone import Pinecone, ServerlessSpec
 
# Initialize client
pc = Pinecone(api_key="YOUR_API_KEY")
 
# Create index
pc.create_index(
    name="documents",
    dimension=4,
    metric="cosine",
    spec=ServerlessSpec(
        cloud="aws",
        region="us-east-1"
    )
)
 
# Connect to index
index = pc.Index("documents")
 
# Insert vectors (upsert)
index.upsert(vectors=[
    {"id": "doc1", "values": [0.1, 0.2, 0.3, 0.4],
     "metadata": {"source": "wiki", "topic": "AI"}},
    {"id": "doc2", "values": [0.5, 0.6, 0.7, 0.8],
     "metadata": {"source": "arxiv", "topic": "ML"}},
    {"id": "doc3", "values": [0.9, 0.1, 0.2, 0.3],
     "metadata": {"source": "blog", "topic": "AI"}}
])
 
# Search with metadata filter
results = index.query(
    vector=[0.1, 0.2, 0.3, 0.4],
    top_k=2,
    filter={"topic": {"$eq": "AI"}},
    include_metadata=True
)
print(results)

# Start Milvus with Docker Compose
wget https://github.com/milvus-io/milvus/releases/download/v2.4.0/milvus-standalone-docker-compose.yml -O docker-compose.yml
docker compose up -d
 
# Install Python SDK
pip install pymilvus

from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType, utility
 
# Connect to Milvus
connections.connect("default", host="localhost", port="19530")
 
# Define schema
fields = [
    FieldSchema(name="id", dtype=DataType.VARCHAR, is_primary=True, max_length=64),
    FieldSchema(name="topic", dtype=DataType.VARCHAR, max_length=64),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=4)
]
schema = CollectionSchema(fields, description="Document collection")
 
# Create collection
collection = Collection("documents", schema)
 
# Insert data
data = [
    ["doc1", "doc2", "doc3"],
    ["AI", "ML", "AI"],
    [[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8], [0.9, 0.1, 0.2, 0.3]]
]
collection.insert(data)
 
# Build index
index_params = {
    "index_type": "HNSW",
    "metric_type": "COSINE",
    "params": {"M": 16, "efConstruction": 256}
}
collection.create_index("embedding", index_params)
collection.load()
 
# Search
search_params = {"metric_type": "COSINE", "params": {"ef": 64}}
results = collection.search(
    data=[[0.1, 0.2, 0.3, 0.4]],
    anns_field="embedding",
    param=search_params,
    limit=2,
    expr='topic == "AI"',
    output_fields=["topic"]
)
for hits in results:
    for hit in hits:
        print(f"ID: {hit.id}, Distance: {hit.distance}, Topic: {hit.entity.get('topic')}")

# Run with Docker
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant
 
# Install Python SDK
pip install qdrant-client

from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance, PointStruct, Filter, FieldCondition, MatchValue
 
# Connect to Qdrant
client = QdrantClient(host="localhost", port=6333)
 
# Create collection
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(size=4, distance=Distance.COSINE)
)
 
# Insert vectors
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(id=1, vector=[0.1, 0.2, 0.3, 0.4],
                    payload={"source": "wiki", "topic": "AI"}),
        PointStruct(id=2, vector=[0.5, 0.6, 0.7, 0.8],
                    payload={"source": "arxiv", "topic": "ML"}),
        PointStruct(id=3, vector=[0.9, 0.1, 0.2, 0.3],
                    payload={"source": "blog", "topic": "AI"})
    ]
)
 
# Search with filter
results = client.query_points(
    collection_name="documents",
    query=[0.1, 0.2, 0.3, 0.4],
    limit=2,
    query_filter=Filter(
        must=[FieldCondition(key="topic", match=MatchValue(value="AI"))]
    )
)
for point in results.points:
    print(f"ID: {point.id}, Score: {point.score}, Payload: {point.payload}")

# Run with Docker
docker run -p 8080:8080 -p 50051:50051 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  semitechnologies/weaviate
 
# Install Python SDK
pip install weaviate-client

import weaviate
import weaviate.classes as wvc
 
# Connect to Weaviate
client = weaviate.connect_to_local()
 
# Create collection (class)
documents = client.collections.create(
    name="Document",
    vectorizer_config=wvc.config.Configure.Vectorizer.none(),
    properties=[
        wvc.config.Property(name="source", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="topic", data_type=wvc.config.DataType.TEXT),
        wvc.config.Property(name="content", data_type=wvc.config.DataType.TEXT),
    ]
)
 
# Insert vectors
documents.data.insert_many([
    wvc.data.DataObject(
        properties={"source": "wiki", "topic": "AI", "content": "doc about AI"},
        vector=[0.1, 0.2, 0.3, 0.4]
    ),
    wvc.data.DataObject(
        properties={"source": "arxiv", "topic": "ML", "content": "doc about ML"},
        vector=[0.5, 0.6, 0.7, 0.8]
    ),
    wvc.data.DataObject(
        properties={"source": "blog", "topic": "AI", "content": "another AI doc"},
        vector=[0.9, 0.1, 0.2, 0.3]
    )
])
 
# Search with filter
results = documents.query.near_vector(
    near_vector=[0.1, 0.2, 0.3, 0.4],
    limit=2,
    filters=wvc.query.Filter.by_property("topic").equal("AI"),
    return_metadata=wvc.query.MetadataQuery(distance=True)
)
for obj in results.objects:
    print(f"Topic: {obj.properties['topic']}, Distance: {obj.metadata.distance}")
 
client.close()

# Install extension (PostgreSQL 13+)
# Ubuntu/Debian
sudo apt install postgresql-16-pgvector
 
# Or build from source
cd /tmp && git clone https://github.com/pgvector/pgvector.git
cd pgvector && make && sudo make install
 
# Or use Docker
docker run -p 5432:5432 -e POSTGRES_PASSWORD=postgres ankane/pgvector

-- Enable extension
CREATE EXTENSION vector;
 
-- Create table with vector column
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    source VARCHAR(64),
    topic VARCHAR(64),
    embedding vector(4)
);
 
-- Insert data
INSERT INTO documents (content, source, topic, embedding) VALUES
    ('doc about AI', 'wiki', 'AI', '[0.1, 0.2, 0.3, 0.4]'),
    ('doc about ML', 'arxiv', 'ML', '[0.5, 0.6, 0.7, 0.8]'),
    ('another AI doc', 'blog', 'AI', '[0.9, 0.1, 0.2, 0.3]');
 
-- Create HNSW index
CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops)
    WITH (m = 16, ef_construction = 256);
 
-- Search with filter
SELECT id, content, topic,
       1 - (embedding <=> '[0.1, 0.2, 0.3, 0.4]') AS similarity
FROM documents
WHERE topic = 'AI'
ORDER BY embedding <=> '[0.1, 0.2, 0.3, 0.4]'
LIMIT 2;

# Python with psycopg2
import psycopg2
from pgvector.psycopg2 import register_vector
import numpy as np
 
conn = psycopg2.connect("host=localhost dbname=postgres user=postgres password=postgres")
register_vector(conn)
 
cur = conn.cursor()
query_vec = np.array([0.1, 0.2, 0.3, 0.4])
cur.execute("""
    SELECT id, content, topic, 1 - (embedding <=> %s) AS similarity
    FROM documents
    WHERE topic = 'AI'
    ORDER BY embedding <=> %s
    LIMIT 2
""", (query_vec, query_vec))
 
for row in cur.fetchall():
    print(f"ID: {row[0]}, Content: {row[1]}, Similarity: {row[3]:.4f}")

# Qdrant -- Advanced filtering example
from qdrant_client.models import Filter, FieldCondition, MatchValue, Range
 
results = client.query_points(
    collection_name="documents",
    query=[0.1, 0.2, 0.3, 0.4],
    limit=5,
    query_filter=Filter(
        must=[
            FieldCondition(key="topic", match=MatchValue(value="AI")),
            FieldCondition(key="year", range=Range(gte=2023)),
        ],
        must_not=[
            FieldCondition(key="status", match=MatchValue(value="draft"))
        ]
    )
)

# Milvus -- Boolean expression filtering
results = collection.search(
    data=[[0.1, 0.2, 0.3, 0.4]],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 64}},
    limit=5,
    expr='topic == "AI" and year >= 2023 and status != "draft"'
)

-- pgvector -- Full SQL WHERE clause power
SELECT id, content, 1 - (embedding <=> query_vec) AS similarity
FROM documents
WHERE topic = 'AI'
  AND year >= 2023
  AND status != 'draft'
  AND category IN ('research', 'tutorial')
ORDER BY embedding <=> query_vec
LIMIT 5;

# Weaviate -- Native hybrid search (BM25 + vector)
results = documents.query.hybrid(
    query="transformer architecture attention mechanism",
    alpha=0.5,  # 0 = pure keyword, 1 = pure vector
    limit=5,
    return_metadata=wvc.query.MetadataQuery(score=True)
)
for obj in results.objects:
    print(f"Score: {obj.metadata.score:.4f}, Content: {obj.properties['content'][:80]}")

# Qdrant -- Sparse + Dense fusion
from qdrant_client.models import SparseVector
 
# Requires collection configured with both dense and sparse vectors
results = client.query_points(
    collection_name="documents",
    prefetch=[
        # Dense vector search
        {"query": [0.1, 0.2, 0.3, 0.4], "using": "dense", "limit": 20},
        # Sparse vector search (BM25 weights)
        {"query": SparseVector(indices=[1, 42, 100], values=[0.5, 0.8, 0.3]),
         "using": "sparse", "limit": 20},
    ],
    query={"fusion": "rrf"},  # Reciprocal Rank Fusion
    limit=5
)

-- pgvector + tsvector -- Hybrid search with PostgreSQL full-text search
SELECT id, content,
       ts_rank(to_tsvector('english', content), plainto_tsquery('english', 'transformer attention')) AS text_score,
       1 - (embedding <=> query_vec) AS vector_score
FROM documents
WHERE to_tsvector('english', content) @@ plainto_tsquery('english', 'transformer attention')
ORDER BY (0.5 * ts_rank(to_tsvector('english', content), plainto_tsquery('english', 'transformer attention'))
        + 0.5 * (1 - (embedding <=> query_vec))) DESC
LIMIT 5;

# Qdrant -- Named vectors (multiple vectors per point)
from qdrant_client.models import VectorParams, Distance
 
client.create_collection(
    collection_name="multimodal",
    vectors_config={
        "text": VectorParams(size=768, distance=Distance.COSINE),
        "image": VectorParams(size=512, distance=Distance.COSINE),
    }
)
 
# Search by text vector
results = client.query_points(
    collection_name="multimodal",
    query=[0.1] * 768,
    using="text",
    limit=5
)

# Milvus -- Multiple vector fields
fields = [
    FieldSchema(name="id", dtype=DataType.VARCHAR, is_primary=True, max_length=64),
    FieldSchema(name="text_vec", dtype=DataType.FLOAT_VECTOR, dim=768),
    FieldSchema(name="image_vec", dtype=DataType.FLOAT_VECTOR, dim=512),
]

# Milvus -- Prometheus metrics endpoint
curl http://localhost:9091/metrics
 
# Qdrant -- Built-in metrics
curl http://localhost:6333/metrics
 
# Weaviate -- Prometheus metrics
curl http://localhost:2112/metrics

from langchain_openai import OpenAIEmbeddings
from langchain_core.documents import Document
 
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 
docs = [
    Document(page_content="RAG improves LLM accuracy with retrieval", metadata={"topic": "RAG"}),
    Document(page_content="Vector databases store embeddings efficiently", metadata={"topic": "VectorDB"}),
    Document(page_content="HNSW enables fast approximate nearest neighbor search", metadata={"topic": "Indexing"}),
]

# Chroma
from langchain_chroma import Chroma
 
vectorstore = Chroma.from_documents(docs, embeddings, collection_name="langchain_demo")
results = vectorstore.similarity_search("How does RAG work?", k=2)
 
# Pinecone
from langchain_pinecone import PineconeVectorStore
 
vectorstore = PineconeVectorStore.from_documents(docs, embeddings, index_name="langchain-demo")
results = vectorstore.similarity_search("How does RAG work?", k=2)
 
# Milvus
from langchain_milvus import Milvus
 
vectorstore = Milvus.from_documents(docs, embeddings, collection_name="langchain_demo",
                                     connection_args={"host": "localhost", "port": "19530"})
results = vectorstore.similarity_search("How does RAG work?", k=2)
 
# Qdrant
from langchain_qdrant import QdrantVectorStore
 
vectorstore = QdrantVectorStore.from_documents(docs, embeddings,
                                                url="http://localhost:6333",
                                                collection_name="langchain_demo")
results = vectorstore.similarity_search("How does RAG work?", k=2)
 
# Weaviate
from langchain_weaviate import WeaviateVectorStore
import weaviate
 
weaviate_client = weaviate.connect_to_local()
vectorstore = WeaviateVectorStore.from_documents(docs, embeddings, client=weaviate_client)
results = vectorstore.similarity_search("How does RAG work?", k=2)
 
# pgvector
from langchain_postgres import PGVector
 
vectorstore = PGVector.from_documents(docs, embeddings,
                                       connection="postgresql://user:pass@localhost/db",
                                       collection_name="langchain_demo")
results = vectorstore.similarity_search("How does RAG work?", k=2)

from llama_index.core import VectorStoreIndex, Document
from llama_index.embeddings.openai import OpenAIEmbedding
 
documents = [Document(text="RAG combines retrieval with generation for better AI responses.")]
embed_model = OpenAIEmbedding(model="text-embedding-3-small")

# Chroma
from llama_index.vector_stores.chroma import ChromaVectorStore
import chromadb
 
chroma_client = chromadb.Client()
chroma_collection = chroma_client.create_collection("llama_demo")
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
 
index = VectorStoreIndex.from_documents(documents, vector_store=vector_store, embed_model=embed_model)
query_engine = index.as_query_engine()
response = query_engine.query("What is RAG?")

# Qdrant
from llama_index.vector_stores.qdrant import QdrantVectorStore
from qdrant_client import QdrantClient
 
qdrant_client = QdrantClient(host="localhost", port=6333)
vector_store = QdrantVectorStore(client=qdrant_client, collection_name="llama_demo")
 
index = VectorStoreIndex.from_documents(documents, vector_store=vector_store, embed_model=embed_model)
query_engine = index.as_query_engine()
response = query_engine.query("What is RAG?")

# Milvus
from llama_index.vector_stores.milvus import MilvusVectorStore
 
vector_store = MilvusVectorStore(uri="http://localhost:19530", collection_name="llama_demo", dim=1536)
 
index = VectorStoreIndex.from_documents(documents, vector_store=vector_store, embed_model=embed_model)
query_engine = index.as_query_engine()
response = query_engine.query("What is RAG?")

# Qdrant with Haystack
from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
from haystack_integrations.components.retrievers.qdrant import QdrantEmbeddingRetriever
from haystack.components.embedders import OpenAIDocumentEmbedder, OpenAITextEmbedder
from haystack import Pipeline, Document
 
# Set up document store
document_store = QdrantDocumentStore(
    url="http://localhost:6333",
    index="haystack_demo",
    embedding_dim=1536,
    recreate_index=True
)
 
# Index documents
doc_embedder = OpenAIDocumentEmbedder(model="text-embedding-3-small")
docs = [Document(content="RAG improves LLM accuracy with external knowledge retrieval.")]
docs_with_embeddings = doc_embedder.run(documents=docs)
document_store.write_documents(docs_with_embeddings["documents"])
 
# Build retrieval pipeline
query_pipeline = Pipeline()
query_pipeline.add_component("text_embedder", OpenAITextEmbedder(model="text-embedding-3-small"))
query_pipeline.add_component("retriever", QdrantEmbeddingRetriever(document_store=document_store, top_k=3))
query_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")
 
results = query_pipeline.run({"text_embedder": {"text": "What is RAG?"}})
for doc in results["retriever"]["documents"]:
    print(f"Score: {doc.score:.4f}, Content: {doc.content[:80]}")