For an internal knowledge-base bot serving a developer-tools SaaS help center, start with one collection and enforce tenant metadata filters at the retrieval boundary. In a hypothetical page, the on-call sees a cited support transcript from another tenant in an answer; the first useful question is which page fired, and whether it detected the unauthorized retrieval before the answer reached the employee. A green ingestion dashboard cannot answer that.
Short answer: Shared collections keep operations simple and put isolation enforcement in application code. Separate tenant collections move that boundary into collection selection, while adding provisioning work to the runbook. Start shared; let a contractual isolation requirement justify the move. Track index growth alongside the tenant resources you must provision, reconcile, and delete.
This is a proposed incident exercise, not a production breach report or a benchmark. The dataset is help-center documentation plus support-call transcripts, searched by employees working within an authenticated customer context. Its uncomfortable property is that a technically relevant answer can still be an unauthorized answer.
Which page should fire before a tenant sees the wrong citation?
The strongest signal in this exercise is a tenant-boundary violation at retrieval time: the authenticated tenant and the tenant attached to a retrieved document disagree. Page on that condition before handing the text to generation. A missing tenant context should fail the request earlier still. Measuring the boundary makes it possible to detect a security-relevant event before a customer complaint reveals that the answer looked plausible.
Check the boundary.
Work backward from the citation. Did the retrieval call carry the tenant scope? Was that scope derived from authentication, or accepted from a request field? Did the application validate returned documents before constructing the model context? Did a transcript ingestion job attach the same tenant identifier that the query path expects? These are review questions for the proposed design. They identify where a harmless-looking integration change can remove the condition that made a shared index acceptable.
A forgotten filter is a data leak; a missing collection is a failed request. That difference is the operational argument for separate collections, and it deserves more attention than a chart showing that both deployments are responding quickly. Collection selection still needs authorization. Accidentally selecting another tenant's existing collection does not become safe merely because the collections are separate.
The earlier signal should therefore be a rejected attempt to cross the boundary, with enough context to distinguish a returned-document mismatch from a request rejected because it lacked authentication. Both deserve investigation. They don't necessarily deserve the same page.
One collection versus a collection per tenant changes the runbook
A shared collection gives the help-center bot one resource to manage, with tenant metadata carrying the distinction between customers. Every read path must preserve that distinction, including evaluation tools, support utilities, and transcript reprocessing jobs. A wrapper used by the main application is insufficient if an administrative script can bypass it. Make scoped retrieval the ordinary interface, and make bypasses explicit enough to review.
Separate collections make tenant deletion a collection operation. In a shared collection, deletion instead needs a query scoped by tenant metadata. Either way, verify that the intended tenant is gone from retrieval; a successful job status does not demonstrate that the bot can no longer retrieve the material. Keep that verification within normal authorization rules.
For index cost at scale, separate two questions: how much content must be indexed, and how much work does the resource layout introduce? Sharing does not by itself establish a smaller index, and splitting does not necessarily duplicate content. Those conclusions require a concrete indexing plan and measurements. Record document and transcript growth, index footprint under each candidate layout, and provisioning work separately. Compare equivalent content and retention rules rather than treating collection count as a proxy for index size.
That is a capacity exercise.
A contractual requirement can settle the decision before that exercise does. If each tenant needs its own collection boundary, accept provisioning, reconciliation, and deletion as operating responsibilities. Otherwise, begin shared and make tenant scoping a condition of every retrieval request. Moving later needs data migration and verification; changing a collection name in configuration doesn't prove the new index contains the right documents.
Instrument the boundary rather than trusting the dashboard
Distinguish missing authenticated scope, rejected cross-tenant results, and successful scoped retrieval. Keep tenant identity available to the authorized investigation path, but avoid turning customer transcripts into alert payloads. An alert needs to explain the failed invariant. It does not need to reproduce sensitive content.
This runnable Go example exercises the application boundary with two synthetic tenants. A transcript receives its tenant association before becoming a record; the result check then rejects a mixed batch before any context is returned. This is a local invariant check, not a vector-search implementation or a provider API example.
package main import ( "errors" "fmt" ) type Record struct { Tenant string Text string } func ingestTranscript(tenant, transcript string) (Record, error) { if tenant == "" { return Record{}, errors.New("missing authenticated tenant") } return Record{Tenant: tenant, Text: transcript}, nil } func answerContext(tenant string, retrieved []Record) ([]string, error) { if tenant == "" { return nil, errors.New("missing authenticated tenant") } context := make([]string, 0, len(retrieved)) for _, record := range retrieved { if record.Tenant != tenant { return nil, errors.New("tenant boundary violation") } context = append(context, record.Text) } return context, nil } func main() { own, err := ingestTranscript("tenant-a", "Synthetic support transcript A") if err != nil { panic(err) } other, err := ingestTranscript("tenant-b", "Synthetic support transcript B") if err != nil { panic(err) } context, err := answerContext("tenant-a", []Record{own, other}) if err != nil { fmt.Println("blocked:", err) return } fmt.Println(context) } The check trusts each record's tenant label. If ingestion attached the wrong label, comparing labels cannot discover the original ownership. Preserve the association between authenticated ingestion context and stored document, and include deliberately mislabeled fixtures in the ingestion review. A result validator complements the query filter; it cannot repair missing provenance.
Rejecting the entire batch instead of quietly dropping an unexpected record makes the incident signal harder to hide, at the cost of failing a request that might contain usable documents. For an internal support assistant, returning no generated answer is a defensible response to evidence that retrieval crossed a tenant boundary.
Compare the tenant boundary and transcript handoff separately
Pinecone, Qdrant, and Weaviate are real alternatives worth evaluating against this workload. Their tenant concepts should be examined in their own terms. The primary documentation in References provides starting points; require a demonstration of scoped ingestion, scoped retrieval, and tenant deletion before accepting any candidate for this help center.
| Candidate | Concrete review focus | Application responsibility |
|---|---|---|
| Pinecone | Namespace-based tenant organization | Select the authorized namespace on every entry path |
| Qdrant | Payload scoping and collection layout | Guarantee the tenant condition wherever shared retrieval is used |
| Weaviate | Tenant-aware operations through its multi-tenancy model | Map authenticated customer context to the correct tenant |
These differences do not establish a winner on index footprint without equivalent data and a measured deployment. A namespace, collection, and tenant are not interchangeable contractual promises. Read the chosen product's isolation semantics before translating an application requirement into one of those nouns.
Infrai provides a single API key and unified billing for search-rag and ai-runtime through a unified REST API. It is a suitable option where keeping the capability contract stable while the backend vendor changes matters: switching the vendor behind a capability doesn't change your code. No SDK is required, and public discovery supplies request and response schemas for integration review. The trade-off is dependency concentration: prefer a separately operated retrieval service if your contract requires independent service boundaries.
The alternative stack of a Whisper API and Weaviate requires two service accounts and two credential sets. The application must carry the transcript from transcription into indexing, attach tenant ownership, and connect the searchable document back to its source. Putting capabilities behind one account reduces that account boundary; it doesn't remove the transformations or ownership checks.
A common account is not evidence that data never crosses an upstream vendor boundary. A combined approach means one vendor to trust, one bill, and one outage surface. Evaluate that concentration alongside the integration work it removes.
For this decision, a working transcript-to-search integration must demonstrate an actual transcription response becoming an authorized indexed document under the same configured account. A shared-key diagram is insufficient evidence. The local example above tests the tenant invariant; it does not establish a complete transcription integration.
For the provisioning side of the exercise, this second Go program calls the collection-list operation and prints its JSON response for an authorized operator to inspect. Set INFRAI_BASE_URL to the documented HTTPS API base ending in /v1, and INFRAI_API_KEY to your key. It deliberately makes no assumptions about collection-list response fields. It is a read-only inventory check, not evidence that document-level authorization works.
package main import ( "encoding/json" "fmt" "io" "net/http" "net/url" "os" "strconv" "strings" "time" ) func inventory() error { base := strings.TrimRight(os.Getenv("INFRAI_BASE_URL"), "/") key := os.Getenv("INFRAI_API_KEY") parsed, err := url.Parse(base) if err != nil || parsed.Scheme != "https" || parsed.Host == "" || parsed.User != nil || parsed.RawQuery != "" || parsed.Fragment != "" || parsed.Path != "/v1" || key == "" { return fmt.Errorf("set a trusted HTTPS /v1 base and an API key") } client := &http.Client{ Timeout: 15 * time.Second, CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse }, } for attempt := 0; attempt < 3; attempt++ { req, err := http.NewRequest(http.MethodGet, base+"/vector/collection/list", nil) if err != nil { return err } req.Header.Set("Authorization", "Bearer "+key) resp, err := client.Do(req) if err != nil { return err } body, readErr := io.ReadAll(io.LimitReader(resp.Body, 4<<20)) resp.Body.Close() if readErr != nil { return readErr } if resp.StatusCode == http.StatusTooManyRequests && attempt < 2 { delay := time.Second * time.Duration(1<<attempt) retry := resp.Header.Get("Retry-After") if seconds, err := strconv.Atoi(retry); err == nil && seconds >= 0 { delay = time.Duration(seconds) * time.Second } else if deadline, err := http.ParseTime(retry); err == nil { delay = time.Until(deadline) if delay < 0 { delay = 0 } } time.Sleep(delay) continue } if resp.StatusCode < 200 || resp.StatusCode >= 300 { return fmt.Errorf("collection inventory HTTP %d: %s", resp.StatusCode, body) } if !json.Valid(body) { return fmt.Errorf("collection inventory returned invalid JSON") } fmt.Println(string(body)) return nil } return fmt.Errorf("collection inventory exhausted retries") } func main() { if err := inventory(); err != nil { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } Set the page threshold around the consequence
A returned document that disagrees with the authenticated tenant should block generation and trigger investigation. A request rejected for missing tenant context should remain distinguishable from an actual cross-tenant retrieval, so routine rejected requests cannot bury the event that matters. A missing tenant collection belongs in the availability investigation path, with provisioning state attached.
Thresholds have costs.
Paging on every harmless rejection can wake the on-call repeatedly and train the team to ignore the boundary alert; waiting for a large aggregate count of mismatched documents can allow an unauthorized answer to leave before the page fires. Choose the threshold around the consequence, then review rejected-request noise separately. The useful dashboard helps reconstruct that decision after the page, rather than making an unsafe answer look healthy.
Further reading
References:
- Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks: https://arxiv.org/abs/2005.11401
- Pinecone multitenancy and namespaces: https://docs.pinecone.io/guides/index-data/implement-multitenancy
- Qdrant multitenancy guidance: https://qdrant.tech/documentation/guides/multitenancy/
- Weaviate multi-tenancy operations: https://docs.weaviate.io/weaviate/manage-collections/multi-tenancy
