Quote-to-Claim Attribution Prompt

This prompt is designed for transparency and explainability engineers who need to build audit interfaces or user-facing explainability features. Its job is to take a set of claims and a set of supporting quotes extracted from source documents, then produce a human-readable attribution chain that explicitly links each quote to the specific claim it supports, complete with reasoning. Use this when you need to show users or auditors exactly why a piece of evidence was used to support a conclusion.

This is not a quote extraction prompt; it assumes you already have extracted quotes and formulated claims. It is also not a fact-checking prompt; it explains the relationship between a claim and a quote, but does not independently verify the claim's truth. The prompt works best when the input quotes are verbatim spans from source documents and the claims are discrete, atomic statements. If your claims are multi-sentence paragraphs or your quotes are paraphrased, the attribution quality will degrade significantly.

Do not use this prompt when you need to extract quotes from raw documents, verify factual accuracy, or rank evidence by strength. Those tasks require separate prompts from the Supporting Evidence Extraction and Evidence Ranking pillars. This prompt is also unsuitable for real-time streaming applications where latency is critical; the reasoning chains it produces require full model inference and are best suited for asynchronous audit report generation or on-demand explainability views.

Before wiring this into production, ensure your upstream quote extraction pipeline preserves exact source spans and document identifiers. The attribution prompt relies on precise text matching between claims and quotes. If your extraction step introduces truncation, normalization, or paraphrasing, the model will struggle to produce accurate attribution chains. Plan to validate outputs with a separate LLM judge that checks whether each attribution link is logically sound and whether any quotes were incorrectly linked to unrelated claims.

This prompt template is designed for transparency and explainability engineers who need to generate human-readable attribution linking each extracted quote to the specific claim it supports. It produces attribution chains with reasoning, making it suitable for audit interfaces and user-facing explainability features. The template uses square-bracket placeholders that you replace with your application's data before sending the prompt to the model.

textCopy
You are an attribution specialist. Your task is to link each extracted quote to the specific claim it supports, producing a clear attribution chain with reasoning.

## INPUT

**Claims:**
[CLAIMS]

**Extracted Quotes:**
[QUOTES]

**Source Documents (for context):**
[SOURCE_DOCUMENTS]

## OUTPUT SCHEMA

Return a JSON object with the following structure:

{
  "attributions": [
    {
      "claim_id": "string - identifier for the claim from the input",
      "claim_text": "string - the exact claim text",
      "supporting_quotes": [
        {
          "quote_id": "string - identifier for the quote from the input",
          "quote_text": "string - the exact quote text",
          "source_reference": "string - document and location identifier",
          "relationship": "directly_supports | partially_supports | provides_context | contradicts",
          "reasoning": "string - explanation of how this quote relates to the claim"
        }
      ],
      "unsupported_portions": [
        "string - parts of the claim that lack quote support"
      ],
      "overall_assessment": "fully_supported | partially_supported | unsupported | contradicted",
      "assessment_reasoning": "string - summary of why this overall assessment was reached"
    }
  ],
  "unattributed_quotes": [
    {
      "quote_id": "string",
      "quote_text": "string",
      "reason_unattributed": "string - why this quote could not be linked to any claim"
    }
  ]
}

## CONSTRAINTS

- Every claim in the input must appear in the output with at least one attribution attempt.
- Every quote in the input must either be attributed to at least one claim or listed in unattributed_quotes.
- Quote text must be reproduced verbatim from the input without modification.
- Reasoning must reference specific content from both the claim and the quote.
- If a quote contradicts a claim, include it with relationship "contradicts" rather than omitting it.
- Do not fabricate support. If a quote does not support a claim, do not claim it does.
- For partially_supported or unsupported assessments, explicitly identify which portions of the claim lack evidence.

## RISK LEVEL

[RISK_LEVEL]

## EXAMPLES

[EXAMPLES]

To adapt this template, replace [CLAIMS] with your structured list of claims, each with an identifier and text. Replace [QUOTES] with your extracted quotes, each with an identifier, text, and source reference. [SOURCE_DOCUMENTS] provides full document context for disambiguation. Set [RISK_LEVEL] to "high" when attributions will be used in audit or compliance contexts, which triggers stricter reasoning requirements. [EXAMPLES] should contain one or two worked attribution examples showing the expected relationship types and reasoning depth. After the model returns output, validate that every claim and quote from the input appears in the response, that quote text matches verbatim, and that relationship labels are from the allowed enum. For high-risk use cases, route outputs through human review before surfacing attributions to end users.

The Quote-to-Claim Attribution Prompt is designed to sit between your evidence extraction layer and your user-facing explainability interface. It consumes a set of extracted quotes and a target claim, then produces structured attribution chains that explain why each quote supports that claim. In a production system, this prompt typically runs after a retrieval or extraction step has already surfaced candidate quotes from source documents. The harness must validate that every attribution chain is self-consistent, that quotes are not hallucinated, and that the reasoning is grounded in the provided text rather than the model's parametric knowledge.

Wire this prompt into your application as a post-extraction processing step. The input payload should include the claim text, an array of extracted quote objects (each with quote_text, source_document_id, and span_location), and any domain-specific constraints such as required attribution format or confidence thresholds. The output schema should enforce a list of attribution objects, each containing quote_text, claim_supported, attribution_reasoning, and confidence_score. Implement a validation layer that checks: (1) every returned quote exists verbatim in the input quotes, (2) no attribution references a source document not provided, (3) confidence scores fall within the expected range, and (4) the reasoning text does not introduce external facts. For high-stakes audit interfaces, add a human review queue that samples attributions below a configurable confidence threshold and routes them for manual verification before they appear in the UI.

Model choice matters here. Use a model with strong instruction-following and structured output capabilities, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro, and set the temperature low (0.0–0.2) to minimize creative drift in reasoning text. If your application requires processing many claims per document, batch the prompt calls but keep each batch small enough that the model can attend to all quotes without truncation. Log every attribution output alongside the input quotes, claim, model version, and validator results. This audit trail is essential for debugging hallucinated attributions and for demonstrating grounding fidelity to compliance reviewers. When the validator rejects an output, implement a single retry with the error details injected into the prompt as a correction hint; if the retry also fails, escalate to the human review queue rather than looping indefinitely.