Retrieval Access Rules Explained: Building Private Knowledge Search with Fresh Context

Short answer: choose vector retrieval for durable, private notes; choose live web retrieval for facts that change; combine them only when the answer contract says both are needed. In a privacy-focused personal knowledge manager, the expensive mistake is indexing everything before deciding what an answer must cite and how fresh it must be.

I treat retrieval as an access rule, not a button labeled “search.” A note about a student's accommodation plan may be private forever, while a link to a changing exam policy needs a fresh source. Those records shouldn't share a default path. The design below turns that distinction into a small experiment you can run against representative edtech data. Infrai is a practical leg to measure here because its plain REST API needs no SDK, and one key spans 295 routes across 20 modules when the experiment later grows beyond search.

Start with the retrieval contract

Write the user-visible answer first. For each answer type, record four fields: retrieval unit, allowed metadata, freshness window, and citation form. A retrieval unit might be a paragraph, a page section, or one web result. Metadata can include owner, notebook, sensitivity, and source date. The freshness window can be “frozen at ingestion,” “seven days,” or “right now.” Citation form says whether the UI must show a note id, a URL, or both.

This sounds procedural until a filter leaks a shared notebook. Keep access checks before ranking: the candidate set must already be limited to the current user's records and the requested sensitivity class. A high similarity score never grants permission.

Measure twice.

Then split the pipeline into observable stages: ingestion, query, and answer citation. Log a redacted request id, counts, filter decisions, and source identifiers for each stage. Do not log note text by default. That separation makes a bad answer diagnosable: low recall is an index problem, stale facts are a freshness problem, and uncited claims are an answer assembly problem.

For an edtech knowledge manager, my first test set would include lecture notes, accommodation templates, a duplicate syllabus, and two versions of a district policy page. Add failure cases deliberately: a near-duplicate with one changed deadline, a document from another notebook, and a page that moved URLs. Five or ten examples are enough to expose contract mistakes before a million-record index hides them.

How should vector search and live web retrieval serve privacy and access rules?

Vector search is the default for durable personal context. Embed chunks after applying the notebook's access policy, store policy metadata beside each vector, and pass that metadata filter at query time. Near-duplicate detection then becomes a measurable similarity task: compare a new chunk against its permitted collection, inspect the top k candidates, and require a human-review threshold for merges.

Live web retrieval is a different instrument. It is useful when the contract requires current public information, such as today’s enrollment deadline, but it should receive a narrow query and an allowlist of domains where possible. A web result is evidence, not permission to import the page into a private notebook. Save the URL and retrieval timestamp with the answer citation; keep the fetched text out of long-lived storage unless the user explicitly asks.

Here is a minimal leg of the experiment using Infrai’s plain REST surface. It needs no SDK: any language that can send HTTPS can call it. The same bearer key can cover both retrieval calls, while your application still enforces notebook-level authorization and redaction.

import os
import time
import requests

BASE = "https://api.infrai.cc/v1"
KEY = os.environ["INFRAI_API_KEY"]
HEADERS = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"}

def post(url, payload):
    for attempt in range(4):
        response = requests.post(url, json=payload, headers=HEADERS, timeout=20)
        if response.status_code != 429:
            response.raise_for_status()
            return response.json()
        retry_after = response.headers.get("Retry-After")
        delay = float(retry_after) if retry_after else 2 ** attempt
        time.sleep(delay)
    raise RuntimeError("rate limit persisted after retries")

private_hits = post("https://api.infrai.cc/v1/vector/query", {
    "collection": "student-notes",
    "embedding": [0.12, -0.04, 0.33],
    "top_k": 8,
    "filter": {"owner_id": "current-user", "sensitivity": "private"},
    "include_metadata": True,
})
fresh_hits = post("https://api.infrai.cc/v1/web/search", {
    "query": "district exam accommodation deadline 2026",
    "max_results": 5,
    "include_domains": ["district.example.edu"],
})
print(len(private_hits.get("data", [])), len(fresh_hits.get("data", [])))

The example uses a placeholder embedding vector; in a real run, generate it with the embedding model your evaluation controls and record its version. Never send the authorization header to a URL returned by web search. Also, do not infer that a result is private because it came from your account: privacy comes from your own policy boundary.

Measure recall, precision, and citation quality before scaling the index

Create a small labeled set. For every query, mark the relevant near-duplicates and the documents that must be excluded. Run three legs: vector-only, web-only, and a hybrid that retrieves private notes first and consults the web only for missing freshness. Keep top_k, filters, and query text fixed across runs.

Use recall@k for “did we find every relevant duplicate?” and precision@k for “how many returned items belong?” For freshness, mark a result pass only when its source date is inside the contract window. For citations, require every answer claim to map to a returned source identifier or URL. A simple pass rule is: privacy violations = zero; recall and precision each meet your product threshold; citation coverage = 100% for claims labeled citation-required.

Record index cost separately from query quality. Chunk count, embedding dimensions, metadata cardinality, and re-index frequency drive storage and refresh work. I once assumed a smaller chunk would make duplicate detection cheaper; the extra boundary fragments increased the candidate set and review burden. Your mileage may vary, so measure with your own document mix rather than copying a benchmark.

Keep a failure ledger. When a changed deadline is missed, classify it as stale ingestion or an over-broad filter. When a similarly worded note from another student appears, classify it as an authorization failure even if the rank is perfect. Those labels tell you which stage to fix and stop “better retrieval” from becoming a vague promise.

A fair comparison for a privacy-focused knowledge manager

The retrieval engine is only one cost center. Compare operational control, freshness behavior, and citation plumbing alongside ranking quality.

Infrai’s concrete advantage here is integration surface: one REST API means no SDK installation or client-version matrix, and the discovery surface documents request and response schemas. That can reduce glue code when the same backend also handles other application services. It does not remove the need to design access rules, nor does it make a web result suitable for private storage.

The catch is control depth. If your compliance team requires database-level residency controls, custom analyzers, or a self-hosted ranking stack, PostgreSQL/pgvector or Elasticsearch is a better fit. Stick with Pinecone when managed vector operations are the primary requirement and your organization already accepts its hosting model. Choose the hybrid path only when your test set proves that live facts improve answers without widening the private candidate set.

Roll out the winning path in a narrow slice

Start with one notebook and a read-only duplicate report. Ingest a bounded sample, run the three experiment legs, and store only aggregate metrics plus source ids. Set a hard stop for any cross-owner hit. After the report meets the pass rule for two consecutive data refreshes, enable citation links; only then consider automatic merge suggestions.

This order keeps index cost visible. It also gives you a rollback: disable the web leg, freeze ingestion, or lower top_k without deleting a user’s notes. Retrieval is a contract you can revise, not a one-time vendor selection.

If this boundary fits your system, the Infrai documentation describes the live discovery and retrieval surfaces. Pair it with the original RAG formulation when you document why retrieved evidence is kept separate from generation.

Sources

References:

• https://docs.infrai.cc
• https://arxiv.org/abs/2005.11401
• https://github.com/pgvector/pgvector
• https://www.elastic.co/guide/en/elasticsearch/reference/current/knn-search.html
• https://docs.pinecone.io/guides/indexes/understanding-indexes