Citations et Sources RAG : Garantir la traçabilité des réponses

TL;DR

La traçabilité des sources est ce qui différencie un chatbot RAG fiable d'une boîte noire. En citant explicitement les documents sources, vous réduisez les hallucinations, augmentez la confiance utilisateur et facilitez la vérification des informations. Ce guide couvre les techniques d'implémentation, les formats de citation efficaces et les patterns pour gérer les cas complexes.

Pourquoi les citations sont essentielles en RAG

Le problème de la boîte noire

Sans citations, un chatbot RAG ressemble à n'importe quel LLM : l'utilisateur n'a aucun moyen de vérifier si la réponse vient de vos documents ou d'une hallucination du modèle.

DEVELOPERpython
# ❌ Réponse sans citation (problématique)
response = """
Le délai de rétractation est de 14 jours pour les achats en ligne.
Vous pouvez retourner le produit sans justification.
"""
# L'utilisateur ne sait pas si c'est correct

# ✅ Réponse avec citations (fiable)
response = """
Le délai de rétractation est de 14 jours pour les achats en ligne.
[Source: CGV, Section 5.2 - Droit de rétractation]

Vous pouvez retourner le produit sans justification.
[Source: FAQ Retours, Mise à jour: 15/01/2024]
"""
# L'utilisateur peut vérifier et faire confiance

Bénéfices mesurables

Architecture d'un système de citations

Les 3 approches principales

1. Citations inline (dans le texte)

DEVELOPERpython
inline_response = """
Pour bénéficier de la garantie [1], vous devez conserver
votre facture d'achat [2]. La garantie couvre les défauts
de fabrication pendant 2 ans [1].

Sources:
[1] Conditions de garantie, v2.3
[2] FAQ - Preuves d'achat
"""

Avantages : Précis, facile à suivre Inconvénients : Peut surcharger le texte

2. Citations en fin de réponse

DEVELOPERpython
footer_response = """
Pour bénéficier de la garantie, vous devez conserver votre
facture d'achat. La garantie couvre les défauts de fabrication
pendant 2 ans.

---
Sources consultées:
- Conditions de garantie, v2.3 (pertinence: 95%)
- FAQ - Preuves d'achat (pertinence: 78%)
"""

Avantages : Texte plus fluide Inconvénients : Moins précis sur quelle source pour quelle info

3. Citations cliquables (avec métadonnées)

DEVELOPERpython
rich_response = {
    "text": "Pour bénéficier de la garantie...",
    "citations": [
        {
            "id": 1,
            "text": "garantie couvre les défauts pendant 2 ans",
            "source": "Conditions de garantie",
            "version": "2.3",
            "page": 12,
            "url": "/docs/garantie#section-2",
            "confidence": 0.95
        }
    ]
}

Avantages : Riche, interactif, vérifiable Inconvénients : Complexité d'implémentation

Implémentation technique

Étape 1 : Enrichir les métadonnées des chunks

DEVELOPERpython
from dataclasses import dataclass
from datetime import datetime
from typing import Optional

@dataclass
class EnrichedChunk:
    content: str
    source_document: str
    document_type: str  # "policy", "faq", "manual", etc.
    section: Optional[str] = None
    page_number: Optional[int] = None
    version: Optional[str] = None
    last_updated: Optional[datetime] = None
    url: Optional[str] = None
    confidence_score: float = 0.0

    def to_citation(self) -> str:
        """Génère une citation formatée."""
        parts = [self.source_document]

        if self.section:
            parts.append(f"Section: {self.section}")
        if self.page_number:
            parts.append(f"Page {self.page_number}")
        if self.version:
            parts.append(f"v{self.version}")
        if self.last_updated:
            parts.append(f"MAJ: {self.last_updated.strftime('%d/%m/%Y')}")

        return " | ".join(parts)

Étape 2 : Prompt pour générer des citations

DEVELOPERpython
CITATION_PROMPT = """
Tu es un assistant qui répond aux questions en citant ses sources.

## Règles de citation
1. Chaque affirmation factuelle DOIT être suivie d'une citation
2. Format: [Source: Nom du document, Section X]
3. Si plusieurs sources confirment, cite la plus pertinente
4. Si aucune source ne confirme, ne fais PAS l'affirmation

## Documents disponibles
{formatted_context}

## Question
{query}

## Ta réponse (avec citations obligatoires)
"""

