Un LLM comme arbitre dans la récupération RAG : choisir le bon candidat avec des raisons

Un LLM comme Arbitre dans la Récupération RAG : Choisir le Bon Candidat avec des Justifications

La génération augmentée par récupération (RAG) est devenue un pilier des applications modernes d'IA, permettant aux grands modèles de langage (LLM) d'ancrer leurs réponses dans des connaissances externes. Cependant, un défi persiste : même avec une récupération de haute qualité, plusieurs documents candidats peuvent être retournés, et ils ne sont pas tous également pertinents. Les méthodes de classement traditionnelles comme la similarité cosinus ou BM25 échouent souvent à capturer la pertinence nuancée — comme le contexte temporel, l'alignement d'intention ou le raisonnement spécifique à un domaine.

Voici l'approche **LLM comme arbitre** : au lieu de se fier uniquement à la similarité d'embedding, nous utilisons un appel LLM secondaire pour évaluer et classer les candidats récupérés avec un raisonnement explicite. Cette technique, explorée dans des discussions industrielles récentes (par exemple, sur *Towards Data Science*), offre une étape de récupération plus intelligente et contextuelle. Dans cet article, nous allons parcourir une implémentation pratique, de l'installation à l'utilisation, en montrant comment construire un pipeline RAG où un LLM juge les documents candidats et fournit des justifications pour ses choix.

Pourquoi Utiliser un LLM comme Arbitre ?

Le classement traditionnel de la récupération a des limites :

• **La similarité sémantique** peut manquer des indices pragmatiques ou contextuels (par exemple, un document de 2022 vs 2024 sur le même sujet).
• **Les méthodes basées sur des mots-clés** échouent lorsque les requêtes sont abstraites ou nécessitent un raisonnement multi-étapes.
• **Aucune explication** n'est fournie pour justifier pourquoi un document est préféré à un autre.

Utiliser un LLM comme arbitre répond à ces problèmes :

• Le LLM peut raisonner sur la **pertinence temporelle**, l'**autorité** et l'**alignement d'intention**.
• Il produit des **justifications lisibles par l'humain** pour le score de chaque candidat, permettant le débogage et la confiance.
• Il peut traiter des **requêtes complexes** (par exemple, "Trouvez la mise à jour politique la plus récente sur la sécurité de l'IA qui ne provient pas d'un blog de fournisseur").

Cette approche est complémentaire à la recherche vectorielle : vous récupérez toujours les K meilleurs candidats via la similarité d'embedding, puis vous affinez avec le raisonnement du LLM. L'essentiel est que le LLM ne régénère pas — il *juge*.

Prérequis

Pour suivre ce tutoriel, vous aurez besoin de :

• **Python 3.10+** installé sur votre système.
• **Clé API OpenAI** (ou un autre fournisseur de LLM) avec accès à GPT-4 ou GPT-4o-mini (pour un bon rapport coût-efficacité). Alternativement, vous pouvez utiliser un modèle local via Ollama (par exemple, `llama3` ou `mistral`).
• **Familiarité de base** avec Python, les environnements virtuels et les outils en ligne de commande.
• **Au moins 4 Go de RAM** si vous utilisez un LLM local ; l'API cloud nécessite une connexion Internet.
• **pip** (gestionnaire de paquets Python).

Nous utiliserons les bibliothèques Python suivantes :

• `langchain` et `langchain-community` pour l'orchestration RAG.
• `chromadb` pour le stockage vectoriel.
• `openai` (ou `ollama`) pour les appels LLM.
• `pandas` pour la manipulation des données.

Installation Pas à Pas

1. Créer un Environnement Virtuel Python

Créez d'abord un environnement isolé pour éviter les conflits de dépendances.

python3 -m venv rag-arbitre
source rag-arbitre/bin/activate   # Sur Windows : rag-arbitre\Scripts\activate

2. Installer les Paquets Requis

Installez les bibliothèques principales. Nous utiliserons `langchain` pour son interface modulaire de récupération et de LLM.

pip install langchain langchain-community chromadb openai pandas tiktoken

Si vous prévoyez d'utiliser un modèle local via Ollama :

pip install langchain-ollama

3. Configurer les Clés API (Si Vous Utilisez OpenAI)

Exportez votre clé API OpenAI comme variable d'environnement (remplacez `votre-clé-ici` par votre clé réelle).

export OPENAI_API_KEY="votre-clé-ici"

Sur Windows (PowerShell) :

$env:OPENAI_API_KEY="votre-clé-ici"

4. (Optionnel) Installer et Démarrer Ollama pour les Modèles Locaux

Si vous préférez l'inférence locale, installez Ollama depuis [ollama.ai](https://ollama.ai) et téléchargez un modèle.

# Après avoir installé Ollama
ollama pull llama3.1

Construction du Pipeline d'Arbitrage

