How does citation linkage between retrieved chunks and the model output rely on context engineering choices?

Flashcard·Medium·4.0 · 0·~30s·Asked atAirbnb Jasper Sigmoid

Attempt it

Each retrieved chunk gets a stable identifier (chunk_id or short tag like [S3]) attached as a header inside the context block. The system instruction tells the model to cite by that identifier when it uses a chunk. The identifier survives reranking, trimming, and reordering because it is bound to the chunk text, not to its position. At read time the renderer maps the cited identifier back to the original source row. The fragile alternative is asking the model to invent citations from the chunk text, it confabulates URLs and titles. The robust pattern is explicit, position-independent identifiers placed inline with the chunks.

Your answer

Citation linkage means the user sees a citation on the model's answer and the UI can take them to the exact source row in the knowledge base. For that to work reliably the model has to be able to point at chunks unambiguously. The pattern that works is to give every retrieved chunk a short stable identifier before assembly. Common forms are a chunk_id from the vector store or a short tag like [S1], [S2], [S3]. That identifier gets written inline with the chunk text in the context block, usually as a header line above the chunk. The system instruction then tells the model: when you use a fact from a chunk, cite it by its tag. The model writes 'the wide then rerank pattern is the 2026 default [S2]' and the renderer maps [S2] back to the original chunk row. What makes this robust is that the identifier travels with the text. Reranking can reorder the chunks, trimming can drop some, and the tag still uniquely names the surviving chunks. The fragile alternative, asking the model to quote chunk text or repeat the title, fails because the model confabulates. It will paraphrase, mangle URLs, or invent a title that sounds plausible. Inline tags make confabulation impossible by construction.

Robust citation linkage is a context-engineering decision, not a model capability. The model only cites well if the context block was assembled so that citing is the easy thing to do. The core move is to attach a stable, position-independent identifier to every retrieved chunk inside the context block. A header line above each chunk carries the id: '[S1] Source: docs/rerank.md, section 3'. The chunk text follows. The system prompt instructs the model to cite by tag whenever it uses content from a chunk. Why the identifier matters more than position: between retrieval and inference the chunks may be reranked, deduplicated, trimmed for budget, or reordered for lost-in-the-middle mitigation. Position is unstable across all of those operations. The tag is stable because it is bound to the chunk text. At render time a small post-processor scans the model output for tag patterns and maps each tag back to the original chunk record (source URL, document title, section). That mapping is what turns 'used [S2]' into a clickable footnote. The failure mode the pattern avoids is hallucinated citations. If you ask the model to quote a chunk's title or URL, it will confabulate plausible-sounding strings that do not exist in the corpus. Inline tags route around that, the model never has to remember a title, only a tag the assembly stage put right next to the text.

TL;DR

Attach a stable id (chunk_id or short tag like [S3]) inline with each chunk, tell the model to cite by that id, and map ids back to sources at render time, so citations survive reranking and trimming.

Memory aid

Easy to grasp

Imagine you give a kid a stack of recipe cards and ask which card they used to make dinner. If every card has a sticker on the corner that says S1, S2, S3, the kid can just say 'S2' and you know exactly which recipe. If the cards have no stickers, the kid has to describe the recipe back to you, and they will probably get the title slightly wrong. RAG citations work the same way. Give every chunk a sticker before you hand them to the model, tell the model to cite the sticker, and you always know which chunk the answer came from. No stickers and the model has to guess at titles and URLs, and it guesses badly.

Key concepts

Context engineering Retrieval-augmented generation

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Citation linkage is the property that an answer's citation points back, deterministically, to the exact source row it came from. It is one of the few RAG quality properties that depends almost entirely on how the context block is assembled. The model is a passive participant, it cites whatever the system instruction and the chunk headers tell it to cite.

This card walks through the canonical assembly shape, the failure mode it avoids, and the production patterns that have stabilized around it in 2026.

Position is fragile; ids are stable

A natural first attempt is to number the chunks by their assembly position and ask the model to cite by number. 'Document 1 says X' is easy to prompt for and easy to render.

The attempt breaks the first time the assembly order changes. A reranker reorders the candidates so the strongest chunk moves to position one. A trim drops the third chunk to fit budget. A lost-in-the-middle mitigation moves the most important chunk to the head and the second-most to the tail. After any of these the model's old understanding of 'document 3' no longer corresponds to the same source row.

Bind the id to the text, not the slot

The fix is to give every chunk a stable identifier, either the vector-store row id, or a short generated tag like [S1], [S2], and write that identifier inline with the chunk. Now the chunk and the tag travel together. Reranking moves them as a pair. Trimming removes the pair entirely or leaves it; it never decouples them. The model sees the same tag to text binding regardless of what assembly transformations happened upstream.

The canonical assembly format

Render-time mapping and validation

Failure modes the pattern eliminates

Situations where this technique stops working.

2–4 min · Everything important, quickly.

python

def assemble_context(chunks: list[Chunk]) -> str:
    blocks = []
    for i, c in enumerate(chunks, start=1):
        tag = f"S{i}"
        header = f"[{tag}] Source: {c.source_path} | section: {c.section}"
        blocks.append(f"{header}\n{c.text}")
    return "\n\n".join(blocks)

SYSTEM = (
    "When you use information from a labelled source block, cite it inline "
    "using its tag in square brackets (e.g. [S1]). Cite every claim that "
    "depends on a source. Do not invent tags."
)

# Render-time validation
def validate_citations(answer: str, valid_tags: set[str]) -> list[str]:
    import re
    cited = set(re.findall(r"\[(S\d+)\]", answer))
    return list(cited - valid_tags)  # hallucinated tags

Real products, models, and research that use this idea.

Anthropic Claude Opus 4.7 ships a structured citation API: chunks are passed as `documents` and the model emits citation objects with stable doc ids.
OpenAI's 2026 Responses API exposes a document id based citation field for GPT-5, replacing earlier ad-hoc citation prompting.

What an interviewer would ask next. Try answering before peeking at the approach.

QHow do you handle citation linkage when chunks are summarized before injection?

The summary inherits the source tag; render-time mapping resolves through the summary back to the original chunk(s).

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Asking the model to quote chunk text or paraphrase source titles. The model confabulates and the renderer cannot reliably link back to the underlying source row.

60 second bullets to scan on the way to the call.

Explain what a stable chunk identifier is and why it beats position
Walk through the assembly format (header line plus chunk text)

Primary sources. Browse if you want the original framing.