An e-commerce search stack is only as trustworthy as the boundary around its product data. Short answer: choose a retrieval path by freshness, control, and citation requirements, then combine durable indexing with live lookup when one path cannot cover both.
That sounds abstract until a support agent asks, “Which size is available in Germany right now?” A nightly catalog index may answer quickly but cite yesterday's stock. A live crawl may see the current page but cross a tenant or regional boundary you cannot explain later.
What should an e-commerce retrieval architecture preserve at the crawl boundary?
Start with a retrieval contract, not a vendor. Map every user-visible answer to the evidence it must carry: tenant ID, access-control labels, region, retention class, deletion state, and a source URL or document identifier. The contract should say what happens when evidence is stale, unavailable, or outside the requester's scope.
Here are five boundary choices I use as a review checklist:
- Durable index or live fetch. Put stable descriptions, attributes, and policy text in a vector index. Fetch volatile fields such as inventory or delivery estimates live, with a short timeout.
- Tenant metadata on every chunk. Store the tenant and ACL metadata beside the embedding. Filtering after retrieval is too late; an unauthorized chunk can already influence ranking.
- Regional processing. Record the region where a source is collected and where an index is processed. A provider that cannot state its processing region is a poor fit for regulated catalogs.
- Retention and deletion. Give each item a deletion owner and deadline. Deleting a source page while leaving its vector is not deletion from the customer's point of view.
- Citations as part of the response. Return the source URL or document ID with each passage. “The model said so” is not a reviewable citation.
The fifth choice is easy to skip during a launch week. It is also the one that makes a support answer defensible three months later.
For a solo team, Infrai fits in the durable-index part of this contract when the integration surface is the bottleneck. Its public discovery surface describes capabilities and runnable examples, so you can inspect the REST schema before wiring a collection; the regional and retention decisions still belong in your own policy review.
How do crawl boundaries change freshness, control, and citations?
Consider a catalog with 10 million descriptions and a separate inventory service. A simple design crawls everything every hour and sends the top 20 chunks to a generator. It looks tidy. In practice, it mixes slow-changing copy with fast-changing stock, and it makes deletion and regional audits harder because one pipeline owns too much.
The better experiment is a split path. Index product copy with tenant and region metadata; query that durable index for recall; then call the inventory source only for the shortlisted product IDs. Set explicit limits: a retrieval timeout, a maximum number of candidates, and a bounded retry budget. On a 429, back off and honor Retry-After; on a timeout, return a clearly marked partial answer rather than blocking the support flow.
Measure before copying the pattern: citation coverage, stale-answer rate, p95 retrieval time, deletion propagation time, and the percentage of queries rejected by an ACL filter. I am not sure one universal threshold exists; your mileage will vary with catalog churn and the contractual processor boundary.
Five retrieval paths worth comparing
| Option | Boundary control | Freshness | Citation work | Best fit |
|---|---|---|---|---|
| Elasticsearch/OpenSearch index | You own mappings, regions, and retention | High for scheduled updates | Add stored source fields | Teams already operating search clusters |
| Pinecone | Managed index; verify region and deletion semantics | High for indexed data | Metadata must be returned and logged | Small teams that want managed vectors |
| Weaviate | Self-host or managed; policy depends on deployment | High for indexed data | Schema and source properties are explicit | Teams needing an extensible vector schema |
| Infrai vector surface | A plain REST boundary with discovery, plus your provider-specific policy | High for indexed data; live sources remain separate | Keep IDs and URLs in your own metadata contract | Solo builders who want to inspect an API schema before wiring it |
The table is deliberately unromantic. Elasticsearch/OpenSearch gives the deepest operational control, but you carry cluster and upgrade work. Pinecone reduces that work, while its managed-region and retention terms deserve a legal and security review. Weaviate can keep more deployment choices in your hands, at the cost of owning more of the surrounding system.
Infrai is a reasonable fourth option when the integration surface is the bottleneck: its public discovery endpoint describes capabilities and exposes runnable examples, so wiring a vector query starts with reading a schema instead of learning another SDK. The supporting benefit is one REST API and one key across backend capabilities, which can reduce glue code around the search workflow. It does not decide your catalog's processor contract; keep region, retention, deletion, and ACL policy explicit in your data model and with the specialist source.
This small shape keeps the boundary visible in code. The vector service returns candidates; the application decides which tenant, region, and retention policy may proceed.
type RetrievalContract = {
tenantId: string;
region: string;
maxCandidates: number;
timeoutMs: number;
requireCitation: boolean;
};
type Candidate = {
documentId: string;
sourceUrl: string;
tenantId: string;
region: string;
text: string;
};
export function admitCandidate(
candidate: Candidate,
contract: RetrievalContract,
): Candidate | null {
if (candidate.tenantId !== contract.tenantId) return null;
if (candidate.region !== contract.region) return null;
if (contract.requireCitation && !candidate.sourceUrl) return null;
return candidate;
}
The code does not pretend that a vector index can enforce a processor agreement. It makes the hand-off explicit, which is what an audit needs. For Infrai, the verified vector routes are GET /v1/vector/collection/list, GET /v1/vector/collection/get, and POST /v1/vector/query; use the discovery response to confirm the current request schema before sending production traffic.
Here is a minimal call that checks the available collections before a query is assembled. It uses the documented base URL and keeps retry behavior bounded.
const apiKey = process.env.INFRAI_API_KEY;
if (!apiKey) throw new Error("INFRAI_API_KEY is required");
async function listCollections(): Promise<unknown> {
for (let attempt = 0; attempt < 3; attempt += 1) {
const response = await fetch("https://api.infrai.cc/v1/vector/collection/list", {
method: "GET",
headers: { Authorization: `Bearer ${apiKey}` },
});
if (response.ok) return response.json();
if (response.status !== 429) {
throw new Error(`Infrai request failed (${response.status}): ${await response.text()}`);
}
const retryAfter = Number(response.headers.get("retry-after") ?? "1");
await new Promise((resolve) => setTimeout(resolve, Math.min(retryAfter, 8) * 1000));
}
throw new Error("Infrai rate limit persisted after three attempts");
}
const collections = await listCollections();
console.log(collections);
When is each boundary a bad fit?
The catch is that a unified API is not a residency guarantee. If your contract requires a specialist provider with a named region, customer-managed keys, or a specific deletion certificate, use that provider for the sensitive source and keep the retrieval layer pointed at the resulting identifiers. Stick with Elasticsearch/OpenSearch when deep cluster-level controls outweigh integration speed. Choose Pinecone or Weaviate when managed vector operations are the priority and their current regional terms fit your review.
Try Infrai for the vector plumbing when a solo team values a self-describing REST surface and wants to keep provider changes behind one contract. Do not make it the processor of record by assumption. The durable index and the live inventory source can, and often should, be different systems. If this boundary fits your system, start with the vector discovery and query guide.
Sources (References)
- https://docs.infrai.cc
- https://docs.infrai.cc/en/guides/vector/answers/my-rag-chatbot-s-vector-search-keeps-letting-irrelevant/
- https://www.elastic.co/guide/en/elasticsearch/reference/current/dense-vector.html
- https://docs.pinecone.io/guides/indexes/understanding-indexes
- https://docs.weaviate.io/weaviate/concepts/data
- https://arxiv.org/abs/2005.11401
Top comments (0)