Notre pipeline se compose de trois étapes : 1. **Ingérer les documents** dans un stockage vectoriel. 2. **Récupérer les K meilleurs candidats** en utilisant la similarité d'embedding. 3. **L'arbitre LLM** note chaque candidat avec des justifications, puis réorganise le classement.

Étape 1 : Ingérer des Documents Exemples

Créez un script Python `ingestion.py` pour charger un petit corpus. Nous utiliserons des documents fictifs sur les politiques d'IA.

# ingestion.py
import pandas as pd
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.schema import Document

# Documents exemples (en pratique, chargez depuis des fichiers)
documents = [
    Document(page_content="En 2024, la loi européenne sur l'IA a été finalisée, exigeant de la transparence pour les systèmes à haut risque.", metadata={"source": "eu_ia_loi.txt", "date": "2024-06-01"}),
    Document(page_content="Google a publié de nouvelles directives pour le développement responsable de l'IA en 2023, axées sur l'équité.", metadata={"source": "google_ia_blog.txt", "date": "2023-03-15"}),
    Document(page_content="La norme d'IA responsable de Microsoft (2022) décrit des principes pour la supervision humaine.", metadata={"source": "microsoft_ia_blog.txt", "date": "2022-11-01"}),
    Document(page_content="OpenAI a annoncé GPT-4o-mini en 2024, un modèle économique pour les développeurs.", metadata={"source": "openai_actualites.txt", "date": "2024-07-01"}),
    Document(page_content="Le décret exécutif américain de 2023 sur la sécurité de l'IA impose des rapports pour les grands modèles.", metadata={"source": "decret_us.txt", "date": "2023-10-30"}),
]

# Initialiser les embeddings (OpenAI)
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Créer le stockage vectoriel
vectorstore = Chroma.from_documents(
    documents,
    embeddings,
    persist_directory="./chroma_db"
)
print("Documents ingérés avec succès.")

Exécutez le script :

python ingestion.py

Étape 2 : Récupérer les Candidats

Créez maintenant une fonction de récupération qui obtient les K meilleurs candidats.

# recuperation.py
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

def recuperer_candidats(requete: str, k: int = 5):
    """Retourne les k meilleurs documents avec métadonnées."""
    resultats = vectorstore.similarity_search_with_score(requete, k=k)
    # Formater pour l'arbitre
    candidats = []
    for doc, score in resultats:
        candidats.append({
            "contenu": doc.page_content,
            "metadonnees": doc.metadata,
            "score_similarite": round(score, 4)
        })
    return candidats

Étape 3 : Fonction d'Arbitrage LLM

Le cœur de notre approche : le LLM évalue chaque candidat et retourne un score (1-10) avec une justification.

# arbitre.py
from langchain_openai import ChatOpenAI

# Initialiser le LLM (utilisez GPT-4o-mini pour un bon rapport coût-efficacité)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

def score_arbitre(requete: str, candidat: dict) -> dict:
    """Demander au LLM de noter un seul document candidat."""
    prompt = f"""Vous êtes un arbitre de récupération. Évaluez la pertinence du document suivant par rapport à la requête de l'utilisateur.
Requête : {requete}
Document : {candidat['contenu']}
Métadonnées (source, date) : {candidat['metadonnees']}

Fournissez une réponse JSON avec :
- "score" : entier de 1 à 10 (10 = parfaitement pertinent)
- "raison" : explication concise (maximum 2 phrases)

Réponse :"""
    
    reponse = llm.invoke(prompt)
    # Analyser la réponse (simplifié : suppose un JSON valide)
    import json
    try:
        resultat = json.loads(reponse.content)
    except:
        resultat = {"score": 5, "raison": "Erreur d'analyse"}
    return resultat

Étape 4 : Pipeline Complet avec Réorganisation

Combinez la récupération et l'arbitrage en une seule fonction.

# pipeline.py
from recuperation import recuperer_candidats
from arbitre import score_arbitre

def rag_avec_arbitre(requete: str, k: int = 5):
    """Récupérer, arbitrer et réorganiser les candidats."""
    # Étape 1 : Récupération
    candidats = recuperer_candidats(requete, k=k)
    
    # Étape 2 : Arbitrer chaque candidat
    candidats_notes = []
    for cand in candidats:
        resultat_arbitre = score_arbitre(requete, cand)
        cand["score_llm"] = resultat_arbitre["score"]
        cand["raison"] = resultat_arbitre["raison"]
        candidats_notes.append(cand)
    
    # Étape 3 : Réorganiser par score LLM (décroissant)
    candidats_notes.sort(key=lambda x: x["score_llm"], reverse=True)
    
    return candidats_notes

Exemples d'Utilisation

Exemple 1 : Requête Simple

Exécutez une requête pour voir l'arbitre en action.

# exemple1.py
from pipeline import rag_avec_arbitre

