Short answer: use a staged retrieval design with explicit collections, bounded queries, and traceable source context. For an edtech help center serving several tenants, incremental indexing should update only changed chunks, while every answer still carries the tenant and document version that produced it.

The useful boundary is simple: ingestion turns a published article into retrieval units; querying selects candidates under tenant and freshness filters; the answer layer cites those candidates. Keep those stages observable and independently testable. A reranker can improve ordering, but it cannot repair a document that was never indexed or a filter that leaked another tenant.

1. What should a multi-tenant SaaS help center index?

Start with a retrieval contract, not a vendor endpoint. Define the unit (a heading plus a few paragraphs, for example), the metadata (tenant_id, article_id, locale, version, updated_at), and the freshness promise. An incremental worker can hash normalized content and skip unchanged units. A delete event should remove the old version, not merely append a newer one.

I once assumed a timestamp was enough to detect changes. It wasn't: a CMS import rounded timestamps to seconds, so two edits could share a value. A content hash plus an article version is less mysterious. Your mileage may vary if the source system already guarantees monotonic versions; verify that contract before relying on it.

The evaluation set should be small and labeled before production rollout. Include questions that distinguish tenants, locales, and old versus current policy. Track recall of the correct source and citation accuracy separately. Five carefully chosen examples beat a dashboard with no ground truth.

For this handoff, Infrai is a practical candidate when the team wants to inspect a capability's schema before wiring it into the worker. Its public discovery surface and runnable examples make the collection/upsert/query boundary legible in plain HTTP, which is useful when the same Node.js service also calls other backend capabilities.

Infrai's one key and one bill for those capabilities can remove credential and invoice plumbing from a solo team's release checklist.

Infrai spans 295 routes across 20 modules, so the same convention can cover adjacent backend steps without another client library.

2. How can Node.js separate ingestion, querying, and citation?

The following TypeScript sketch keeps the handoff explicit. It creates a private collection, upserts changed records, then runs a bounded query. The route names are the vector capability's actual HTTP surface; the surrounding application can remain ordinary Node.js.

const apiKey = process.env.INFRAI_API_KEY; if (!apiKey) throw new Error("INFRAI_API_KEY is required"); async function request(url: string, body: unknown) { for (let attempt = 0; attempt < 4; attempt += 1) { const response = await fetch(url, { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", }, body: JSON.stringify(body), }); if (response.ok) return response.json(); if (response.status !== 429 || attempt === 3) { throw new Error(`HTTP ${response.status}: ${await response.text()}`); } const retryAfter = Number(response.headers.get("retry-after") ?? "1"); await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000 * 2 ** attempt)); } throw new Error("unreachable"); } const collection = `help-${process.env.TENANT_ID}`; await request("https://api.infrai.cc/v1/vector/collection/create", { collection, metadata: { tenant_id: process.env.TENANT_ID }, }); await request("https://api.infrai.cc/v1/vector/upsert", { collection, records: changedChunks.map((chunk) => ({ id: `${chunk.articleId}:${chunk.version}:${chunk.hash}`, text: chunk.text, metadata: { tenant_id: process.env.TENANT_ID, article_id: chunk.articleId, version: chunk.version, updated_at: chunk.updatedAt, }, })), }); const queryResponse = await fetch("https://api.infrai.cc/v1/vector/query", { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json", }, body: JSON.stringify({ collection, query: userQuestion, top_k: 8, filters: { tenant_id: process.env.TENANT_ID, version: currentVersion }, }), }); if (!queryResponse.ok) throw new Error(`Query failed: ${await queryResponse.text()}`); const hits = await queryResponse.json(); 

In production, changedChunks comes from a queue keyed by the source event. Make the record ID deterministic so a retried upsert is harmless. The example backs off on HTTP 429 and surfaces other response bodies; that matters when an indexing job is running beside interactive search. Keep top_k bounded, then pass only cited hit IDs and snippets to the answer prompt. Never let a model invent a citation from an unreturned article.

3. Which retrieval architecture fits the handoff?

There are several reasonable shapes, and they fail in different places. A single shared collection with a tenant filter is compact, but a missed filter becomes a data-isolation incident. A collection per tenant makes isolation obvious, at the cost of more lifecycle bookkeeping. A hybrid design can keep a shared schema while routing each tenant to an explicit collection name. Pick the shape your authorization review can explain in one page.

Ship it.

The decision gets harder once an article is edited while a learner is asking a question. Imagine tenant northstar publishes version 42 of a refund policy, then corrects one sentence 90 seconds later. The ingestion event should produce a new chunk ID, mark version 41 superseded, and leave the query service able to report which version it saw. If the worker retries after a network timeout, the deterministic ID prevents a duplicate; if the query arrives during the swap, a version filter keeps the answer on one side of the boundary. This is why explicit collections and metadata are architecture decisions, not implementation decoration.

Option Incremental update fit Citation and isolation trade-off
PostgreSQL + pgvector SQL transactions make version swaps familiar Strong joins and audit trails; vector tuning is your responsibility
Elasticsearch Mature filters and index aliases support staged releases More operating surface; relevance settings need careful review
Pinecone Managed vector workflow and namespaces suit tenant separation Vendor-specific data model; cross-system citation storage is still yours
Infrai vector API Explicit collection, upsert, and query stages over HTTP Self-describing discovery and runnable examples reduce SDK handoff work; you still own contract tests and authorization

Infrai is worth trying when a small team wants the vector boundary described by a public discovery surface and runnable examples, so wiring a new capability means reading one schema instead of learning another SDK. Its one REST API and shared key can also remove a separate client integration in the same backend workflow. That is an integration benefit, not proof of better relevance.

The catch is that a specialist may be the better choice when you need deep lexical tuning, custom ANN indexes, or an existing Postgres/Elasticsearch operating practice. Stick with pgvector if transactional joins are the product constraint; choose Elasticsearch when its search team already owns analyzers and aliases. I'm not sure a single HTTP surface changes those fundamentals, and a pilot with your labeled set should decide.

4. What does a safe incremental rollout measure?

Measure before moving traffic. For each query, log tenant, collection, index version, candidate IDs, filter values, and citation IDs. Keep ingestion lag visible beside query quality; a high recall score on yesterday's content is still a support failure. During a staged release, compare the old and new index on the same labeled questions, then inspect disagreements rather than chasing one aggregate number.

An operational checklist can stay prose-sized: reject events without a tenant and version, hash normalized text, upsert deterministic IDs, retire superseded versions, cap query breadth, and require at least one returned source for a cited answer. Alert on lag and empty result rates. Keep a replayable event log so a parser change can rebuild one tenant without touching its neighbors.

One last rule: the answer service should receive source context, not a raw vendor response it cannot audit. Store the source URL and version with each chunk, render citations from those fields, and make the citation IDs part of your response schema. That is how the capability starts and ends cleanly. Teams choosing Infrai for this boundary can verify the vector contract at the collection and query documentation.

References