Citation Accuracy Verification Prompt

Use this prompt when your product surfaces cited answers to users and attribution errors would erode trust, create compliance risk, or violate accuracy guarantees. The ideal user is an AI reliability engineer, product developer, or QA lead responsible for ensuring that every citation in a model-generated answer accurately reflects its source content. You need a post-generation verification step that runs before user-facing output is finalized, not a prompt for initial answer generation. The required context includes the original model answer with its citations, the full source documents or passages that were cited, and any retrieval metadata that maps claims to sources.

This prompt is designed for cited-answer products where the cost of a fabricated quote or mismatched citation is high—think legal research tools, medical literature assistants, financial analysis platforms, or enterprise knowledge bases. It detects three failure modes: quote fabrication (a citation points to a source that doesn't contain the quoted text), claim-source mismatch (a claim is attributed to a source that says something different), and irrelevant or contradictory citations (a source is cited but its content doesn't support or actively contradicts the claim). The prompt produces structured correction instructions that downstream repair prompts or human reviewers can act on, including the specific claim, the problematic citation, the actual source content, and a recommended fix.

Do not use this prompt for initial answer generation—it is strictly a verification step. Do not use it when you lack access to the full source content for each citation; the prompt cannot verify what it cannot read. Do not use it as a replacement for retrieval quality evaluation; it checks citation accuracy, not whether the right documents were retrieved in the first place. If your workflow involves regulated domains like healthcare or legal, always route the verification output to a human reviewer before finalizing user-facing answers. For high-throughput systems, pair this prompt with a retry budget and escalation threshold to prevent verification loops from blocking the pipeline.

This template is designed to be dropped directly into a post-generation validation step within your AI harness. It assumes you already have a model response containing citations and the corresponding source context that was provided to the model. The prompt instructs the model to act as a strict auditor, comparing each cited claim against its alleged source passage. It is not a conversational prompt; it is a verification instruction set meant for programmatic execution where the output will be parsed and used to trigger repair or escalation workflows.

textCopy
You are a citation accuracy auditor. Your task is to verify that every cited claim in the [MODEL_OUTPUT] accurately reflects the content of its corresponding source passage in [SOURCE_CONTEXT]. You must detect quote fabrication, semantic distortion, and unsupported attribution.

## INPUT

### MODEL_OUTPUT

[MODEL_OUTPUT]

codeCopy

