Select all techniques that meaningfully improve the reliability of source citations in a production RAG answer (chunks resolving back to real source documents).

Multi-select·Medium·4.0 · 0·~1 min·Asked atPerplexity·Relevant atAnthropic OpenAI

Attempt it

Reliable citations are not a politeness problem solved by saying 'please cite'. They are a system design problem solved with four cooperating tricks. First, **number the chunks** you pass into the prompt: [1], [2], [3]. The model only has to emit small integers, which is something LLMs do correctly almost all the time. After the model responds, your code maps the numbers back to actual source URLs or document IDs. Second, **validate** every citation the model emitted. If it cites [12] but you only passed five chunks, that citation is hallucinated and you strip it before showing the answer to the user. This single check catches the most common citation failure. Third, **use structured outputs** when the model supports it. Claude Opus 4.7's tool use and GPT-5.5's structured outputs let you define a JSON schema where each claim has a slot for its citation. The model fills the slots; you parse the JSON; no free form citation drift is possible. Fourth, **make grounding explicit** in the system prompt. Say 'every factual claim must be attributable to at least one cited chunk, otherwise refuse'. Without this directive, models drift into uncited generation; with it, they default to citing. Do NOT ask the model to write URLs from memory and do NOT raise the temperature; both hurt citation reliability.

Citation reliability in RAG comes from a stack of four reinforcing techniques. A single polite instruction is not enough. **Numbered chunk references**: pass chunks into the prompt with explicit numeric tags like [1], [2], [3]. Require the model to cite by number. The model emits small integers, which are easy to produce correctly. Your code maps the numbers back to the underlying source URLs or document IDs after generation. This decouples what the model writes (a number) from what the user sees (a real source link). **Post-validation**: after generation, scan the model's output for citation markers. Any marker that does not correspond to a chunk number you actually passed is a hallucinated citation. Strip or flag it. A few lines of code catch a meaningful slice of citation errors. **Structured outputs**: when the model exposes a JSON-schema or tool-use interface, define a typed schema. Anthropic, OpenAI, and Google all support this in 2026. Each emitted claim has a `claim_text` and a `citations: int[]` field. The model fills the schema; the runtime validates; no free form citation strings ever exist. This eliminates an entire class of parsing bugs. **Grounding directive**: the system prompt must state that every factual claim must trace to a cited chunk. Refusal is the fallback when no chunk supports a claim. Without this, models drift into confident uncited generation. The two bad ideas are: asking the model to write URLs from memory (URLs hallucinate constantly), and raising temperature for citation creativity (this is exactly the wrong direction).

Quick reference

TL;DR

Reliable citations come from system design, not polite prompts. Number chunks, validate citations against the IDs you passed, use structured outputs, and require grounding in the system prompt.

Memory aid

Easy to grasp

Imagine you ask a researcher for a report with sources. If you just say 'cite your sources', they might write down a URL from memory that turns out to be slightly wrong. Instead, you give them a numbered stack of source documents and say 'every claim must point to one of these numbers'. Then, before you hand the report to anyone, you check that every cited number actually exists in the stack you provided. If a citation refers to source number twelve and you only gave eleven sources, you cross it out. You can also make the researcher fill in a structured form instead of writing free form notes, so each claim has a slot for its source ID. That combination of constraints is how production RAG systems make citations actually trustworthy.

Key concepts

RAG system design Prompt engineering Structured outputs

Detailed answer & concept explanation

~6 min read

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

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

Quick scan · 2–4 min

Everything important, quickly.

3 min: enumerate the four stacking invariants (number, validate, structure, ground), explain why URLs from memory hallucinate, contrast with high temperature, and close with the faithfulness check as a complementary layer.

Code example

python

import re, json

def render_chunks(chunks):
    return "\n\n".join(f"[{i+1}] {c.text}" for i, c in enumerate(chunks))

SYSTEM = """You answer using ONLY the numbered chunks provided.
Every factual claim must end with one or more citation markers like [1] or [2,4].
If no chunk supports a claim, refuse: "I don't have a source for that."""

def answer_with_citations(query, chunks, llm):
    prompt = f"{render_chunks(chunks)}\n\nQuestion: {query}"
    out = llm.complete(system=SYSTEM, user=prompt, temperature=0.0)

    valid_ids = set(range(1, len(chunks) + 1))
    def repl(m):
        ids = [int(x) for x in m.group(1).split(",")]
        kept = [i for i in ids if i in valid_ids]
        return f"[{','.join(map(str, kept))}]" if kept else ""
    cleaned = re.sub(r"\[([\d,\s]+)\]", repl, out)
    return cleaned

Side-by-side

Technique	What invariant it enforces	Failure it prevents
Numbered chunks	Citation surface is a small integer	URL-style hallucination in citation strings
Post-validation	Every emitted ID exists in the passed set	Hallucinated chunk IDs pointing nowhere
Structured outputs	Typed schema with citations field per claim	Free-form citation parsing bugs
Grounding directive	Refusal when no chunk supports a claim	Confident uncited generation drift
Memorized URLs (BAD)	None; relies on pretraining memory	Models invent or corrupt URL strings
High temperature (BAD)	None; increases variability	Citation drift across reruns

Real-world examples

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

Anthropic's Citations feature for Claude Opus 4.7 attaches source spans to generated claims via a structured citations API; the runtime validates them against the passed documents.
Perplexity AI renders numbered citations [1][2] alongside answers; the numbers map to real source URLs the system already had, not URLs the model invented.
OpenAI's GPT-5.5 structured outputs (JSON schema mode) let you define a Pydantic or JSON schema where each claim has a typed citations field; the runtime guarantees schema compliance.
LlamaIndex and LangChain both ship `CitationQueryEngine` and structured citation chain helpers that bind retrieved chunk IDs to model outputs.
Bing Copilot and Google's Gemini grounded search expose per-claim citations that are server validated against the search corpus, the same pattern at scale.

Interviewer follow-ups

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

QWalk me through how Anthropic's Claude Opus 4.7 Citations feature works and how it differs from a vanilla numbered citation prompt.

QHow would you add a faithfulness check on top of these techniques?

QYour users complain that citations point to chunks that don't actually support the claim, even though the chunk ID is valid. What's wrong?

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Asking the LLM to cite URLs from memory; URLs are notoriously misquoted in pretraining driven citation. Real citations come from chunk IDs you control, not strings the model invents.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.