Source Attribution and Citation in RAG

"Citing your sources is not pedantry. It is the difference between a trustworthy assistant and a confident confabulator."

RAG, Scrupulously Footnoted AI Agent

1. Why Attribution Matters

Source attribution serves multiple purposes beyond user trust:

• Verifiability: Users can click through to the source document and confirm claims, reducing the effective hallucination rate by enabling human verification
• Accountability: When answers are wrong, citations enable root-cause analysis: was the source document incorrect, was the wrong passage retrieved, or did the LLM misinterpret the evidence?
• Compliance: Regulated industries (finance, healthcare, legal) require audit trails showing which documents informed a decision. EU AI Act transparency requirements increasingly mandate explainable outputs.
• Freshness signals: Citations that include document dates let users assess whether the information is current
• Feedback loops: Tracking which sources are cited most frequently reveals which documents are most valuable, informing corpus curation

2. Prompt-Level Attribution Strategies

The simplest approach to attribution is instructing the LLM to cite its sources within the generation prompt. This works surprisingly well with capable models but requires careful prompt design.

Inline Citation with Source IDs

def build_attributed_prompt(query, retrieved_chunks):
 """Build a prompt that instructs the LLM to cite sources inline."""
 context_block = ""
 for i, chunk in enumerate(retrieved_chunks):
 source_id = f"[{i+1}]"
 context_block += (
 f"Source {source_id}: {chunk['title']}\n"
 f" URL: {chunk['url']}\n"
 f" Content: {chunk['text']}\n\n"
 )

 system_prompt = """You are a research assistant. Answer the user's question
using ONLY the provided sources. Follow these citation rules strictly:

1. Every factual claim must have an inline citation like [1], [2], etc.
2. If multiple sources support a claim, cite all of them: [1][3].
3. If no source supports a claim, do not make it. Say "I could not find
 information about this in the provided sources."
4. At the end, list all cited sources with their titles and URLs.
5. Never cite a source for a claim it does not actually support."""

 return system_prompt, f"Sources:\n{context_block}\nQuestion: {query}"

# Example usage
chunks = [
 {"title": "Returns Policy", "url": "/docs/returns", "text": "Items may be returned within 30 days..."},
 {"title": "Warranty Guide", "url": "/docs/warranty", "text": "Electronics carry a 2-year warranty..."},
]
system, user_msg = build_attributed_prompt("What is the return window?", chunks)
# LLM output: "Items can be returned within 30 days of purchase [1].
# Electronics also carry a 2-year warranty [2].
#
# Sources:
# [1] Returns Policy - /docs/returns
# [2] Warranty Guide - /docs/warranty"

Structured Output with Citation Objects

For programmatic consumption, structured output formats are more reliable than parsing inline citations from free text:

from pydantic import BaseModel
from openai import OpenAI

class Citation(BaseModel):
 source_id: int
 quote: str # Exact quote from the source that supports the claim

class AnswerStatement(BaseModel):
 claim: str
 citations: list[Citation]

class AttributedAnswer(BaseModel):
 statements: list[AnswerStatement]
 unsupported_aspects: list[str] # Parts of the question with no source support

client = OpenAI()

def generate_attributed_answer(query, chunks):
 """Generate a structured answer with per-claim citations."""
 context = "\n".join(
 f"[Source {i+1}]: {c['text']}" for i, c in enumerate(chunks)
 )

 response = client.beta.chat.completions.parse(
 model="gpt-4o",
 messages=[
 {"role": "system", "content": (
 "Answer the question using only the provided sources. "
 "For each statement, include the source ID and an exact "
 "quote from that source as evidence. List any aspects of "
 "the question that the sources do not address."
 )},
 {"role": "user", "content": f"Sources:\n{context}\n\nQuestion: {query}"}
 ],
 response_format=AttributedAnswer,
 )
 return response.choices[0].message.parsed

3. Post-Generation Citation Verification

Prompt-level attribution tells the model to cite sources, but does not guarantee accuracy. Verification checks whether each citation actually supports its associated claim.

NLI-Based Verification

Natural Language Inference (NLI) models classify the relationship between a premise (the source text) and a hypothesis (the generated claim) as entailment, contradiction, or neutral. A valid citation should produce an entailment score above a threshold.

