Citation Format Normalization Prompt Template

This prompt is a post-generation repair tool for platforms that must enforce a single citation style across all model outputs. The primary job-to-be-done is converting a messy, multi-format block of text with citations into a clean, consistently formatted output that matches a specified target style (APA, MLA, Chicago, numeric, or a custom schema). The ideal user is a product engineer or platform developer integrating an LLM into a RAG system, academic tool, or documentation platform where inconsistent citation formatting breaks downstream rendering, search indexing, or compliance checks. You should use this prompt when your model has already produced a useful answer but the citations are a mix of styles, incomplete, or malformed—and you need a reliable normalization step before the text reaches a user or a database.

This prompt requires specific inputs to function correctly. You must provide the original text containing citations ([INPUT]), the target citation format as a clear specification ([TARGET_FORMAT]), and ideally a reference map or source corpus ([SOURCE_MAP]) to verify that normalized citations still point to real sources. The prompt outputs both the normalized text and a per-citation compliance score, which acts as a built-in quality gate. In a production pipeline, you should wire this prompt after your primary generation step and before any rendering or storage step. If a citation's compliance score falls below your threshold (e.g., 0.8), route it for human review or discard it rather than displaying a broken citation to users. The compliance score checks for structural correctness (does it match the target format?) and reference integrity (does the normalized citation still map to a valid source?).

Do not use this prompt as a substitute for proper citation generation during the initial RAG or text-generation step. It is a repair tool, not a primary authoring tool. If your model consistently produces malformed citations, fix the upstream prompt or retrieval pipeline first. Also, do not use this prompt when the input text contains no citations at all—it will hallucinate or produce false positives. This prompt is not designed for legal or regulatory filings where citation format errors carry compliance risk; in those contexts, always require human review of the normalized output. Finally, avoid using this prompt on extremely long documents (over 10,000 words) in a single call; chunk the input by section and normalize each chunk independently, then reassemble with a cross-reference check to ensure citation numbering remains consistent across chunks.

This template accepts a body of text containing citations in any format—APA, MLA, Chicago, numeric, or hybrid—and converts every inline citation and reference list entry to a single target style. It is designed for platforms that ingest model outputs from multiple sources and must enforce a consistent citation surface before displaying content to users or storing it in a database. The prompt does not verify whether citations point to real sources; pair it with the Citation-to-Evidence Alignment or Hallucinated Citation Removal playbooks if source grounding is required.

codeCopy
You are a citation normalization engine. Your job is to convert all citations in the provided text to a single target format while preserving every reference and its associated claim. Do not add, remove, or alter any factual claims. Do not invent sources.

## INPUT TEXT
[INPUT]

## TARGET CITATION STYLE
[TARGET_STYLE]

## STYLE SPECIFICATION
[STYLE_SPEC]

## OUTPUT SCHEMA
Return a JSON object with the following structure:
{
  "normalized_text": "The full input text with all inline citations converted to the target style.",
  "reference_list": [
    {
      "original_id": "Identifier or position from the input.",
      "normalized_citation": "The reference formatted in the target style.",
      "status": "converted | unchanged | partial"
    }
  ],
  "compliance_report": {
    "total_citations": 0,
    "fully_converted": 0,
    "partially_converted": 0,
    "unresolvable": 0,
    "per_citation_scores": [
      {
        "original_id": "Identifier or position.",
        "score": 0.0,
        "issues": []
      }
    ]
  }
}

## CONVERSION RULES
1. Identify every inline citation and reference list entry in the input, regardless of format.
2. Map each inline citation to its corresponding reference list entry.
3. Convert both inline and reference list entries to the target style.
4. If a reference lacks required fields for the target style, mark it as "partial" and list the missing fields in "issues."
5. If a citation cannot be mapped to any reference entry, mark it as "unresolvable."
6. Preserve all non-citation text exactly as it appears.
7. For numeric styles, renumber citations sequentially in order of first appearance.

## COMPLIANCE SCORING
Score each citation from 0.0 to 1.0:
- 1.0: All required fields present and correctly formatted.
- 0.7-0.9: Minor formatting issues but all required fields present.
- 0.4-0.6: Missing one required field.
- 0.1-0.3: Missing multiple required fields.
- 0.0: Unresolvable or no usable metadata.

## CONSTRAINTS
[CONSTRAINTS]

## EXAMPLES
[EXAMPLES]

Adapt this template by replacing the placeholders. [TARGET_STYLE] should be a named style like "APA 7th" or "Chicago author-date." [STYLE_SPEC] should contain the exact formatting rules—include field order, punctuation, italics, and capitalization requirements. [CONSTRAINTS] can specify additional rules such as "do not modify URLs" or "preserve original DOIs even if the target style normally omits them." [EXAMPLES] should include at least one before-and-after pair showing a citation converted from a common source format to the target style. For high-stakes use cases like legal or academic publishing, add a human-review step after normalization and log every citation that scores below 0.7 in the compliance report.

The Citation Format Normalization prompt is designed to be called as a post-generation repair step, not as a real-time user-facing endpoint. In a typical RAG or documentation pipeline, the primary model generates a response with citations in whatever format it produces naturally. That output is then routed through this normalization prompt before it reaches the user or a downstream database. This separation keeps the primary generation prompt simpler and allows the normalization step to be versioned, tested, and monitored independently. The normalization call should be treated as a deterministic transformation layer: same input citations, same target style, same output.

Wire the prompt into your application as an async post-processing hook. After the primary model returns, extract all citation-bearing text and pass it to the normalization prompt with a clear [TARGET_STYLE] parameter (e.g., APA 7th, MLA 9th, Chicago author-date, Vancouver numeric). The prompt returns structured JSON containing the normalized text, a per-citation compliance score, and a list of citations that could not be fully normalized. Validate the JSON response against a schema that requires normalized_text, citation_audit (array of objects with original, normalized, compliance_score, and warnings), and unresolvable (array of citations that failed normalization). If the JSON is malformed, retry once with a stricter schema reminder. If the compliance score for any individual citation falls below a configurable threshold (we recommend 0.7 as a starting point), route that citation to a human review queue rather than silently publishing a broken reference. Log every normalization call with input hash, target style, compliance score distribution, and unresolved count for production monitoring.

Model choice matters here. This is a structured transformation task that benefits from models with strong instruction-following and JSON output discipline. GPT-4o, Claude 3.5 Sonnet, and Gemini 1.5 Pro all perform well. Avoid smaller or older models that may hallucinate citation fields or invent DOIs to fill gaps. Set temperature=0 to maximize deterministic output. If your pipeline processes high volumes, consider batching multiple citation blocks into a single normalization call to reduce API overhead, but keep batches under 8,000 tokens of input to avoid attention dilution on individual citations. For regulated domains such as legal or academic publishing, always require human review on any citation that received a compliance score below 0.9, and never auto-publish normalized citations without an audit trail that maps each output citation back to its original form and the normalization decisions applied.