flowchart LR
  Q["Query"] --> H(("Hybrid
retrieve"))
  H --> RR["Re-rank"]
  RR --> AS["Assemble
to budget"]
  AS --> M{"Model"}
  classDef s fill:#DCEBFE,stroke:#1F2937,color:#0E1726;
  classDef m fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class RR,AS s;
  class M m;
        

Five decisions turn this generic shape into your pipeline. That's the whole deliverable.

flowchart LR
  S["1 Sources"] --> C["2 Chunking"]
  C --> R["3 Retrieval"]
  R --> K["4 Ranking"]
  K --> A["5 Assembly"]
  A --> M{"Model"}
  classDef d fill:#DCEBFE,stroke:#1F2937,color:#0E1726;
  classDef m fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class S,C,R,K,A d;
  class M m;
        

Fill these five boxes and the design is done. The rest of tonight is defending each choice out loud.

# retrieval config · support assistant
sources:  help_center, resolved_tickets
filter:   plan_tier == user.plan          # access check BEFORE retrieval
retrieve: hybrid(bm25 + dense), top_k=40
rerank:   cross_encoder, keep=5, min_score=0.35
assemble: budget=3000 tokens, best_chunk_last, cite=true
fallback: if max_score < 0.35: say_no_answer()  # never invent

# window budget · support assistant
model_window:   16000 tokens
reserve:        system 400 + question 200 + answer 1200
context_budget: 3000 tokens        # the rest is headroom, not fuel

order:   best_chunk_last          # nearest the question, beats lost-in-the-middle
dedup:   drop near-identical chunks before counting tokens
cut:     lowest-ranked first until under_budget
cite:    keep source + url on every chunk that survives

flowchart LR
  subgraph IDX["Indexing: offline, scheduled"]
    direction LR
    D["Docs"] --> CH["Chunk"] --> EM["Embed"] --> VS[("Vector
store")]
  end
  subgraph QRY["Query: online, per request"]
    direction LR
    Q["Question"] --> QE["Embed"] --> RT["Retrieve"] --> RK["Re-rank"] --> AS["Assemble"] --> G{"LLM"} --> AN["Answer"]
  end
  VS -.-> RT
  classDef s fill:#DCEBFE,stroke:#1F2937,color:#0E1726;
  classDef m fill:#EEE6FF,stroke:#1F2937,color:#0E1726;
  class CH,EM,RT,RK,AS s;
  class G m;
        

// ingest.ts: runs offline, on a schedule (nightly re-index)
import { embed, chunk } from "./common/llm";
import { vectors } from "./common/store";

for (const doc of await loadDocs()) {          // help articles + tickets
  for (const part of chunk(doc, { unit: "section", overlap: 0.15 })) {
    const vector = await embed(part.text);          // one vector per chunk
    await vectors.upsert({
      id: part.id,
      values: vector,
      metadata: { url: doc.url, planTier: doc.planTier, updatedAt: doc.updatedAt },
    });
  }
}

// answer.ts: runs online, once per user question
export async function answer(q: string, user: User) {
  const hits = await vectors.search(await embed(q), {
    topK: 40,
    filter: { planTier: user.planTier },       // access BEFORE retrieval
  });
  const ranked = await rerank(q, hits);            // cross-encoder
  const kept = ranked.filter(h => h.score >= 0.35).slice(0, 5);
  if (kept.length === 0) return "No confident answer.";   // never invent

  const context = assemble(kept, { budget: 3000, order: "best-last" });
  return complete({
    system: "Answer only from context. Cite sources.",
    user: q,
    context,
  });
}

sequenceDiagram
  actor U as User
  participant A as App
  participant V as Vector store
  participant R as Reranker
  participant L as LLM
  U->>A: Why was I charged twice
  A->>A: check plan tier and permissions
  A->>V: embed query, search top 40
  V-->>A: 40 candidate chunks
  A->>R: re-rank against the query
  R-->>A: keep top 5 above the floor
  A->>L: question plus 5 chunks plus cite rule
  L-->>A: grounded answer with sources
  A-->>U: answer with citations