### SOURCE_CONTEXT
A mapping of citation identifiers to their full source text.
```json
[SOURCE_CONTEXT]

VERIFICATION RULES

For each citation in the MODEL_OUTPUT:

1. Locate the cited passage in SOURCE_CONTEXT using the citation identifier.
2. If the citation identifier is not found in SOURCE_CONTEXT, flag it as citation_not_found.
3. Compare the claim made in MODEL_OUTPUT against the actual text of the source passage.
4. Classify the citation into one of the following categories:
   • exact_match: The claim is a verbatim or near-verbatim quote from the source.
   • faithful_paraphrase: The claim accurately represents the source's meaning without fabrication.
   • semantic_distortion: The claim twists, exaggerates, or misrepresents the source's meaning.
   • fabricated_quote: The claim is presented as a direct quote but does not appear in the source.
   • unsupported_claim: The claim asserts a fact not present in the source passage.
   • context_contradiction: The claim directly contradicts information in the source.

CONSTRAINTS

• Do not evaluate the quality of the writing, only factual accuracy against the source.
• If a claim is partially supported and partially unsupported, flag the unsupported portion and explain the split.
• If a source passage is ambiguous, note the ambiguity but do not assume fabrication.
• Do not hallucinate source content. If you are unsure, flag it as verification_uncertain.

OUTPUT_SCHEMA

Return a JSON object with the following structure:

jsonCopy
{
  "overall_assessment": {
    "total_citations": <integer>,
    "accurate_citations": <integer>,
    "inaccurate_citations": <integer>,
    "accuracy_rate": <float between 0.0 and 1.0>,
    "critical_failures": <boolean>
  },
  "citation_audit": [
    {
      "citation_id": "<string>",
      "claim_text": "<the exact claim from MODEL_OUTPUT>",
      "source_passage": "<the relevant text from SOURCE_CONTEXT>",
      "classification": "<exact_match|faithful_paraphrase|semantic_distortion|fabricated_quote|unsupported_claim|context_contradiction|citation_not_found|verification_uncertain>",
      "explanation": "<specific reason for the classification, citing the discrepancy if any>",
      "correction_instruction": "<if inaccurate, a clear instruction for how to correct the claim to match the source>"
    }
  ],
  "correction_summary": "<a concise summary of all required corrections for downstream repair>"
}

EXAMPLES

Example 1: Fabricated Quote

MODEL_OUTPUT: "As the report states, 'our Q3 revenue grew by 40% year-over-year.'" SOURCE_CONTEXT: {"report_2024": "The company experienced moderate growth in Q3, with revenue increasing 12% compared to the same period last year."}

Audit Result: { "citation_id": "report_2024", "claim_text": "our Q3 revenue grew by 40% year-over-year", "source_passage": "The company experienced moderate growth in Q3, with revenue increasing 12% compared to the same period last year.", "classification": "fabricated_quote", "explanation": "The MODEL_OUTPUT presents a direct quote with a 40% figure, but the source states 12% and does not contain the quoted language.", "correction_instruction": "Replace the fabricated quote with a faithful paraphrase: 'The company reported a 12% year-over-year revenue increase in Q3.'" }

Example 2: Unsupported Claim

MODEL_OUTPUT: "The study concluded that the new drug reduces mortality by 50% [study_2023]." SOURCE_CONTEXT: {"study_2023": "Patients receiving the treatment showed a statistically significant reduction in symptom severity compared to the placebo group. Long-term mortality data was not collected in this phase."}

Audit Result: { "citation_id": "study_2023", "claim_text": "the new drug reduces mortality by 50%", "source_passage": "Patients receiving the treatment showed a statistically significant reduction in symptom severity compared to the placebo group. Long-term mortality data was not collected in this phase.", "classification": "unsupported_claim", "explanation": "The source explicitly states that mortality data was not collected, making any mortality claim unsupported.", "correction_instruction": "Remove the mortality claim. State only what the source supports: 'The study found a statistically significant reduction in symptom severity for patients receiving the treatment.'" }

Before deploying this template, you must replace the [MODEL_OUTPUT] and [SOURCE_CONTEXT] placeholders with actual data from your application. The [SOURCE_CONTEXT] should be injected as a serialized JSON object mapping citation identifiers (e.g., [1], [report_2024]) to their full source text. If your system uses a different citation format, update the citation_id field description and the verification rules accordingly. The output schema is designed for direct parsing by a downstream repair or escalation module. For high-stakes domains such as legal, medical, or financial applications, route any output where critical_failures is true or accuracy_rate falls below your defined threshold (e.g., 0.95) to a human review queue before taking corrective action.

The Citation Accuracy Verification Prompt is designed to sit inside a post-generation validation layer, not as a standalone chat interaction. After your primary RAG pipeline produces a cited answer, this prompt acts as a verification gate: it receives the generated answer, the full list of citations, and the retrieved source context, then produces a structured verification report. The report flags mismatches between claims and cited passages, detects quote fabrication, and generates correction instructions for a downstream repair step. This is a high-stakes verification workflow—attribution errors directly erode user trust and can create compliance exposure in regulated domains—so the implementation harness must treat the verification output as a signal for automated repair, human review, or escalation, never as a silent pass-through.

Wire the prompt into your application as a post-answer hook. After your RAG system produces final_answer and citations[], call the verification prompt with [CLAIMS_AND_CITATIONS] set to the full answer text plus its citation markers, and [SOURCE_CONTEXT] set to the complete retrieved passages that were available to the generation step. Parse the model's output against a strict JSON schema that includes citation_id, claim_text, verification_status (one of accurate, mismatch, fabricated, insufficient_context), source_evidence, and correction_instruction. If any citation has a status other than accurate, route to a repair prompt (such as the Grounded Answer Regeneration Prompt) or escalate to a human review queue depending on severity thresholds you define. Log every verification result with the original answer, citations, and verification report for audit trails and eval improvement.

Model choice matters here. Use a model with strong instruction-following and low hallucination rates for the verifier role—this is a meta-evaluation task where the verifier model must be more reliable than the generator model. Consider running the verification on a different model than the one that produced the original answer to avoid correlated failures. Implement a single retry on verification parse failures (malformed JSON), but do not retry the verification itself—if the verifier produces an ambiguous result, escalate to human review rather than looping. Set a hard budget: if more than N citations per answer require correction, skip per-citation repair and regenerate the entire answer with stricter grounding constraints. For high-stakes domains, always require human sign-off on any fabricated status before the correction is surfaced to end users.