RAG Citation Answer Repair Prompt Template

This prompt is for RAG product teams who receive model-generated answers where inline citations are broken, missing, or point to the wrong source chunks. The primary job-to-be-done is automated post-generation repair: taking an answer that failed citation validation and producing a corrected version where every claim is properly attributed to a specific chunk in the provided retrieval context. The ideal user is a backend engineer or ML engineer integrating this repair step into a RAG pipeline before the answer reaches the end user or a downstream system of record.

Use this prompt when your RAG pipeline already retrieves source chunks and generates an initial answer, but the citation layer is unreliable. Common triggers include: inline reference IDs that don't match any chunk in the retrieval set, citation markers placed next to claims the cited chunk doesn't support, missing citations on factual statements, or hallucinated references to sources that don't exist in your corpus. The prompt requires the original answer text, the full set of retrieved source chunks with their IDs, and a defined citation format as inputs. It is designed for single-answer repair, not batch processing of multiple answers simultaneously.

Do not use this prompt as a substitute for fixing upstream retrieval or generation quality. If your retriever consistently fails to surface relevant chunks, or your generator ignores provided context, this repair prompt will produce empty citations or flag most claims as unsupported—which is correct behavior but indicates a deeper pipeline problem. This prompt also should not be used for real-time streaming answers where latency is critical; the repair step adds a full model inference round-trip. For high-stakes domains like healthcare or legal, always route the repair output through human review before publication, and use the hallucination audit log this prompt produces as a review aid, not a final verdict.

This template is designed to be dropped directly into your RAG pipeline's post-generation repair loop. It expects a previously generated answer, the set of retrieved source chunks that were available during generation, and a set of repair instructions. The prompt instructs the model to align inline citation markers with actual source content, flag unsupported claims, and produce a corrected answer alongside an audit log. All placeholders use square brackets for easy string replacement in your application code.

textCopy
You are a citation repair specialist. Your task is to fix broken, missing, or misaligned citations in a generated answer.

## INPUT
**Generated Answer:**
[GENERATED_ANSWER]

**Retrieved Source Chunks:**
[RETRIEVED_CHUNKS]

**Repair Instructions:**
[REPAIR_INSTRUCTIONS]

## CONSTRAINTS
- Every factual claim in the answer must be traceable to at least one source chunk.
- Inline citation markers must use the format [SOURCE_ID] where SOURCE_ID matches an ID in the retrieved chunks.
- If a claim cannot be supported by any source chunk, mark it with [UNSUPPORTED] and do not fabricate a citation.
- Do not alter the meaning or wording of the original answer except to fix citations and mark unsupported claims.
- Preserve the original paragraph structure and flow.

## OUTPUT SCHEMA
Return a JSON object with exactly these fields:
{
  "repaired_answer": "string (the full answer text with corrected citation markers)",
  "audit_log": [
    {
      "claim": "string (the claim text)",
      "original_citation": "string or null",
      "repaired_citation": "string or null",
      "action": "kept | remapped | removed | flagged_unsupported",
      "source_chunk_id": "string or null",
      "confidence": "high | medium | low"
    }
  ],
  "unsupported_claims": ["string (claim text for each unsupported claim)"],
  "repair_summary": "string (brief summary of changes made)"
}

## EXAMPLES
[REPAIR_EXAMPLES]

## RISK LEVEL
[RISK_LEVEL]

## INSTRUCTIONS
1. Extract every factual claim from the generated answer.
2. For each claim, search the retrieved source chunks for supporting evidence.
3. If a citation marker exists but points to the wrong chunk, remap it to the correct SOURCE_ID.
4. If a claim has no citation but is supported by a chunk, add the correct citation marker.
5. If a claim has a citation but the cited chunk does not support it, remove the citation and flag as unsupported.
6. If a claim has no supporting evidence in any chunk, mark it with [UNSUPPORTED].
7. Reconstruct the answer with corrected citations.
8. Build the audit log documenting every change.
9. Output only valid JSON. No markdown fences, no commentary.

Adapt this template by replacing each square-bracket placeholder with values from your application context. [GENERATED_ANSWER] should contain the raw model output that failed citation validation. [RETRIEVED_CHUNKS] must include source IDs and full text for every chunk that was available during generation—without this, the repair model cannot verify claims. [REPAIR_INSTRUCTIONS] can specify additional rules such as preferred citation style, minimum confidence thresholds, or domain-specific requirements. [REPAIR_EXAMPLES] should include one or two few-shot examples showing a broken answer, the source chunks, and the correctly repaired output. [RISK_LEVEL] should be set to high if the output will be shown to users without human review, triggering stricter abstention behavior. Wire this prompt into a repair loop that runs after your primary generation step and before the answer reaches the user. Always validate the JSON output against the schema before accepting the repair, and log every audit trail for downstream monitoring.

This prompt is designed to sit inside a post-generation repair loop within your RAG pipeline. After your primary answer-generation model produces a response with inline citations, you route that output through this repair prompt before it reaches the user or a downstream database. The repair prompt expects the original answer, the retrieved source chunks with their canonical IDs, and a set of repair instructions as inputs. The output is a corrected answer with aligned citations and a structured audit log. Wire this as a synchronous step in your inference harness—not as an async background job—because the repaired output is the user-facing artifact.

The implementation harness should enforce a strict contract around inputs and outputs. On the input side, validate that every source chunk has a unique, stable source_id and that the original answer contains citation markers you can parse (e.g., [1], [source-abc]). On the output side, parse the repaired answer and the accompanying audit log into typed objects. Run a citation-to-source validator that checks every citation marker in the repaired answer against the provided source list. If a citation references a source_id that doesn't exist in the input corpus, flag it for a second repair pass or escalate to human review. Log every repair attempt with the original answer hash, the repair prompt version, the model used, the validator results, and the final disposition (passed, repaired, escalated). For high-stakes domains like legal or clinical RAG, add a human approval gate that blocks unrepaired or low-confidence outputs from reaching users.

Choose a model with strong instruction-following and structured output capabilities for this repair task—GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are good defaults. Set temperature=0 to minimize variance in citation alignment. Implement a retry policy with a maximum of two repair attempts. If the validator still finds broken citations after two passes, stop retrying and route the output to a human review queue with the full audit log attached. Avoid infinite repair loops by capping attempts and by logging the specific failure reason on each pass. The audit log this prompt produces is your primary observability artifact—store it alongside the repaired answer so you can trace every citation decision back to its source chunk and repair rationale.