Qdrant vs. Weaviate vs. pgvector: Open Source Vector Databases

By Carlos Montiel | Enterprise AI Specialist
Leer en español →
Published: 2026-07-28 | By: Carlos Montiel | Reading time: ~5 minutes

Choosing a vector database isn't choosing "which one is fastest" -- it's choosing which operational trade-off you're willing to accept between raw performance, simplicity, and what already runs in your stack.

The problem all three solve differently

All three options solve approximate nearest neighbor (ANN) search over embedding vectors, typically using variants of the HNSW (Hierarchical Navigable Small World) algorithm. The real difference isn't in the base algorithm -- it's in the operational model: pgvector is an extension on a relational database you already know, Qdrant is a dedicated vector database written in Rust built for raw performance, and Weaviate is a vector database with more integrated "full search stack" features (generation modules, classification, native multi-tenancy).

pgvector: the lowest-friction operational option

pgvector is a PostgreSQL extension that adds a `vector` data type and distance operators (cosine, L2, inner product) with HNSW or IVFFlat indexes. Its decisive advantage is operational: if you already run PostgreSQL in production, you add vector search without introducing a new system to back up, monitor, and maintain separately. You can join relational metadata and vector search in the same SQL query, something that requires duplicating data or making separate calls in a dedicated vector database.

CREATE EXTENSION vector; CREATE TABLE documents (id bigserial, content text, embedding vector(1536)); CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops); SELECT content FROM documents ORDER BY embedding <=> '[0.1, 0.2, ...]' LIMIT 5;

The real limitation shows up at scale: pgvector wasn't designed from the ground up for massive vector search, and on collections of tens of millions of vectors with strict latency requirements, its performance tends to lag Qdrant in throughput benchmarks under high concurrent load, especially when complex filters get combined with vector search.

Qdrant: performance as a design priority

Qdrant is written in Rust and designed from scratch exclusively for vector search, which shows in throughput and latency benchmarks under load -- consistently among the fastest open source options in independent comparisons (ANN-Benchmarks and community evaluations). Its filtering system (pre-filtering combined with the HNSW graph, not naive post-filtering) solves a classic vector search problem well: filtering by metadata without drastically degrading result quality or performance, something many simpler implementations handle poorly.

It supports vector quantization (scalar, binary, product) to reduce memory footprint on large collections, and has good multitenancy support via payload-based sharding.

from qdrant_client import QdrantClient client = QdrantClient(url="http://localhost:6333") client.query_points( collection_name="docs", query=[0.1, 0.2, 0.3], query_filter={"must": [{"key": "language", "match": {"value": "es"}}]}, limit=5 )

The cost is operational: it's one more system to deploy, back up, and monitor, separate from your main database.

Weaviate: the option with more integrated features

Weaviate positions itself more as a complete search platform than a pure vector database. It includes built-in modules to automatically generate embeddings (you don't need to generate the vector externally and pass it in), native hybrid search (BM25 + vector) with configurable result fusion, and multi-tenancy support designed from the core for SaaS with strong per-tenant isolation.

Its schema model (with typed classes and properties, similar to GraphQL) gives more structure than Qdrant, which helps in projects with stricter data governance requirements, but adds an extra configuration layer for simple use cases.

Benchmarks: what to measure and what to ignore

Public "vectors per second" benchmarks are useful but misleading in isolation -- real performance depends a lot on your vectors' dimensionality, your read-vs-write ratio, whether you need simultaneous complex filtering, and your memory budget for keeping the full HNSW index in RAM (critical for latency across all these solutions). In projects where we've done this evaluation for clients, the variable that moves the decision most isn't raw speed but the operational cost of maintaining one more system versus leveraging existing PostgreSQL.

Practical recommendation

If you already run PostgreSQL and your scale is hundreds of thousands to a few million vectors, start with pgvector -- the operational simplicity of one less system to maintain almost always outweighs the marginal performance gain of a dedicated solution at that scale. If your scale exceeds 10-50 million vectors, you need strict p99 latency under high concurrent load, or constant complex filtering, Qdrant is the more solid technical option due to its performance-first design. If you need a more complete search platform with integrated embedding generation and native SaaS multitenancy from day one, Weaviate reduces integration work in exchange for accepting its more opinionated schema model.

Carlos Montiel
Enterprise AI Solutions Architect
Specialist in LLMs, Agents, and Orchestration
guatemalia.com/en/#contact · info@guatemalia.com

Need to implement AI at your company?

Carlos Montiel is an enterprise AI solutions architect. He implements LLMs, Agents, RAG, and orchestrators for companies across Guatemala and Latin America. Reach out for a consultation.

Contact Carlos Montiel

info@guatemalia.com