Source Attribution Instruction

A source attribution instruction transforms a model's output from a general statement into a verifiable claim. It does this by mandating a direct link between every factual assertion and its supporting evidence. The core mechanism is a conditional rule: if a claim is made, a citation must follow.

• Example Instruction: "For every factual statement in your answer, cite the specific document name and paragraph number that supports it."
• Without Instruction: "The company was founded in 2010."
• With Instruction: "The company was founded in 2010 [Source: Annual Report 2022, p. 3]."

This characteristic moves the model from generative mode into an extractive and associative reasoning mode, significantly reducing its tendency to hallucinate.

These instructions inherently require the model to produce a deterministic output format. The citation is not a suggestion; it is a structural component of the response. This often involves specifying a precise citation format (e.g., APA, MLA, inline brackets, footnotes) that the model must adhere to.

• Enforces Consistency: A predefined format like [Doc: <name>, Section: <id>] ensures machine-readability for downstream validation systems.
• Reduces Ambiguity: Clear formatting rules eliminate model guesswork about how to present the source, leading to more reliable and parseable outputs.
• Facilitates Automation: Structured citations enable automated factual consistency checks where a secondary system can programmatically verify the claim against the cited source.

This characteristic is closely related to Structured Output Generation techniques within prompt architecture.

The instruction explicitly anchors the model's knowledge scope to the provided context. It acts as a bounded generation constraint, limiting the model's response universe to the contents of the supplied source materials.

• Defines the Knowledge Boundary: The instruction implicitly states: "Your world is this set of documents. Do not draw from pre-trained knowledge unless it corroborates these sources."
• Enables Source-Based Generation: The model's primary task shifts from recall to retrieval and synthesis within a closed corpus.
• Mitigates Temporal Errors: When combined with a knowledge cutoff or temporal bounding instruction, it prevents the model from incorrectly applying outdated internal knowledge to the current, provided context.

This anchoring is the operational opposite of open-ended generation and is a core principle of Retrieval-Augmented Generation (RAG) Architectures.

A robust source attribution instruction must account for information gaps. It inherently trains the model to practice uncertainty acknowledgment. If a requested fact is not present in the provided sources, the instruction's logic should guide the model to state this absence rather than fabricate an answer.

• Triggers a "Not Found" Response: A well-designed instruction includes a clause like, "If the information is not in the provided documents, state 'Source not found.'"
• Operationalizes a Confidence Threshold: The model effectively applies a binary confidence threshold: citation possible (high confidence) vs. citation impossible (must express uncertainty).
• Supports a No Fabrication Rule: This is the direct enforcement mechanism for the absolute prohibition against inventing details.

This characteristic is critical for building user trust and is a key component of calibration prompts aimed at improving model honesty.

Complying with a source attribution instruction requires the model to engage in implicit stepwise verification. The cognitive process is decomposed into distinct, sequential phases:

1. Claim Formulation: Generate a candidate factual statement.
2. Evidence Retrieval: Search the provided context for supporting text.
3. Match & Link: Associate the claim with the specific evidence location.
4. Formatting: Apply the required citation structure.
5. Validation (Optional): Perform a final contradiction detection check between the claim and the cited evidence.

This internal process mirrors explicit self-verification prompt patterns and fact-checking loops. It demonstrates how a single instruction can induce a complex, reliability-focused reasoning chain, moving the model towards ReAct-like (Reasoning + Acting) behavior where the "act" is to cite.

A source attribution instruction is rarely used in isolation. It functions as a core, actionable component within a broader system of hallucination guardrails. These guardrails are high-level constraints, while the attribution instruction provides the executable mechanism.

• Works with Grounding Prompts: A grounding prompt (e.g., "Base your answer only on the text below") sets the policy; the attribution instruction provides the enforceable procedure.
• Feeds Factual Consistency Checks: The outputted citations become the input for automated or model-driven factual consistency checks.
• Supports Multi-Source Synthesis: When multiple documents are provided, the instruction forces the model to perform cross-reference instruction implicitly, showing which source supports which claim, highlighting consensus or discrepancy.
• Foundation for Deterministic Output: By tethering output to source, it maximizes factual fidelity, making the system's responses more reproducible and auditable.

Thus, it is a fundamental building block in context engineering for production AI systems.

This instruction mandates the model to embed citations directly within the response text using a standardized bracketed format. It is the most common method for ensuring traceability to source documents.

