Skip to content
AI & Tools

Choosing a Vector Database: Pinecone, Qdrant, Weaviate, Chroma or pgvector

AIDToolStack EditorialNovember 7, 20268 min read
Vector DatabasesRAGpgvectorQdrantPinecone
Share:Twitter

Your RAG prototype works. The embeddings sit in a NumPy array, cosine similarity runs in a loop, and the demo answers questions about your docs. Then someone asks where the vectors will live in production, and every vendor page you open promises speed and scale. That tells you nothing.

The differences that actually decide this are narrower: who runs the thing, what happens when a query has a filter on it, whether keyword search comes built in, and what the bill is metered on. This post goes through those four for Pinecone, Qdrant, Weaviate, Chroma and pgvector, using their own docs and pricing pages as of November 2026.

Start with what you already run

If your app already has Postgres, try pgvector before anything else. One fewer system to run, back up and secure is worth a lot, and your vectors can join against the rows they describe.

The README (install instructions currently pin v0.8.7, for Postgres 13 and later) gives you a vector type, HNSW and IVFFlat indexes, and distance operators: <-> for L2, <#> for negative inner product, <=> for cosine distance. The limit people hit is dimensions. A vector column stores up to 16,000 dimensions, but HNSW and IVFFlat only index up to 2,000. halfvec indexes up to 4,000.

That matters more than it sounds. OpenAI's embeddings guide lists text-embedding-3-large at 3,072 dimensions by default, which is over the vector index limit. Either store it as halfvec, or ask the API for fewer dimensions with its dimensions parameter. text-embedding-3-small (1,536) fits as is.

CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE chunks (
  id        bigserial PRIMARY KEY,
  tenant_id bigint NOT NULL,
  body      text NOT NULL,
  embedding vector(1536)
);

CREATE INDEX ON chunks USING hnsw (embedding vector_cosine_ops);

-- keep scanning the index until enough rows pass the filter
SET hnsw.iterative_scan = strict_order;

SELECT id, body
FROM chunks
WHERE tenant_id = 42
ORDER BY embedding <=> $1
LIMIT 10;

That SET line is there for a reason, which brings us to the part most comparisons skip.

Filtering is where they really differ

Nearly every real query has a filter: this tenant, this product version, documents the user is allowed to see. Approximate indexes like HNSW aren't built for that, and each database solves it differently.

The pgvector README is unusually honest about the naive approach. With approximate indexes, "filtering is applied after the index is scanned." Its example: if a condition matches 10% of rows, HNSW with the default ef_search of 40 returns about 4 rows on average. You asked for 10 and got 4, silently. Since 0.8.0, iterative index scans fix most of this: set hnsw.iterative_scan to strict_order or relaxed_order and the scan continues until it has enough matches or hits hnsw.max_scan_tuples.

Diagram comparing post-filtering, where HNSW returns 40 candidates and a 10% filter leaves about 4, with filter-aware search, where an allow list or payload index restricts the search to eligible points and returns the full 10
Diagram comparing post-filtering, where HNSW returns 40 candidates and a 10% filter leaves about 4, with filter-aware search, where an allow list or payload index restricts the search to eligible points and returns the full 10

The dedicated databases push the filter into the search itself:

  • Qdrant uses payload indexes, which you create per field and type (keyword, integer, geo, text and so on). Its indexing docs say the HNSW graph gets extra filter-aware edges, but only if the payload indexes exist before the graph is built, and they also feed cardinality estimates to the query planner. The practical rule: create payload indexes before you ingest.
  • Weaviate pre-filters. Its filtering docs describe an inverted index that builds an allow list of eligible IDs, and the vector search only keeps candidates on it. Since v1.34 the default filter strategy is ACORN; v1.40 added another strategy, PathSeer, though acorn stays the default. When a filter is very restrictive (the cutoff is around 15% of the dataset), it falls back to brute force over the matching subset.
  • Pinecone documents metadata filters with $eq, $ne, range operators, $in/$nin (up to 10,000 values), $exists, and $and/$or/$not. It doesn't describe the internals, so you test it rather than reason about it.
  • Chroma takes a where clause on metadata ($eq, $gt, $in, $contains and friends) and a separate where_document for substring matches on the text, per its filtering docs.

Here's the Qdrant version of "index the field you filter on," from its docs:

from qdrant_client import QdrantClient, models

client = QdrantClient(url="http://localhost:6333")