requete = "Quelles sont les dernières réglementations sur l'IA en 2024 ?"
resultats = rag_avec_arbitre(requete, k=3)

for i, r in enumerate(resultats, 1):
    print(f"Rang {i} : Score {r['score_llm']}/10")
    print(f"  Document : {r['contenu'][:80]}...")
    print(f"  Raison : {r['raison']}")
    print(f"  Source : {r['metadonnees']['source']}")
    print()

**Sortie attendue (exemple) :**

Rang 1 : Score 9/10
  Document : En 2024, la loi européenne sur l'IA a été finalisée...
  Raison : Mentionne directement les réglementations de 2024 ; très pertinent.
  Source : eu_ia_loi.txt

Rang 2 : Score 7/10
  Document : Le décret exécutif américain de 2023 sur la sécurité de l'IA...
  Raison : Pertinent mais date de 2023, pas explicitement 2024.
  Source : decret_us.txt

Rang 3 : Score 4/10
  Document : Google a publié de nouvelles directives pour...
  Raison : Se concentre sur l'équité, pas sur les réglementations ; plus ancien.
  Source : google_ia_blog.txt

Exemple 2 : Requête Complexe avec Raisonnement Temporel

# exemple2.py
from pipeline import rag_avec_arbitre

requete = "Trouvez l'annonce la plus récente d'un modèle économique d'OpenAI"
resultats = rag_avec_arbitre(requete, k=5)

for r in resultats:
    print(f"Score : {r['score_llm']} | {r['metadonnees']['source']} | Raison : {r['raison']}")

**Sortie attendue :**

Score : 10 | openai_actualites.txt | Correspond directement : GPT-4o-mini est un modèle économique de 2024 d'OpenAI.
Score : 3 | eu_ia_loi.txt | Ne parle pas d'OpenAI ou d'annonces de modèles.
Score : 2 | microsoft_ia_blog.txt | Non pertinent : Microsoft, pas OpenAI.
...

Exemple 3 : Débogage avec les Justifications

Les justifications vous permettent de comprendre *pourquoi* un document a été mal classé.

# debug.py
resultats = rag_avec_arbitre("Directives de sécurité de l'IA du gouvernement américain", k=4)
for r in resultats:
    if r["score_llm"] < 5:
        print(f"Faible score pour {r['metadonnees']['source']} : {r['raison']}")

**Sortie :**

Faible score pour openai_actualites.txt : Parle d'un modèle, pas de directives de sécurité ou de gouvernement.
Faible score pour eu_ia_loi.txt : Réglementation européenne, pas du gouvernement américain.

Configuration Avancée

Utilisation de Modèles Locaux (Ollama)

Remplacez OpenAI par un LLM local pour des raisons de confidentialité ou de coût.

# arbitre_ollama.py
from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1", temperature=0)

# Même fonction score_arbitre qu'avant, en utilisant ce llm

Notation par Lots pour l'Efficacité

Pour de nombreux candidats, le traitement par lots réduit la latence.

# arbitre_lot.py
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

prompt = ChatPromptTemplate.from_template(
    "Étant donné la requête : {requete}\nNotez chaque document (1-10) avec une raison.\nDocuments :\n{docs}"
)

def arbitre_lot(requete: str, candidats: list):
    texte_docs = "\n---\n".join([f"Doc {i+1} : {c['contenu']}" for i, c in enumerate(candidats)])
    reponse = llm.invoke(prompt.format(requete=requete, docs=texte_docs))
    # Analyser la sortie structurée (l'implémentation dépend de la conception de votre prompt)
    return reponse.content

Conclusion

Utiliser un LLM comme arbitre dans la récupération RAG transforme une simple étape de classement en un processus conscient du raisonnement. En demandant au LLM d'évaluer les candidats avec des justifications explicites, vous obtenez :

• **Une pertinence accrue** : Le LLM capture les nuances comme le contexte temporel et l'intention.
• **De la transparence** : Chaque classement est accompagné d'une explication lisible par l'humain.
• **De la flexibilité** : Vous pouvez adapter le prompt de l'arbitre à des critères spécifiques au domaine (par exemple, "préférer les sources évaluées par les pairs").

Le compromis est une latence et un coût accrus — chaque requête entraîne un appel LLM supplémentaire. Cependant, pour les applications où la qualité de la récupération est critique (par exemple, la recherche juridique, les questions-réponses médicales ou les bases de connaissances d'entreprise), l'avantage l'emporte sur la surcharge.

Pour commencer, clonez les extraits de code ci-dessus et expérimentez avec vos propres documents. Alors que les LLM continuent de s'améliorer (comme le montrent les récentes annonces d'OpenAI, Google et Microsoft), l'approche de l'arbitre deviendra encore plus puissante — et plus essentielle pour construire des systèmes d'IA fiables et contextuels.