pgvector vs Pinecone vs Qdrant: how do you choose a vector DB in 2025?

// Filtered vector search: four strategies and what each returns for "top 10
// WHERE <filter>" as the filter gets more selective. The "index" here returns
// candidates in exact nearest-first order, EF at a time: a best-case ANN index,
// so every loss below comes from the filter strategy, not from approximation.
let seed = 2025;
const rand = () => { seed = (seed * 1664525 + 1013904223) % 4294967296; return seed / 4294967296; };
const D = 16, N = 6000, K = 10, EF = 40, MAX_SCAN = 2000, QUERIES = 10;

const pts = [];
for (let i = 0; i < N; i++) { const v = []; for (let d = 0; d < D; d++) v.push(rand() - 0.5); pts.push(v); }
const FILTERS = [
  ["50% of rows", (i) => i % 2 === 0],
  ["10% of rows", (i) => i % 10 === 3],
  ["1% of rows", (i) => i % 100 === 7],
  ["0.2% of rows", (i) => i % 500 === 7],
];
const dist2 = (a, b) => { let s = 0; for (let d = 0; d < D; d++) { const t = a[d] - b[d]; s += t * t; } return s; };
const qs = [];
for (let j = 0; j < QUERIES; j++) { const v = []; for (let d = 0; d < D; d++) v.push(rand() - 0.5); qs.push(v); }

function strategies(q, match) {
  const all = pts.map((p, i) => [dist2(q, p), i]).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
  const truth = all.filter(([, i]) => match(i)).slice(0, K).map((x) => x[1]);
  const out = {};
  // post-filter: take EF nearest candidates, then apply WHERE
  out.post = { ids: all.slice(0, EF).filter(([, i]) => match(i)).slice(0, K).map((x) => x[1]), touched: EF };
  // iterative scan: keep pulling EF more until K matches or MAX_SCAN candidates seen
  let seen = 0; const got = [];
  while (got.length < K && seen < MAX_SCAN && seen < N) {
    for (const [, i] of all.slice(seen, seen + EF)) if (match(i) && got.length < K) got.push(i);
    seen += EF;
  }
  out.iter = { ids: got, touched: seen };
  // pre-filter: find matching rows first (a B-tree or payload index), then exact distance on them
  const subset = all.filter(([, i]) => match(i));
  out.pre = { ids: subset.slice(0, K).map((x) => x[1]), touched: subset.length };
  // partition: a separate index per filter value (namespace, partial index, per-tenant graph)
  out.part = { ids: subset.slice(0, K).map((x) => x[1]), touched: Math.min(EF, subset.length) };
  return { truth, out };
}

console.log(`${N} vectors, top ${K}, EF ${EF}, iterative cap ${MAX_SCAN}, ${QUERIES} queries`);
console.log("filter        strategy      avg returned  recall   avg vectors touched");
const NAMES = { post: "post-filter", iter: "iterative", pre: "pre-filter", part: "partition" };
for (const [label, match] of FILTERS) {
  const acc = {};
  for (const k of Object.keys(NAMES)) acc[k] = { ret: 0, hit: 0, touched: 0 };
  for (const q of qs) {
    const { truth, out } = strategies(q, match);
    const t = new Set(truth);
    for (const k of Object.keys(NAMES)) {
      acc[k].ret += out[k].ids.length; acc[k].touched += out[k].touched;
      acc[k].hit += out[k].ids.filter((i) => t.has(i)).length;
    }
  }
  for (const k of Object.keys(NAMES)) {
    const a = acc[k];
    console.log(`${label.padEnd(14)}${NAMES[k].padEnd(14)}${(a.ret / QUERIES).toFixed(1).padEnd(14)}${((100 * a.hit) / (QUERIES * K)).toFixed(0).padStart(3)}%    ${(a.touched / QUERIES).toFixed(1)}`);
  }
}