from transformers import pipeline

nli = pipeline("text-classification", model="cross-encoder/nli-deberta-v3-large")

def verify_citations(statements, source_texts):
 """Verify that each citation's source actually supports its claim."""
 results = []
 for stmt in statements:
 claim = stmt.claim
 for cit in stmt.citations:
 source = source_texts[cit.source_id - 1]
 # NLI: does the source entail the claim?
 result = nli(f"{source}", f"{claim}")
 label = result[0]["label"]
 score = result[0]["score"]
 results.append({
 "claim": claim,
 "source_id": cit.source_id,
 "nli_label": label,
 "nli_score": score,
 "verified": label == "ENTAILMENT" and score > 0.7
 })
 return results

# Flag unverified citations for human review or removal

Quote Matching Verification

When citations include exact quotes (as in the structured output approach), a simpler verification checks whether the quote actually appears in the source document. Fuzzy string matching handles minor formatting differences:

from rapidfuzz import fuzz

def verify_quote(quote, source_text, threshold=85):
 """Check if a citation quote actually appears in the source."""
 # Try exact substring match first
 if quote.lower() in source_text.lower():
 return {"match": "exact", "score": 100}

 # Fall back to fuzzy matching for minor variations
 # Slide a window of quote-length across the source
 best_score = 0
 quote_len = len(quote)
 for i in range(len(source_text) - quote_len + 1):
 window = source_text[i:i + quote_len]
 score = fuzz.ratio(quote.lower(), window.lower())
 best_score = max(best_score, score)
 if best_score >= threshold:
 return {"match": "fuzzy", "score": best_score}

 return {"match": "none", "score": best_score}

4. End-to-End Attribution Architectures

Production attribution systems combine multiple strategies into a pipeline:

1. Retrieval with provenance metadata: Every chunk carries its source document ID, URL, page number, paragraph index, and ingestion timestamp. This metadata propagates through the entire pipeline.
2. Attributed generation: The LLM generates answers with inline citations using structured output (Section 2 above).
3. Citation verification: An NLI model or quote-matching pipeline verifies each citation. Unverified citations are either removed or flagged.
4. Citation enrichment: Verified citations are enriched with display metadata (document title, section heading, page number, deep link URL) for the frontend.
5. Feedback collection: Users can flag incorrect citations, creating a feedback loop for improving retrieval and generation quality.

Granularity Levels

Citation granularity is a critical design decision:

ALCE: The Attribution Benchmark

The Automatic LLM Citation Evaluation (ALCE) benchmark (Gao et al., 2023) provides standardized evaluation for attribution quality. It measures:

• Citation precision: What fraction of citations actually support their claims?
• Citation recall: What fraction of claims that should be cited are actually cited?
• Fluency: Does adding citations degrade the natural flow of the response?

ALCE uses NLI models as automated judges. A citation is considered correct if an NLI model classifies the source passage as entailing the associated claim with high confidence. This automated evaluation enables rapid iteration on attribution prompts and architectures without requiring expensive human annotation.

5. Common Failure Modes

• Citation hallucination: The model invents a plausible citation to a source that does not exist in the retrieved context. Mitigation: constrain citations to a fixed set of source IDs provided in the prompt.
• Citation displacement: The model cites the correct source but for the wrong claim. Mitigation: per-claim verification with NLI.
• Over-citation: Every sentence is cited to every source, making citations meaningless. Mitigation: penalize citation count in the prompt or post-process to remove redundant citations.
• Under-citation: Key claims are generated without attribution, especially for information the model "knows" from pretraining. Mitigation: explicit prompting that all claims must be sourced, with a fallback statement for unsupported claims.
• Stale citations: The cited document has been updated or removed since ingestion. Mitigation: include ingestion timestamps in metadata and periodically re-index.

6. Integration with Hallucination Detection

Attribution and hallucination detection are complementary. A claim with no valid citation is a candidate hallucination. A claim with a verified citation but low semantic similarity to the source may be a subtle hallucination. Production systems typically combine both:

1. Generate answer with citations (this section)
2. Verify citations via NLI (this section)
3. Run hallucination detection on uncited claims (Section 32.2)
4. Score overall answer faithfulness using evaluation frameworks (RAGAS, DeepEval)