Multi-Source Citation Merging Prompt

This prompt is designed for knowledge base operators and RAG system builders who need to synthesize a single, coherent answer from multiple overlapping source documents. The core job-to-be-done is merging citations from several retrieved chunks into a single, deduplicated attribution chain. The ideal user is an AI engineer or product developer who already has a retrieval pipeline in place and now faces the downstream problem of presenting a unified, auditable answer to the end-user without repeating the same source or burying the reader in redundant footnotes.

Use this prompt when your retrieval step returns multiple documents that cover the same factual territory—for example, three internal policy documents that all define a company holiday schedule, or two technical specs that describe the same API parameter with minor variations. The prompt requires the following inputs: a user question, a set of retrieved documents with unique identifiers, and a defined output schema for citations. It is not suitable for single-document Q&A, for scenarios where source documents are guaranteed to be non-overlapping, or for real-time chat applications where the latency of a merge-and-deduplicate step would violate user experience constraints. If your sources are highly contradictory rather than overlapping, use the Source Conflict Disclosure Prompt instead.

Before wiring this into production, ensure you have a reliable method for assigning unique, stable identifiers to every document chunk. The prompt's deduplication logic depends on these IDs to recognize when two passages are the same source. You should also define a conflict resolution priority—such as 'prefer the most recent document' or 'prefer the document with the highest retrieval score'—and pass that rule into the prompt's [CONSTRAINTS] placeholder. Without explicit priority rules, the model will make arbitrary choices that may not match your business logic. Always pair this prompt with a post-generation validation step that checks for duplicate citations and verifies that every cited claim appears in the referenced source.

The following prompt template is designed to be dropped into a RAG pipeline after retrieval but before final answer synthesis. It accepts a list of source documents and a set of claims or a draft answer, then produces a deduplicated citation map. Use it when your retrieval step returns multiple chunks that reference the same underlying fact, or when different versions of a document create conflicting attribution chains. The template uses square-bracket placeholders for all dynamic inputs, making it safe to copy, adapt, and parameterize in code.

textCopy
You are a citation merging engine. Your job is to take a set of claims and a list of source documents, then produce a deduplicated, prioritized citation map.

## INPUT

### Claims or Draft Answer
[CLAIMS_OR_DRAFT_ANSWER]

### Source Documents
[SOURCE_DOCUMENTS]

Each source document is a JSON object with the following fields:
- id: a unique document identifier
- title: the document title
- date: the publication or revision date in ISO 8601 format
- priority: an integer from 1 (highest) to 5 (lowest) indicating source authority
- text: the relevant passage text

## TASK

1. For each claim in the input, identify all source documents that support it.
2. If multiple sources support the same claim, select the best citation using these rules in order:
   a. Prefer the source with the highest priority (lowest integer).
   b. If priorities are equal, prefer the most recent date.
   c. If dates are equal, prefer the source with the most specific supporting text (longest relevant passage).
3. If two sources contradict each other on a claim, do not merge them. Flag the conflict.
4. Remove duplicate citations where the same source is cited multiple times for the same claim.
5. For each unique claim-to-source mapping, extract the minimal verbatim quote that supports the claim (no more than 50 words).

## OUTPUT SCHEMA

Return a JSON object with this exact structure:
{
  "merged_citations": [
    {
      "claim": "The exact claim text from the input",
      "citation": {
        "source_id": "string",
        "source_title": "string",
        "source_date": "ISO 8601 string",
        "quote": "Verbatim supporting text, max 50 words",
        "priority": integer
      },
      "conflict": null or {
        "conflicting_source_id": "string",
        "conflicting_quote": "string",
        "conflict_note": "Brief description of the contradiction"
      }
    }
  ],
  "deduplication_summary": {
    "total_claims": integer,
    "unique_citations": integer,
    "duplicates_removed": integer,
    "conflicts_found": integer
  }
}

## CONSTRAINTS

- Do not invent claims not present in the input.
- Do not cite a source that does not support the claim.
- If no source supports a claim, include it in the output with citation set to null and add a note.
- Keep quotes verbatim. Do not paraphrase inside the quote field.
- If the input contains more than [MAX_CLAIMS] claims, process only the first [MAX_CLAIMS] and note the truncation.

To adapt this template for your system, replace the placeholders as follows: [CLAIMS_OR_DRAFT_ANSWER] should receive the output of your answer generation step, split into individual factual claims (use a separate claim-decomposition prompt if needed). [SOURCE_DOCUMENTS] should be populated with the top-k retrieved chunks from your vector store or search index, formatted as the JSON objects described. [MAX_CLAIMS] is a safety limit—set it based on your latency budget and token limits (start with 50 and tune from there). If your source documents lack a priority field, either add one via metadata or remove that tiebreaker rule from the prompt. Always validate the output JSON against the schema before passing citations to the final answer formatter. For high-stakes domains, route outputs with conflicts to a human reviewer before publishing.

This prompt operates as a post-retrieval, pre-synthesis step in a RAG pipeline. After your retriever returns chunks from multiple documents, pass the raw retrieved passages, their source metadata, and any existing citation markers into this prompt. The model's job is to produce a deduplicated, conflict-resolved citation map before the answer generation step consumes it. Do not use this prompt as the final answer generator—it is a citation normalization and merging utility that feeds into a downstream synthesis prompt such as the RAG Citation Answer Prompt Template or the Deterministic Citation Output Contract Prompt.

Wire the prompt into your application as a middleware function between retrieval and answer generation. The function should: (1) collect all retrieved passages with their source_id, document_title, chunk_index, retrieval_score, and text fields; (2) assemble the prompt with the [RETRIEVED_PASSAGES] placeholder populated as a structured JSON array; (3) call the model with temperature=0 and response_format set to JSON to enforce the output schema; (4) validate the returned citation map against a schema that requires merged_citations (array of unique source objects), deduplication_log (which passages were collapsed and why), and conflict_flags (where sources disagree on facts, dates, or claims). If validation fails, retry once with the validation error injected into the [PREVIOUS_ERRORS] placeholder. Log every merge decision and conflict flag for auditability—this is critical for compliance workflows where you must explain why one source was preferred over another.

For high-stakes domains, insert a human review gate after citation merging when the conflict_flags array is non-empty or when the deduplication removed more than a configurable threshold of passages. Route flagged merges to a review queue with the original passages, the merged citation map, and the conflict details. Avoid the temptation to let the model silently resolve conflicts by picking a winner—surface the disagreement explicitly. When integrating with downstream answer generation, pass only the merged_citations array (not the raw passages) to keep the context window lean and prevent the answer model from re-litigating merge decisions. Test the full pipeline with overlapping document sets where you control the ground truth, and measure both citation recall (are all unique sources preserved?) and conflict detection precision (are real disagreements flagged without noise?).