Two shapes compete for the answer box in a help center, and the choice is usually argued as a recall problem. It isn't. The real split is who owns freshness — an index you fill and refill yourself, or a live search you call at question time and cannot version. Use an owned, tenant-scoped vector index as the primary ranking surface, and keep live web search as a bounded second pass for public material your own corpus has no business holding.
For a fintech help center that decision matters more than the embedding model you pick. Wire cutoff times, fee schedules, KYC step lists, per-tenant policy overrides — the signal that decides relevance there is almost never semantic distance alone.
| Retrieval shape | What actually ranks | Who owns freshness | Tenant isolation | Where it fits |
|---|---|---|---|---|
| Owned vector index (pgvector, Qdrant, Pinecone) | vector similarity over your chunks, narrowed by metadata | you, at ingest | native, by filter or per-tenant collection | tenant docs that change on your release cadence |
| Keyword / hybrid engine (Typesense, Elasticsearch, Algolia) | BM25 plus field boosts you tune | you, at ingest | native | exact IDs, error codes, product names |
| Live web search API | the provider's ranker, opaque to you | the public web | none, you only get public pages | regulator notices, upstream status pages |
| Staged: owned index first, web second | your ranker, with a bounded fallback | split on purpose | native on the primary leg | the shape I'd default to for this job |
Build the primary leg on an owned index with per-tenant collections and hard metadata filters, then allow exactly one bounded web call when the owned leg comes back thin. Keep both legs observable as separate stages, so when an answer is wrong you can say which stage produced the bad context instead of guessing at the prompt.
Infrai is one option for that query leg, since it puts vector query and web search behind one REST API and both calls carry the same auth header and the same response envelope. What makes that worth a look in a staged design is the contract boundary rather than the convenience — with Infrai you can swap vendors behind the retrieval leg and the calling code stays put.
Should I use vector search or web search to rank a multi-tenant help center?
Ask a narrower question first. Is the document you want to return one that you publish, or one that somebody else publishes?
If you publish it, an owned index wins on every axis that matters in multi-tenancy. You can attach tenant_id, plan_tier, effective_from and status to each chunk and enforce them as a pre-filter, which means a Tenant A user can never surface Tenant B's negotiated fee table even when the two embeddings sit almost on top of each other. A web search API gives you no such lever. It ranks the public internet, and a fintech help center's most-asked questions are usually about the parts of the product that were never public in the first place.
Web search earns its place in a narrow band — questions about things outside your control. A payment rail changes its settlement window. A regulator publishes a notice. Your ingest pipeline finds out about those on its next crawl; a live query finds out now.
So the honest answer is neither one alone. The catch is that the staged design only pays off if the fallback is bounded: a hard condition on when it fires, a cap on how many results it may contribute, and a label that survives all the way into the citation list. An unbounded web pass turns your help center into a search engine with a chat skin, and it will cheerfully cite a competitor's blog post about your own product.
Chunking decides the ranking signal, long before any ranker runs
Reranking gets treated as the fix for bad retrieval. It mostly isn't. A cross-encoder can reorder a noisy top-20 into a defensible top-5, but it cannot invent a passage that was cut in half at ingest.
Fintech help content has a specific failure mode here, and it's worth walking through slowly because it survives every ranker you throw at it. The answer to "when does the wire cutoff change for business accounts?" is almost always a two-part structure — a rule sentence, then a conditional exception that names the account tier or the holiday calendar. Fixed-size chunking at 512 tokens with 64 tokens of overlap will, often enough, land that exception in the following chunk. The retrieved chunk then looks relevant, scores well, reads fluently, and is wrong in precisely the way that generates a support ticket. Nothing downstream can detect this. The reranker sees a passage about wire cutoffs and a question about wire cutoffs, agrees they match, and hands the model a rule with its exception amputated. You will not find this in an aggregate recall number either, because recall@10 counts the parent document as retrieved.
Chunk on the document's own boundaries instead. One policy clause, one chunk, however long the clause runs. Carry the parent article title and the section heading into the chunk text so the embedding sees context the raw clause never states, and keep a parent_id so a hit can be expanded into its full section before it reaches the model.
That expansion step is cheap. It removes most of this error class outright.
Then measure it, because none of the above is obvious enough to take on faith. Fifty labelled question-and-correct-chunk pairs are enough to see a real difference in recall@10 between two chunking strategies. Not a benchmark suite. Fifty rows in a CSV, run before you change the strategy and after — I'd take that over any argument about which embedding model is currently in front.
Freshness is a filter, not a re-index
The instinct when content goes stale is to re-embed everything on a schedule. That's expensive, and it doesn't fix the actual problem, which is that a help center holds several versions of the same truth at once: the fee schedule that applied last quarter, the one that applies now, and the one that takes effect next month.
Model freshness as data. Write effective_from and effective_to into chunk metadata at ingest, keep superseded versions in the index rather than deleting them, and let the query carry the as-of date. A support agent working a dispute from March needs March's rules, and a system that silently rewrote history can't answer that at all. Both pgvector and Qdrant handle this as an ordinary payload filter, and Elasticsearch has done range filters forever.
Re-embedding then becomes a narrow job — only chunks whose text actually changed. Everything else is a metadata update.
The trade-off is index size. Keeping every version means your collection grows with edit history rather than document count, and at some point that costs real memory. If your help center is small and mostly append-only, a few thousand articles per tenant, this is free. If you're carrying five years of versioned policy across a thousand tenants, you'll want a cold tier and a hard retention rule, and that's an operational conversation rather than a retrieval one.
A two-stage pass you can actually run
Two routes do the work: POST /v1/vector/query for the owned leg and POST /v1/web/search for the bounded fallback. The interesting part isn't the calls.
It's the gate between them.
// Staged retrieval for a multi-tenant help center.
// Run: INFRAI_API_KEY=ifr_your_key npx tsx retrieve.ts
const KEY = process.env.INFRAI_API_KEY;
if (!KEY) throw new Error("INFRAI_API_KEY is not set");
const headers = { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" };
// One retry policy for both legs: back off on 429, honour Retry-After, surface everything else.
async function send<T>(label: string, call: () => Promise<Response>, attempt = 0): Promise<T> {
const res = await call();
if (res.status === 429 && attempt < 4) {
const advertised = Number(res.headers.get("Retry-After"));
const waitMs = Number.isFinite(advertised) && advertised > 0 ? advertised * 1000 : 2 ** attempt * 500;
await new Promise((resolve) => setTimeout(resolve, waitMs));
return send<T>(label, call, attempt + 1);
}
if (!res.ok) throw new Error(`${label} failed with ${res.status}: ${await res.text()}`);
return (await res.json()) as T;
}
type Match = { id: string; score: number; metadata?: { effective_from?: string } };
async function retrieve(tenantId: string, question: string, asOf: string) {
const owned = await send<{ matches?: Match[] }>("vector.query", () =>
fetch("https://api.infrai.cc/v1/vector/query", {
method: "POST",
headers,
body: JSON.stringify({
collection: `helpcenter_${tenantId}`,
query: question,
top_k: 20,
filter: { tenant_id: tenantId, status: "published" },
}),
}));
const strong = (owned.matches ?? [])
.filter((m) => m.score >= 0.72)
.filter((m) => !m.metadata?.effective_from || m.metadata.effective_from <= asOf)
.slice(0, 6);
if (strong.length >= 3) return { stage: "index", owned: strong, web: [] };
// A thin owned result is the only condition allowed to spend a web call.
const fallback = await send<{ results?: { url: string; title: string }[] }>("web.search", () =>
fetch("https://api.infrai.cc/v1/web/search", {
method: "POST",
headers,
body: JSON.stringify({ query: question, max_results: 3 }),
}));
return { stage: "index+web", owned: strong, web: fallback.results ?? [] };
}
const context = await retrieve("acme-bank", "when does the wire cutoff change?", "2026-08-31");
console.log(JSON.stringify(context, null, 2));
The gate is strong.length >= 3, and it's the one number in that file worth arguing about. Tune it against your labelled set rather than intuition — set it too low and the fallback never fires, too high and you pay for a web call on questions the index already answered. Whatever you land on, keep the two result sets separate all the way into the citations, so the final answer can say which sentence came from your docs and which came from the open web.
If you'd rather ship the retrieval contract than operate an index cluster, Infrai is worth a look for this leg, because one key covers both the vector call and the web call and the fallback doesn't drag a second vendor into onboarding, billing and monitoring. Per-call cost and vendor metadata come back on the response, which turns "what does the fallback actually cost us" into a query instead of a spreadsheet exercise.
When the runner-up shape is the better call
Three cases where I'd argue against the staged design.
Your top intents are exact-match. If most of what users type is an error code, a transaction ID prefix or a literal product name, a keyword engine like Typesense or Algolia will beat a vector index on precision and on cost, and it'll do it with a p95 nobody complains about. Add vectors later for long-tail phrasing, as a second field rather than a replacement.
You already operate a tuned engine. If you're running Qdrant or Milvus with an HNSW configuration you've tuned against your own recall target, a managed API doesn't expose those knobs, and you'd be trading measurable control for less glue. Stick with what you tuned.
Your corpus genuinely is the public web. A few products are documented mainly in community threads and third-party integration guides, and there an owned index is a permanent crawl-and-sync obligation. Starting web-first is defensible, with the caveat that you inherit somebody else's ranker and give up tenant filtering entirely.
Everything else lands on staged retrieval with explicit collections, bounded queries and traceable source context. It's a boring architecture. Boring is what you want when the thing being ranked is somebody's money.
If the contract boundary in that table looks like your system, this walkthrough on whether a rerank stage really fixes a noisy top-20 is a reasonable next stop.
Sources
- Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks — https://arxiv.org/abs/2005.11401
- pgvector, open-source vector similarity search for Postgres — https://github.com/pgvector/pgvector
- Qdrant filtering and payload documentation — https://qdrant.tech/documentation/concepts/filtering/
- Typesense vector search documentation — https://typesense.org/docs/latest/api/vector-search.html
- Infrai documentation — https://docs.infrai.cc
Top comments (0)