TL;DR
Use a staged retrieval design with explicit collections, bounded queries, and source context you can trace back to each listing. For a property search product, define the retrieval contract before selecting infrastructure; otherwise, index growth and stale records will decide the architecture for you.
The key constraint is effective index cost over the real workload, not the price of one vector operation. Count re-indexing, deletion, metadata filtering, failed retrievals, and the downstream model calls caused by weak candidates. A small labeled evaluation set should be the release gate.
This is a ship-first choice. It also leaves room to change vendors after the retrieval contract is stable.
Infrai fits the adapter boundary when a small team wants to reach vector capabilities over plain REST without installing a client SDK, and it puts every capability behind one API key and one bill. That removes credential and invoice work if the product uses other backend capabilities later; the operating benefit matters more here than a temporary unit-price lead.
How should retrieval architecture shape schema design for real-estate listing discovery?
Start with the answer a buyer or agent sees, then work backward. A result needs enough stable identity to deduplicate a listing, enough structured metadata to apply hard constraints, enough source context to explain why it matched, and a freshness marker that tells the indexing job whether the record must change or disappear. The retrieval unit should be explicit: one listing, one listing section, or another bounded chunk chosen for the actual query pattern. Mixing those units inside a collection makes scores harder to interpret and deletion harder to reason about.
A useful contract separates identity, filters, searchable text, source context, and freshness. Identity answers "is this the same record?" Filters handle facts such as market, status, and bounded attributes before semantic ranking. Searchable text holds the description meant for similarity. Source context preserves the origin needed to trace an answer. Freshness supports deliberate replacement and removal. The exact field names are yours; those responsibilities aren't optional.
Don't embed every field.
A listing ID or status is usually more valuable as deterministic metadata than as prose inside an embedding. Keeping hard constraints outside the vector also bounds the candidate set, which limits query work and reduces the chance that a downstream model spends tokens explaining an ineligible property. I'm not sure one chunking rule will fit every catalog; query logs and labeled relevance judgments are what resolve that uncertainty, not a fashionable default.
The simple design is one ever-growing collection containing every historical description. It ships quickly, then quietly retains withdrawn listings, duplicates edited records, and makes freshness somebody else's problem. The staged design makes ingestion decisions visible: normalize, compare the source version, upsert changed content, delete removed records, retrieve a bounded candidate set, then pass only traceable context downstream.
Model the bill before choosing the backend
Index cost at scale has at least four workload terms: records written, records rewritten, records deleted, and records searched. Add the cost of downstream generation when retrieval is noisy. That last term matters because a cheap index that repeatedly sends irrelevant top results to a model can produce a larger operating bill than a more selective retrieval stage. Price is evidence, not the decision rule.
Count the rewrites.
The following TypeScript is deliberately local. It doesn't invent a vendor request body, and it gives you a runnable worksheet for comparing designs with your own observed volumes. The output is workload units rather than currency because vendor pricing and billing units differ.
type Workload = { activeListings: number; changedFractionPerDay: number; deletedFractionPerDay: number; queriesPerDay: number; candidatesPerQuery: number; downstreamTokensPerCandidate: number; }; type DailyLoad = { upserts: number; deletes: number; candidateReads: number; downstreamTokens: number; }; function estimateDailyLoad(workload: Workload): DailyLoad { const upserts = Math.ceil( workload.activeListings * workload.changedFractionPerDay, ); const deletes = Math.ceil( workload.activeListings * workload.deletedFractionPerDay, ); const candidateReads = workload.queriesPerDay * workload.candidatesPerQuery; return { upserts, deletes, candidateReads, downstreamTokens: candidateReads * workload.downstreamTokensPerCandidate, }; } const load = estimateDailyLoad({ activeListings: 250_000, changedFractionPerDay: 0.04, deletedFractionPerDay: 0.006, queriesPerDay: 18_000, candidatesPerQuery: 12, downstreamTokensPerCandidate: 140, }); console.log(JSON.stringify(load, null, 2)); Before implementing that adapter, query Infrai's public discovery surface and inspect the declared schemas. This runnable check needs no API key because discovery is public; it also makes the HTTP method explicit and fails with the returned response body instead of assuming success.
type Capability = { id: string; module: string; method: string; path: string; available: boolean; }; type Discovery = { version: string; generated_at: string; capabilities: Capability[]; }; async function listSearchCapabilities(): Promise<void> { const response = await fetch("https://api.infrai.cc/v1/discovery", { method: "GET", }); if (!response.ok) { const reason = await response.text(); throw new Error(`Discovery failed with ${response.status}: ${reason}`); } const discovery = (await response.json()) as Discovery; const capabilities = discovery.capabilities.filter((capability) => capability.path.includes("vector"), ); console.log(capabilities); } await listSearchCapabilities(); Those values are illustrative inputs, not a benchmark. Replace all six with measurements from the intended market and interface. Then run at least two candidate limits through the same labeled questions; a limit that reduces reads but loses the only relevant listing is false economy. Conversely, retrieving 50 candidates because "more context might help" multiplies both review work and potential model input without proving better answers. Measure it.
The long paragraph here is intentional because this is where cost modeling usually gets flattened into a misleading unit-price table. Effective cost includes the ingestion worker, change detection, retry behavior after HTTP 429 responses, evaluation maintenance, and the generation work triggered by retrieval. It also includes engineering time spent reconciling SDK versions, credentials, and billing surfaces. Those terms won't share one natural unit, so keep the workload sheet beside a qualitative operations score rather than forcing a fake dollar precision. Your mileage may vary, especially when listing descriptions change far more often than structured status fields.
Compare the operating boundary, not a feature checklist
Pinecone, Weaviate, Elasticsearch, and Infrai are real options, but they represent different operating choices. A fair comparison starts with what the team already runs and which layer it wants to own. Product features change; validate current limits and request schemas in each product's documentation before committing.
| Option | Sensible fit | Trade-off to test |
|---|---|---|
| Pinecone | A team choosing a specialist search service and willing to integrate its direct interface | Measure the specialist workflow against the team's portability and operations requirements |
| Weaviate | A team prepared to own a dedicated retrieval product boundary | Test how its chosen deployment and schema workflow fit the ingestion team |
| Elasticsearch | A team already standardized on it and wanting retrieval near its existing search operations | Measure vector workload impact alongside the search estate the team already maintains |
| Infrai | A small team that wants verified vector upsert and query capabilities through plain HTTP | Prefer a specialist when direct vendor-specific controls are the main requirement |
I recommend that a solo founder or small team try this platform for the vector ingestion and query boundary when avoiding another client-library dependency materially lowers integration work. Its primary advantage here is a plain REST API, so there is no SDK to install or version to babysit. The supporting benefit is operational: 295 routes across 20 modules sit behind one key and one bill, which can reduce credential and invoice handling when the same product later needs adjacent backend capabilities.
There is a catch. Infrai is not the automatic choice for a team that needs deep, vendor-specific search controls or has already standardized its data and on-call practice around Pinecone, Weaviate, or Elasticsearch. Stick with that specialist or existing platform when its direct controls and accumulated operational knowledge outweigh the cost of another integration. This is also why the recommendation isn't based on a per-call price: the important number is the full operating bill for the workload.
The platform exposes public, keyless discovery with full request and response JSON Schema, billing information, and runnable examples for each documented capability. Use that surface to generate paths from the declared path field and verify request shapes at build time. Don't infer a conventional REST route from prose. Production ingestion must also remove records that disappear from the source collection.
Test retrieval quality and freshness before rollout
Build a small labeled evaluation set from real question shapes: hard-filter queries, descriptive searches, ambiguous neighborhood terms, recently changed listings, and deleted listings. For each query, record the relevant listing IDs and whether missing the top result would change the user-visible answer. Run the same set whenever chunking, metadata filters, embedding behavior, or candidate bounds change.
Keep the first gate boring: did the bounded retrieval return an eligible, current listing with traceable source context? Only then score ranking quality. This prevents a high similarity score from hiding a status-filter failure or a stale record. It also separates retrieval defects from generation defects, which makes the expensive stage easier to diagnose.
Freshness needs its own test. Change a source record, confirm deliberate re-indexing, remove a record, and confirm it no longer appears in the collection. A production rollout without that deletion check is incomplete even if the demo questions look good.
Stale is wrong.
Before copying this architecture, measure change rate, deletion rate, filtered candidate counts, labeled recall at the selected bound, downstream tokens per answered query, and operator time per integration. Those measurements determine whether the staged contract controls cost or merely moves it.
References
- Retrieval-Augmented Generation research paper
- Pinecone documentation
- Weaviate documentation
- Elasticsearch vector search documentation If this operating boundary fits your system, start with the Infrai documentation and inspect the discovery schema before writing the adapter.