Quote Accuracy Verification Retry Prompt

This prompt is a targeted recovery mechanism for document intelligence applications where a model has already generated a response containing quoted material from a source document. Its primary job is to act as a verification and retry step, comparing the generated quote against the original source text to detect and correct boundary errors, paraphrases presented as direct quotes, and other inaccuracies. The ideal user is a developer or AI engineer building a product pipeline that requires high quote fidelity for compliance, legal, audit, or trust-sensitive workflows. The required context includes the original source text, the model's generated response containing the quote, and a clear specification of the expected quote format.

Use this prompt when your application's initial citation or quote generation has failed a prior validation check, or when you are operating in a domain where a single misquote carries unacceptable risk. It is not a replacement for initial citation generation or a general-purpose fact-checking tool. Do not use this prompt to generate quotes from scratch, to verify claims that are not presented as direct quotes, or in low-stakes applications where a lightweight string similarity check is sufficient. The prompt is designed to be wired into a post-generation validation harness, where a validator first flags a potential quote inaccuracy, and this prompt is then invoked with the specific source text and generated quote to produce a corrected version or a confirmation of accuracy.

Before integrating this prompt, ensure your pipeline can reliably extract the generated quote and its corresponding source passage. The prompt's effectiveness depends on receiving a precise [SOURCE_TEXT] and [GENERATED_QUOTE]. If your system cannot isolate these inputs, the verification will be unreliable. After receiving the output, you should run a secondary validation, such as a quote fidelity score or a human review step for high-risk documents, before presenting the corrected quote to the end user. Avoid using this prompt in a loop without a retry budget; if it fails to resolve the inaccuracy after a set number of attempts, escalate to a human reviewer or log the failure for offline analysis.

This template is designed to be copied directly into your prompt management system or codebase. It accepts a claimed quote, the source text it was supposedly drawn from, and a set of constraints that define what constitutes an acceptable quote. The square-bracket placeholders represent the dynamic data your application must supply at runtime. Replace each placeholder with actual values before sending the prompt to the model. Do not leave unresolved placeholders in production requests.

textCopy
You are a quote accuracy verifier for a document intelligence system. Your job is to compare a claimed quote against the provided source text and determine whether the quote is accurate, contains boundary errors, or is a paraphrase presented as a direct quote.

## INPUT

**Claimed Quote:**
[CLAIMED_QUOTE]

**Source Text:**
[SOURCE_TEXT]

**Source Metadata:**
- Document ID: [DOCUMENT_ID]
- Section/Page: [SECTION_REFERENCE]
- Retrieval Timestamp: [RETRIEVAL_TIMESTAMP]

## CONSTRAINTS

- Quote fidelity threshold: [FIDELITY_THRESHOLD] (e.g., "exact", "minor-variance-allowed", "substantive-match")
- Maximum allowed character deviation: [MAX_CHAR_DEVIATION]
- Flag paraphrases as quotes: [FLAG_PARAPHRASES] (true/false)
- Flag boundary errors: [FLAG_BOUNDARY_ERRORS] (true/false)
- Flag omitted context that changes meaning: [FLAG_OMITTED_CONTEXT] (true/false)

## OUTPUT SCHEMA

Return a JSON object with this exact structure:
{
  "quote_fidelity_score": number (0.0 to 1.0),
  "verdict": "accurate" | "boundary_error" | "paraphrase_not_quote" | "fabricated" | "meaning_altering_omission",
  "deviations": [
    {
      "type": "substitution" | "insertion" | "deletion" | "boundary_shift" | "paraphrase" | "omission",
      "claimed_text": "string",
      "source_text": "string",
      "position_in_quote": number,
      "severity": "minor" | "moderate" | "critical"
    }
  ],
  "corrected_quote": "string or null if no correction possible",
  "correction_notes": "string explaining what was changed and why",
  "requires_human_review": boolean,
  "human_review_reason": "string or null"
}

