Source Attribution Verification Prompt

This prompt is for teams shipping AI-generated content that includes citations—RAG answers, research briefs, legal summaries, or any output where the model claims to reference a specific source. The job is to verify that every citation in the generated response accurately reflects the cited source's content. This means detecting misattributed quotes, fabricated references, citation-to-claim mismatches, and cases where the model cites a real document but misrepresents what it says. The ideal user is an AI engineer, evaluation lead, or content verification specialist who needs automated, repeatable checks before cited outputs reach users or reviewers.

Use this prompt when citations are a product requirement, not optional decoration. It fits into CI/CD pipelines as a pre-release gate, into human review queues as a triage filter, and into production monitoring as a drift detector. You need the generated text, the full cited source content, and the citation mapping before running this prompt. Do not use it when citations are absent, when source documents are unavailable, or when you need real-time streaming verification—this is a post-generation audit step. For high-stakes domains like legal, healthcare, or finance, this prompt should feed a human review queue, not make autonomous pass/fail decisions.

Before implementing, define your tolerance for false positives and false negatives. A strict configuration will flag minor paraphrasing differences as misattributions, increasing reviewer burden. A lenient configuration will miss subtle misrepresentations. Start by running this prompt against a golden dataset of known-good and known-bad citation pairs to calibrate thresholds. Then integrate it into your evaluation harness with structured logging, per-citation pass/fail scores, and clear escalation paths for failures that require human judgment.

This prompt template is designed to be dropped directly into your evaluation pipeline. It instructs the model to act as a strict auditor, comparing each citation in a generated response against the provided source material. The template uses square-bracket placeholders for all dynamic inputs, making it easy to parameterize for different documents, responses, and risk tolerances. Copy the block below and replace the placeholders with your application's data before sending it to the model.

textCopy
You are a strict citation auditor. Your task is to verify that every citation in the [RESPONSE_TO_AUDIT] accurately reflects the content of the cited source provided in [SOURCE_MATERIAL].

For each citation found in the response, perform the following checks and output a structured report:
1.  **Source Existence**: Does the cited source identifier (e.g., [1], [doc_alpha]) exist in the provided [SOURCE_MATERIAL]?
2.  **Quote Accuracy**: If a direct quote is used, does it match the source text exactly, including punctuation? Flag any discrepancies.
3.  **Claim Support**: Does the source genuinely support the specific claim it is attached to? Classify the relationship as `SUPPORTS`, `PARTIALLY_SUPPORTS`, `CONTRADICTS`, or `UNRELATED`.
4.  **Contextual Fidelity**: Is the source's meaning distorted, overstated, or taken out of context to support the claim? Flag any misrepresentation.

**Output Format**: Return a single JSON object with the following schema:
{
  "audit_results": [
    {
      "citation_id": "string",
      "source_exists": boolean,
      "quote_accurate": boolean or null,
      "claim_support_level": "SUPPORTS" | "PARTIALLY_SUPPORTS" | "CONTRADICTS" | "UNRELATED",
      "contextual_fidelity_issues": ["string"] or [],
      "overall_verdict": "PASS" | "FAIL",
      "auditor_notes": "string"
    }
  ],
  "summary": {
    "total_citations": number,
    "passed": number,
    "failed": number,
    "critical_failures": ["citation_id"]
  }
}

**Constraints**:
- If a citation is a fabricated reference (source does not exist), the `overall_verdict` must be `FAIL` and this must be flagged as a `critical_failure`.
- If the [RISK_LEVEL] is `HIGH`, any `FAIL` verdict should halt the pipeline and require human review.
- Base your audit strictly on the provided [SOURCE_MATERIAL]. Do not use outside knowledge.
- If no citations are found in the response, return an empty `audit_results` array and a note in the summary.

[SOURCE_MATERIAL]:

[INSERT_SOURCE_DOCUMENTS_HERE]

codeCopy

[RESPONSE_TO_AUDIT]:

[INSERT_GENERATED_RESPONSE_HERE]

To adapt this template, start by mapping your source documents into the [SOURCE_MATERIAL] block. Each source should have a clear, unique identifier that matches the citations in the response. The [RISK_LEVEL] placeholder is a control lever: set it to LOW for internal development checks where a logged warning is sufficient, and HIGH for customer-facing outputs where a FAIL verdict must trigger an immediate block and human review queue. For production systems, you should validate the output JSON against the schema before accepting the audit result, as a malformed response from the auditor is itself a failure mode.

The Source Attribution Verification Prompt is designed to operate as a post-generation audit step, not a real-time guardrail. In a typical RAG or cited-generation pipeline, the primary model produces a response with inline citations. This prompt then takes the generated response and the full text of each cited source as input, producing a structured verification report. The implementation harness should treat this as an asynchronous evaluation job: enqueue the verification request, run it against a judge model (typically a capable model like GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro), and route the results to a review queue or automated gate. Do not block the user-facing response on this verification completing unless the use case demands synchronous grounding guarantees and your latency budget can absorb the additional model call.

The harness must validate the output schema before acting on the results. The prompt returns a JSON object with a citations array, where each element contains citation_id, claim_summary, source_text_excerpt, verification_status (one of accurate, misattributed, fabricated, partial_match, or unverifiable), and explanation. Implement a post-processing validator that checks: (1) every citation_id in the output matches a citation present in the original generated response, (2) no citation_id is missing from the verification report, (3) all verification_status values are from the allowed enum, and (4) the source_text_excerpt field contains a non-empty substring that can be located in the provided source document. If validation fails, retry the verification call once with an explicit error message injected into the prompt context. If the retry also fails, flag the output for mandatory human review and log the validation failure details for prompt debugging.

For high-stakes domains such as legal, medical, or financial content, implement a tiered escalation path based on the verification results. Any citation marked fabricated or misattributed should trigger immediate human review before the response reaches the end user. Citations marked partial_match can be surfaced with a confidence warning in the UI. Citations marked accurate can pass through without intervention. Store the full verification report alongside the generated response in your logging or observability system, including the judge model version, prompt version, and timestamp. This audit trail is essential for governance, prompt regression testing, and debugging hallucination patterns over time. For cost optimization, consider batching verification requests during off-peak hours for non-urgent content, or implement a sampling strategy where only a percentage of responses undergo full citation verification if your volume exceeds your evaluation budget.