def format_context_with_ids(chunks: list[EnrichedChunk]) -> str:
    """Formate le contexte avec des identifiants pour citation."""
    formatted = []

    for i, chunk in enumerate(chunks, 1):
        citation_ref = chunk.to_citation()
        formatted.append(f"""
[Document {i}]
Source: {citation_ref}
Contenu:
{chunk.content}
---
""")

    return "\n".join(formatted)

Étape 3 : Parser et valider les citations

DEVELOPERpython
import re
from typing import List, Tuple

def extract_citations(response: str) -> List[Tuple[str, str]]:
    """Extrait les citations du texte de réponse."""
    pattern = r'\[Source:\s*([^\]]+)\]'
    matches = re.findall(pattern, response)
    return matches

def validate_citations(
    response: str,
    available_sources: List[str]
) -> dict:
    """Valide que les citations correspondent aux sources réelles."""
    citations = extract_citations(response)

    results = {
        "valid": [],
        "invalid": [],
        "missing_citations": False
    }

    for citation in citations:
        # Vérification fuzzy pour gérer les variations
        matched = False
        for source in available_sources:
            if fuzzy_match(citation, source, threshold=0.8):
                results["valid"].append(citation)
                matched = True
                break

        if not matched:
            results["invalid"].append(citation)

    # Vérifier si la réponse contient des affirmations sans citations
    sentences = response.split('.')
    for sentence in sentences:
        if is_factual_claim(sentence) and not has_citation(sentence):
            results["missing_citations"] = True
            break

    return results

def fuzzy_match(s1: str, s2: str, threshold: float) -> bool:
    """Compare deux chaînes avec tolérance."""
    from difflib import SequenceMatcher
    ratio = SequenceMatcher(None, s1.lower(), s2.lower()).ratio()
    return ratio >= threshold

def is_factual_claim(sentence: str) -> bool:
    """Détecte si une phrase contient une affirmation factuelle."""
    factual_indicators = [
        "est de", "coûte", "dure", "permet de",
        "nécessite", "garantit", "offre", "inclut",
        "jours", "heures", "euros", "%"
    ]
    return any(ind in sentence.lower() for ind in factual_indicators)

def has_citation(sentence: str) -> bool:
    """Vérifie si une phrase a une citation."""
    return bool(re.search(r'\[Source:', sentence))

Étape 4 : Post-processing des réponses

DEVELOPERpython
class CitationProcessor:
    def __init__(self, chunks: List[EnrichedChunk]):
        self.chunks = chunks
        self.source_map = {
            chunk.to_citation(): chunk for chunk in chunks
        }

    def process_response(self, response: str) -> dict:
        """Traite une réponse pour enrichir les citations."""

        # Extraire les citations
        citations = extract_citations(response)

        # Enrichir avec les métadonnées
        enriched_citations = []
        for citation_text in citations:
            for source_key, chunk in self.source_map.items():
                if fuzzy_match(citation_text, source_key, 0.7):
                    enriched_citations.append({
                        "text": citation_text,
                        "source": chunk.source_document,
                        "section": chunk.section,
                        "url": chunk.url,
                        "confidence": chunk.confidence_score,
                        "excerpt": chunk.content[:200] + "..."
                    })
                    break

        # Calculer le score de traçabilité
        total_claims = count_factual_claims(response)
        cited_claims = len(citations)
        traceability_score = cited_claims / max(total_claims, 1)

        return {
            "response": response,
            "citations": enriched_citations,
            "traceability_score": traceability_score,
            "fully_sourced": traceability_score >= 0.9
        }

Formats de citations par contexte

Support client

DEVELOPERpython
SUPPORT_CITATION_FORMAT = """
Format de citation pour le support:
- Utilisez [Réf: CODE] pour les codes produit
- Utilisez [Doc: NOM] pour la documentation
- Utilisez [FAQ: #ID] pour les questions fréquentes

Exemple:
"Votre produit [Réf: SKU-12345] est couvert par notre garantie
de 2 ans [Doc: Conditions Générales]. Pour un retour, suivez
la procédure standard [FAQ: #RET-001]."
"""