## INSTRUCTIONS

1. Locate the claimed quote within the source text using exact or near-exact matching.
2. Identify every character-level difference between the claimed quote and the matching source passage.
3. Classify each deviation by type and severity.
4. If the claimed quote is a paraphrase rather than a direct quote, set verdict to "paraphrase_not_quote" and do not attempt correction.
5. If the claimed quote cannot be found in the source text at all, set verdict to "fabricated" and fidelity_score to 0.0.
6. If boundary errors exist, produce a corrected quote that starts and ends at the correct source positions.
7. If meaning-altering omissions are detected, flag them and produce a corrected quote that restores essential context.
8. Set requires_human_review to true when: fidelity_score < [AUTO_APPROVAL_THRESHOLD], verdict is "fabricated", or any deviation has "critical" severity.
9. If the quote is accurate, set deviations to an empty array and corrected_quote to null.

## RISK LEVEL

[RISK_LEVEL]

If RISK_LEVEL is "high", every output must set requires_human_review to true regardless of fidelity score.

Adaptation guidance: Replace each bracketed placeholder with values from your application context. The [CLAIMED_QUOTE] should contain the exact text the model or user presented as a quote. The [SOURCE_TEXT] must be the full passage from which the quote was allegedly drawn—do not truncate it, as boundary error detection depends on seeing text before and after the quoted region. The [FIDELITY_THRESHOLD] controls how strict the comparison is: use "exact" for legal or compliance workflows, "minor-variance-allowed" for most business applications, and "substantive-match" for informal use cases. The [AUTO_APPROVAL_THRESHOLD] should be set higher than [FIDELITY_THRESHOLD] to create a safety margin. For regulated domains, set [RISK_LEVEL] to "high" to force human review on every verification.

What to do next: After copying this template, wire it into your retry harness so it triggers automatically when a citation validation step fails. Store the output JSON in your observability system for audit trails. If requires_human_review is true, route the verification result to your review queue before allowing the quoted text to appear in user-facing output. Test this prompt against a golden dataset of known accurate quotes, boundary errors, and fabrications before deploying to production.

The Quote Accuracy Verification Retry Prompt is not a standalone prompt—it is a recovery stage inside a larger document intelligence harness. The typical flow begins when an upstream answer generator produces a response containing quoted material. A lightweight pre-check (string matching or embedding similarity) flags potential quote inaccuracies. The flagged output, along with the original source passage and the claimed quote, is then routed to this retry prompt for structured verification. The prompt returns a fidelity assessment, a corrected quote if needed, and a confidence score that downstream systems can act on.

Wire this prompt into your application as a gated recovery step. After receiving the verification result, parse the quote_fidelity_score (0.0–1.0) and the correction_required boolean. If correction_required is true and quote_fidelity_score is below your threshold (we recommend 0.85 for compliance-sensitive workflows), replace the original quote with the corrected_quote field. Log both the original and corrected versions with the fidelity score for audit trails. If the fidelity score falls below a second, lower threshold (e.g., 0.5), route the entire answer to human review rather than applying the correction automatically. Implement idempotency keys based on the source passage hash and claimed quote to prevent duplicate verification calls. For model choice, prefer Claude 3.5 Sonnet or GPT-4o for their strong instruction-following on structured comparison tasks; avoid smaller models that may conflate paraphrases with exact quotes.

Build validation around the output schema before accepting the correction. Confirm that corrected_quote is a substring of source_passage (or null if no correction is possible). Reject corrections where the fidelity score is high but the corrected quote differs from the original—this indicates a schema violation or model confusion. Add a retry budget: if the verification prompt itself returns malformed JSON or fails schema validation, retry once with the same inputs and a stronger format constraint appended to the prompt. After two failures, log the incident and escalate the original answer to human review. For observability, emit metrics on quote fidelity score distributions, correction rates, and retry exhaustion events so you can detect drift in upstream answer quality or retrieval precision over time.