• Format: [Document #, Page/Section X]
• Example Instruction: "For every factual statement you make, cite the source using inline brackets like [Doc1, Pg3]. Only use information from the provided documents."
• Use Case: Ideal for technical documentation, legal analysis, and research synthesis where verifying the provenance of each claim is critical.

This instruction requires the model to output a separate, structured verification table alongside its final answer. This decouples the reasoning and evidence-gathering process from the polished response.

• Format: A markdown table with columns for Claim, Supporting Evidence, and Source Reference.
• Example Instruction: "First, generate a table listing each key claim in your answer, the exact supporting text, and its source. Then, provide your final answer based solely on that table."
• Use Case: Essential for high-stakes applications like financial reporting, medical advice systems, and compliance documentation where auditability is non-negotiable.

This architecture decomposes the attribution process into a mandated, sequential chain of steps. It forces the model to explicitly perform extraction and verification before generating a final response.

• Typical Steps: 1. Extract all key facts from the query. 2. For each fact, retrieve the relevant passage from the provided sources. 3. Synthesize a response using only the retrieved passages, citing each one.
• Mechanism: Leverages the model's chain-of-thought capability for transparent, auditable reasoning. It is a core component of ReAct frameworks and self-verification prompts.
• Use Case: Complex multi-source synthesis tasks where avoiding contradiction and ensuring comprehensive grounding is paramount.

This instruction combines a strict no fabrication rule with a clear protocol for handling information gaps. It prioritizes accuracy over completeness.

• Core Directive: "Do not guess or invent any information. If the provided sources do not contain sufficient information to fully answer the question, state: 'Based on the provided sources, this specific detail cannot be confirmed.'"
• Linked Concepts: This enforces uncertainty acknowledgment and works in tandem with confidence threshold directives. It is a fundamental hallucination guardrail.
• Use Case: Customer support bots, educational Q&A systems, and any public-facing AI where the cost of fabrication outweighs the benefit of a seemingly complete answer.

This instruction requires the model to perform source-based generation, where the response is primarily a synthesis of direct quotes or close paraphrases, tightly anchored to the source text.

• Example Instruction: "Your answer must be composed by paraphrasing or directly quoting the provided documents. Start each paragraph with a reference to the primary source used, e.g., 'According to Document A...'"
• Mechanism: This technique enhances factual fidelity through contextual anchoring, limiting the model's ability to extrapolate beyond the provided grounding prompt context.
• Use Case: Generating executive summaries from internal reports, creating study guides from textbooks, and other tasks requiring high deterministic output fidelity to source material.

This advanced instruction guides the model to compare information across several provided sources, resolve conflicts, and attribute claims to the correct or consensus source.

• Example Instruction: "You are provided with three reports on the same event. Identify key facts. Where sources agree, cite all relevant sources [Doc1, Doc2]. Where they disagree, note the discrepancy and cite the conflicting sources. Base your final answer on the most frequently cited or most authoritative source."
• Linked Concepts: This is a direct implementation of contradiction detection and multi-source synthesis. It is a critical pattern for retrieval-augmented generation architectures pulling from multiple knowledge bases.
• Use Case: Investigative journalism aids, intelligence analysis, and academic literature reviews where source reliability and consensus must be evaluated.

A grounding prompt is an instruction that explicitly requires a language model to base its response on provided source material, verifiable facts, or a specific knowledge base to prevent fabrication. It is the foundational technique that Source Attribution Instructions build upon.

• Core Function: Anchors the model's output to a provided context.
• Key Difference: While a grounding prompt tells the model what to base its answer on, a Source Attribution Instruction specifies how to cite that basis.
• Example: "Answer the following question using only the information provided in the document below."

An evidence requirement is a prompt directive that mandates the model to support every factual assertion with specific data, quotes, or references from the provided context. It is the operational rule that a Source Attribution Instruction enforces.

• Mechanism: Transforms a general grounding instruction into a specific, actionable output constraint.
• Implementation: Often paired with a citation format instruction to ensure consistency.
• Example Instruction: "For each claim you make, you must cite the exact sentence from the source document that supports it, using [Page X, Line Y] format."

A self-verification prompt is an instruction that guides a model to act as its own critic, systematically checking its initial response for errors, inconsistencies, or unsupported claims. This creates a multi-step fact-checking loop.

• Process: Often follows a Chain-of-Thought structure: 'Generate an answer, then list each factual claim, then verify each against the sources.'
• Relation to Attribution: The verification step explicitly requires the model to perform source attribution on its own draft output.
• Use Case: Critical for high-stakes applications like legal analysis or medical Q&A, where a single pass is insufficient.

The no fabrication rule is an absolute prompt prohibition that explicitly instructs the model not to invent details, quotes, data, or citations that are not present in the provided context. It is the strictest form of hallucination guardrail.

• Absolute Constraint: Often phrased as a zero-tolerance policy: "Do not guess. If the answer is not in the sources, say so."
• Foundation for Attribution: This rule makes source attribution possible and meaningful; if fabrication is allowed, citations lose their veracity.
• Combination: Typically used alongside a confidence threshold and uncertainty acknowledgment instruction to handle missing information gracefully.

A retrieval-augmented prompt is an instruction that explicitly integrates or references content retrieved from an external knowledge source, grounding the model's task in that specific data. It defines the architectural context for Source Attribution.

• System Architecture: In a Retrieval-Augmented Generation (RAG) system, the prompt dynamically includes retrieved chunks of text.
• Attribution's Role: The Source Attribution Instruction tells the model how to cite these dynamically retrieved passages, creating a transparent link between the answer and the knowledge base.
• Example: "Using the retrieved company documents below, answer the user's question. Cite the relevant document ID and section for each part of your answer."

Structured verification is a prompt pattern that forces a model to output its fact-checking process in a predefined format, such as a table of claims and supporting evidence. It makes the attribution process machine-readable and auditable.

• Output Format: Enforces deterministic output like JSON or XML, containing fields for claim, supporting_evidence, source_location, and confidence.
• Engineering Benefit: This structured data is essential for Algorithmic Explainability and building Evaluation-Driven Development pipelines.
• Advanced Application: Enables multi-source synthesis by requiring the model to show evidence from multiple documents and note any conflicts.