Documentation technique

DEVELOPERpython
TECH_CITATION_FORMAT = """
Format de citation technique:
- API: [API: endpoint, version]
- Code: [Code: fichier:ligne]
- Doc: [Doc: page#section]

Exemple:
"Pour authentifier, utilisez le endpoint /auth/token [API: v2.1].
Le rate limiting est de 100 req/min [Doc: API-Limits#section-3].
Voir l'implémentation de référence [Code: examples/auth.py:45]."
"""

Juridique / Conformité

DEVELOPERpython
LEGAL_CITATION_FORMAT = """
Format de citation juridique:
- Loi: [Loi: Référence, Article X]
- Règlement: [Règl: Nom, Art. X]
- Contrat: [Contrat: Section X.Y]

Exemple:
"Conformément au RGPD [Règl: UE 2016/679, Art. 17], vous avez
le droit à l'effacement de vos données. Notre politique interne
[Contrat: Politique Données, Section 4.2] détaille la procédure."
"""

Gestion des cas complexes

1. Information provenant de plusieurs sources

DEVELOPERpython
def handle_multi_source_claim(claim: str, sources: List[EnrichedChunk]) -> str:
    """Gère les affirmations confirmées par plusieurs sources."""

    if len(sources) == 1:
        return f"{claim} [{sources[0].to_citation()}]"

    elif len(sources) <= 3:
        # Liste toutes les sources
        citations = ", ".join([s.to_citation() for s in sources])
        return f"{claim} [Sources: {citations}]"

    else:
        # Trop de sources, résumer
        primary = sources[0].to_citation()
        return f"{claim} [{primary} et {len(sources)-1} autres sources]"

2. Sources contradictoires

DEVELOPERpython
CONTRADICTION_PROMPT = """
Si les documents se contredisent:
1. Mentionne les deux versions
2. Indique la source la plus récente ou autoritaire
3. Recommande de vérifier

Exemple:
"Selon notre FAQ (mise à jour en 2023), le délai est de 14 jours
[Source: FAQ v3.2]. Cependant, nos CGV mentionnent 30 jours
[Source: CGV v2.1, 2022]. Je recommande de vous référer à la FAQ
plus récente ou de contacter le service client pour confirmation."
"""

3. Information partielle

DEVELOPERpython
PARTIAL_INFO_PROMPT = """
Si l'information est incomplète dans les sources:
1. Fournis ce qui est disponible avec citation
2. Indique clairement ce qui manque
3. Suggère où trouver l'info complète

Exemple:
"Notre documentation indique que le produit est compatible avec
Windows et macOS [Source: Fiche Technique]. La compatibilité
Linux n'est pas mentionnée dans mes sources. Pour cette information,
je vous invite à contacter le support technique."
"""

4. Aucune source pertinente

DEVELOPERpython
NO_SOURCE_RESPONSE = """
Je n'ai pas trouvé d'information sur ce sujet dans notre
documentation. Voici ce que je peux vous proposer:

1. Contacter notre support: [email protected]
2. Consulter notre centre d'aide: help.company.com
3. Reformuler votre question avec des termes différents

[Note: Réponse non sourcée - vérification recommandée]
"""

Interface utilisateur pour les citations

Affichage interactif

DEVELOPERtypescript
// Composant React pour afficher les citations
interface Citation {
  id: number;
  text: string;
  source: string;
  url?: string;
  confidence: number;
  excerpt: string;
}

interface CitedResponseProps {
  response: string;
  citations: Citation[];
}

function CitedResponse({ response, citations }: CitedResponseProps) {
  const [expandedCitation, setExpandedCitation] = useState<number | null>(null);

  // Parser le texte pour les références [1], [2], etc.
  const renderWithCitations = (text: string) => {
    const parts = text.split(/(\[\d+\])/g);

    return parts.map((part, index) => {
      const match = part.match(/\[(\d+)\]/);
      if (match) {
        const citationId = parseInt(match[1]);
        const citation = citations.find(c => c.id === citationId);

        return (
          <CitationBadge
            key={index}
            citation={citation}
            onClick={() => setExpandedCitation(citationId)}
          />
        );
      }
      return <span key={index}>{part}</span>;
    });
  };

  return (
    <div className="cited-response">
      <div className="response-text">
        {renderWithCitations(response)}
      </div>

      {expandedCitation && (
        <CitationDetail
          citation={citations.find(c => c.id === expandedCitation)}
          onClose={() => setExpandedCitation(null)}
        />
      )}

      <div className="sources-summary">
        <h4>Sources ({citations.length})</h4>
        {citations.map(c => (
          <SourceLink key={c.id} citation={c} />
        ))}
      </div>
    </div>
  );
}