client.create_payload_index(
    collection_name="chunks",
    field_name="tenant_id",
    field_schema=models.PayloadSchemaType.KEYWORD,
)

If you run multi-tenant search with lots of small tenants, this section should weigh more than any benchmark chart. Test with your real filter selectivity: a 0.1% filter behaves nothing like a 50% one.

Developers and support users search for exact strings: error codes, function names, SKUs. Embeddings are weak at that, which is why hybrid search exists. Our post on RAG for developer documentation goes through why and how to fuse the two result lists.

What each option gives you out of the box:

  • Pinecone: its indexing overview says new indexes are now "document indexes," with a schema that can mix dense vectors, sparse vectors and full-text-searchable string fields. Legacy vector indexes keep working. Pinecone can also embed your text for you ("integrated embedding").
  • Chroma: its introduction lists dense, sparse and hybrid search, plus metadata filtering.
  • Weaviate: its hybrid search runs BM25 and vector search together, weighted by alpha (1 is pure vector, 0 pure keyword), with relative score fusion as the default since v1.24. See Pinecone vs Weaviate for how that compares.
  • Qdrant: the Query API runs dense and sparse queries as prefetch steps and fuses them with RRF or DBSF, per its hybrid query docs. You produce the sparse vectors yourself or with an inference option.
  • pgvector: gives you sparsevec (up to 16,000 non-zero elements, 1,000 for HNSW) next to Postgres's own full-text search. You write the fusion yourself, which is a dozen lines of SQL or Python.

What you pay for, and how it grows

The headline prices don't compare well because each vendor meters something different. Here's what the pricing pages said on 7 November 2026.

Self-hostFree cloud tierPaid entryMetered on
PineconeNo (BYOC by quote)2 GB, 2M write units, 1M read units a month, AWS us-east-1 onlyBuilder $20/mo flat; Standard $50/mo minimumRead units ($16 to $18 per million on Standard), write units, $0.33/GB-month storage
QdrantYes, Apache 2.00.5 vCPU, 1 GB RAM, 4 GB disk, free foreverStandard, usage-basedHourly vCPU, memory and storage
WeaviateYes, BSD-3 plus Weaviate License100,000 objects, 1 GB memory, 10 GB diskFlex from $45/moVector dimensions (from $0.00465 per million), storage, backups
ChromaYes, Apache 2.0Starter $0 plus usage, $5 credits a monthTeam $250/mo with $100 credits$2.50 per GiB written, $0.33/GiB-month stored, $0.0075 per TiB queried
pgvectorIt's an extensionWhatever your Postgres host offersYour Postgres billYour Postgres bill

The metering shape tells you what to optimise:

  • Pinecone charges per operation, so a read-heavy app with modest data pays mostly for queries. Model your queries per second before you model storage.
  • Weaviate charges per stored dimension, so your embedding size is a direct cost lever. At the Flex "from" rate, a million 1,536-dimension vectors is 1,536 million dimensions, about $7 a month for that component, before storage and the $45 minimum. Halving dimensions halves it. Our embedding dimension calculator is handy for this kind of arithmetic.
  • Qdrant Cloud charges for the machine, which is easy to predict and means an idle cluster still costs money.
  • Chroma Cloud charges per byte written and scanned, which suits spiky or small workloads.

The Weaviate repo's LICENSE file says code is "variously licensed under the BSD-3-Clause License, or the Weaviate License," so read it if self-hosting under a specific licence matters to you. Qdrant and Chroma are Apache 2.0 per GitHub.

Running it, and letting agents at it

A few operational facts that tend to decide things late:

  • Pinecone is a managed service; the pricing page lists bring-your-own-cloud only as "contact us." That's the point of it: no clusters to size. Namespaces partition an index, and every read and write targets exactly one, which maps neatly onto tenants or onto a throwaway namespace per CI run.
  • Qdrant and Weaviate are open source, so you can run the same engine locally that you'll pay for in their cloud, which keeps tests honest.
  • Chroma runs in-process (chromadb.Client() in its getting-started guide), self-hosted, or on Chroma Cloud. The in-process mode is why it's the usual first pick for notebooks and prototypes.
  • pgvector inherits your Postgres backups, replicas and access control. It also shares your Postgres capacity, and the README warns that HNSW has slower builds and uses more memory than IVFFlat, so a big index build competes with your transactional load. Our Postgres tuning post covers the memory settings that matter.