Indicateur de confiance

DEVELOPERtypescript
function ConfidenceIndicator({ score }: { score: number }) {
  const getLevel = (score: number) => {
    if (score >= 0.9) return { label: "Très fiable", color: "green" };
    if (score >= 0.7) return { label: "Fiable", color: "blue" };
    if (score >= 0.5) return { label: "Modéré", color: "yellow" };
    return { label: "À vérifier", color: "red" };
  };

  const { label, color } = getLevel(score);

  return (
    <div className={`confidence-badge confidence-${color}`}>
      {label} ({Math.round(score * 100)}%)
    </div>
  );
}

Métriques et monitoring

KPIs de traçabilité

DEVELOPERpython
class CitationMetrics:
    def __init__(self):
        self.metrics = {
            "total_responses": 0,
            "fully_cited": 0,
            "partially_cited": 0,
            "uncited": 0,
            "invalid_citations": 0,
            "user_verifications": 0
        }

    def record_response(self, response_data: dict):
        self.metrics["total_responses"] += 1

        score = response_data["traceability_score"]
        if score >= 0.9:
            self.metrics["fully_cited"] += 1
        elif score >= 0.5:
            self.metrics["partially_cited"] += 1
        else:
            self.metrics["uncited"] += 1

    def get_report(self) -> dict:
        total = self.metrics["total_responses"]
        return {
            "traceability_rate": self.metrics["fully_cited"] / total,
            "partial_rate": self.metrics["partially_cited"] / total,
            "uncited_rate": self.metrics["uncited"] / total,
            "verification_rate": self.metrics["user_verifications"] / total
        }

Alertes automatiques

DEVELOPERpython
def check_citation_quality(response_data: dict) -> List[str]:
    """Génère des alertes si la qualité des citations est insuffisante."""
    alerts = []

    if response_data["traceability_score"] < 0.5:
        alerts.append("WARN: Réponse faiblement sourcée")

    if response_data.get("invalid_citations"):
        alerts.append("ERROR: Citations invalides détectées")

    if response_data.get("contradictions"):
        alerts.append("INFO: Sources contradictoires utilisées")

    return alerts

Intégration avec Ailog

Ailog gère automatiquement les citations avec :

• Extraction automatique des métadonnées de documents
• Génération de citations inline ou en footer
• Validation des sources en temps réel
• Interface cliquable pour explorer les sources

DEVELOPERpython
from ailog import AilogClient

client = AilogClient(api_key="your-key")

response = client.chat(
    channel_id="support-widget",
    message="Quel est le délai de retour ?",
    citation_settings={
        "enabled": True,
        "format": "inline",  # ou "footer", "rich"
        "include_confidence": True,
        "max_citations": 3
    }
)

print(response.text)
# "Le délai de retour est de 30 jours [Source: CGV, Art. 5.2]..."

for citation in response.citations:
    print(f"- {citation.source}: {citation.excerpt}")

Conclusion

Un système de citations bien implémenté transforme votre chatbot RAG d'une boîte noire en un assistant de confiance. Les clés :

1. Métadonnées riches sur vos documents
2. Prompts explicites sur les règles de citation
3. Validation automatique des citations générées
4. Interface claire pour l'utilisateur
5. Monitoring continu de la qualité

Ressources complémentaires

• Introduction au RAG - Fondamentaux du RAG
• Génération LLM pour RAG - Guide parent
• Prompt Engineering RAG - Optimiser vos prompts
• Évaluation RAG - Mesurer la qualité

Envie d'un système de citations clé en main ? Essayez Ailog - citations automatiques, interface cliquable, confiance utilisateur garantie.