If you want a coding agent to inspect or query the store directly, there are MCP servers for Qdrant, Pinecone, Weaviate and Chroma. Give them read-only credentials unless you really want an agent deleting collections.

A decision rule

Decision tree: already on Postgres leads to pgvector; nobody wants to run a database leads to Pinecone; heavy filtering with an option to self-host leads to Qdrant; hybrid search and embedding inside the database leads to Weaviate; prototyping or small bursty workloads leads to Chroma
Decision tree: already on Postgres leads to pgvector; nobody wants to run a database leads to Pinecone; heavy filtering with an option to self-host leads to Qdrant; hybrid search and embedding inside the database leads to Weaviate; prototyping or small bursty workloads leads to Chroma

My default order:

  1. Already on Postgres? Use pgvector until it hurts. Turn on iterative scans, keep dimensions at or under 2,000 (or use halfvec), and measure recall on filtered queries.
  2. Nobody on the team wants to run a database? Pinecone. Model read units against your query volume first.
  3. Heavy filtering, multi-tenant, and you want the option to self-host? Qdrant, with payload indexes created before ingest.
  4. Want hybrid search and embedding handled inside the database? Weaviate (its free tier even includes 2,000 embedding requests a day), and size your dimensions with the per-dimension price in mind.
  5. Prototyping, or small and bursty? Chroma, in-process first.

Before you commit, run the same three checks on your shortlist: recall on your real queries with your real filters, p95 latency under your expected concurrency, and the monthly bill at ten times today's data. The Chroma vs Weaviate and Pinecone vs Qdrant comparisons are a good place to go next if you're down to two.

AE

Written by AIDToolStack Editorial

Researched from official documentation, specifications and vendor pages, listed under Sources below. Last checked November 2026.

Sources

  1. github.com/qdrant/qdrant
  2. github.com/weaviate/weaviate
  3. github.com/weaviate/weaviate/blob/main/LICENSE
  4. github.com/chroma-core/chroma
  5. github.com/pgvector/pgvector
  6. developers.openai.com/api/docs/guides/embeddings
  7. qdrant.tech/documentation/concepts/indexing/
  8. docs.weaviate.io/weaviate/concepts/filtering
  9. docs.pinecone.io/guides/search/filter-by-metadata
  10. docs.trychroma.com/docs/querying-collections/metadata-filtering
  11. docs.pinecone.io/guides/index-data/indexing-overview
  12. docs.trychroma.com/docs/overview/introduction
  13. docs.weaviate.io/weaviate/search/hybrid
  14. qdrant.tech/documentation/concepts/hybrid-queries/
  15. www.pinecone.io/pricing/
  16. qdrant.tech/pricing/
  17. weaviate.io/pricing
  18. www.trychroma.com/pricing
  19. docs.trychroma.com/docs/overview/getting-started

Related Posts

Explore on AIDToolStack

Discover tools and servers featured in our directory.

MCP Servers

Trigger.dev Jobs MCP ServerManage Trigger.dev background jobs from your AI coding assistant. Monitor job runs, trigger tasks manually, inspect execution logs, manage schedules, and debug failed runs. The server provides operational visibility into your background job infrastructure — see which tasks are running, queued, or failed, and take action. Your AI can help diagnose job failures from execution logs, retry failed tasks, and optimize concurrency configurations for better throughput.Tailscale Network MCP ServerManage your Tailscale mesh VPN network from your AI coding assistant. View connected devices, manage ACLs, configure exit nodes, check device status, and manage DNS settings. The server provides visibility into your Tailscale network — see which machines are online, troubleshoot connectivity issues, manage network access policies, and configure routes. Useful for developers managing distributed infrastructure where Tailscale provides secure networking between services.Portainer Docker MCP ServerManage Docker environments through Portainer's API from your AI coding assistant. Control containers, images, networks, and volumes across multiple Docker hosts and Kubernetes clusters. The server provides tools for container lifecycle management, image pulling and building, stack deployment, and resource monitoring. Portainer's multi-environment management makes this server particularly valuable for teams managing containers across development, staging, and production environments.

Reviews

Sign in to leave a review.

No reviews yet. Be the first!

Comments

Sign in to leave a comment.

No comments yet. Be the first!

Sponsor Our Newsletter

Reach thousands of developers who are actively evaluating AI tools, MCP servers, and dev infrastructure. Our weekly newsletter goes to engaged technical decision-makers.

Growing subscriber baseHigh open rates

All sponsored content is clearly labeled per our editorial policy.