Agentic RAG : Révolutionner la recherche avec l'IA itérative

Agentic RAG : Une nouvelle ère pour la recherche d'informations

Applications des modèles de langage de grande taille (LLM)

Agentic RAG propose une approche novatrice pour la récupération d'informations, en transformant le processus en une boucle continue de recherche, lecture et décision. Cette méthode repose sur une implémentation minimale du SDK OpenAI Agents, où l'accent est mis sur une interaction itérative avec les données.

L'application que nous développons est une application RAG (Récupération-Augmentation-Génération). La méthode semble simple : découper les données, les intégrer, les récupérer, puis formuler une réponse. Cependant, dans la pratique, les défis se multiplient rapidement. La recherche de similarité peut identifier des formulations proches sans pour autant fournir des informations pertinentes, et des éléments cruciaux peuvent être omis du contexte récupéré en raison d'un classement inadéquat ou d'une division inappropriée des morceaux de données.

Avec un contexte limité, les modèles de langage de grande taille (LLM) ont peu de marge pour compenser. Alors, pourquoi ne pas rendre la récupération itérative ? Et si le modèle pouvait non seulement chercher et lire, mais aussi décider s'il dispose de suffisamment de preuves avant de poursuivre sa recherche ? Cette approche pourrait même se passer d'intégrations vectorielles au départ. C'est là qu'intervient le concept d'Agentic RAG.

Dans cet article, nous allons explorer comment construire un flux de travail agentic RAG minimaliste avec le SDK OpenAI Agents. Nous verrons comment l'agent procède à la recherche, à la lecture et à l'ancrage de sa réponse de manière itérative. Enfin, nous prendrons du recul pour discuter des éléments à considérer pour développer une solution agentic RAG viable.

1. Étude de cas : Répondre à une question de politique avec Agentic RAG

Pour illustrer le potentiel de l'Agentic RAG, nous avons construit un agent spécialisé dans les politiques d'entreprise, capable d'interagir avec une collection de documents pertinents.

1.1 Curation de la collection de documents

Nous avons créé une série de six documents de politique d'entreprise synthétiques, chacun sous forme de fichier markdown. Chaque document comprend un titre, une date d'entrée en vigueur, un résumé et le texte complet de la politique.

Ces documents couvrent six domaines courants des politiques d'entreprise :

• approval_matrix.md : Détails des niveaux d'approbation pour les décisions de voyage d'affaires, en vigueur à partir du 1er juillet 2025.
• conference_guidelines.md : Règles pour assister à des événements externes, applicables dès le 15 mai 2025.
• faq.md : Réponses informelles aux questions fréquentes sur les voyages, valides à partir du 1er septembre 2025.
• policy_updates_2026.md : Mises à jour sur l'hébergement, les voyages de conférence et le calendrier d'approbation pour 2026, effectives dès le 1er janvier 2026.
• remote_work_policy.md : Règles pour le travail à distance, en vigueur dès le 1er février 2026.
• travel_policy.md : Règles standards pour la réservation de voyages, incluant vols, hébergement, repas et transport, applicables dès le 1er mars 2025.

La réponse à une question de politique peut nécessiter des informations provenant de plusieurs documents, ce qui permet d'observer le comportement agentique souhaité. Les documents synthétiques complets et le carnet de mise en œuvre de l'agentic RAG sont disponibles pour consultation.

1.2 Définition de l'agent

Pour configurer l'agent, nous avons utilisé le SDK OpenAI Agents. L'agent est défini de manière simple :

# pip install openai-agents
from agents import Agent
name="Assistant de recherche sur les politiques",
instructions=INSTRUCTIONS,
model="[gpt](/glossaire/gpt)-5.4",
tools=[list_docs, search_docs, read_doc],

Deux éléments clés doivent être précisés : l'instruction de l'agent et les outils à sa disposition.

L'instruction détermine le comportement de recherche souhaité :

# Note : Cette instruction est itérée avec l'IA
INSTRUCTIONS = """
Vous êtes un assistant de recherche sur les politiques internes attentif.
[Comportement de recherche]
Répondez aux questions des employés sur les politiques en utilisant les outils documentaires.
Trouvez suffisamment de preuves pertinentes pour soutenir la réponse.
Gardez les conclusions ancrées dans les documents de politique.
[Sortie attendue]
Donnez d'abord une réponse directe.
Puis expliquez brièvement les preuves.
Citez les noms de fichiers des documents utilisés pour chaque affirmation importante.
"""

Pour cette étude de cas, l'agent ne peut accéder aux documents qu'à travers trois outils prédéfinis :

• Un outil pour obtenir un aperçu rapide des documents disponibles :

def list_docs() -> list[dict]:
    """Liste des documents de politique disponibles sans retourner leur texte."""
    "doc_name": doc["doc_name"],
    "title": doc["title"],
    "effective": doc["effective"],
    "summary": doc["summary"],
    for doc in docs.values()

• Un outil de recherche par mots-clés, qui compare chaque requête avec des morceaux de paragraphes :

def search_docs(query: str) -> list[dict]:
    """Recherche dans les documents de politique et retourne les trois meilleurs extraits courts."""
    query_tokens = tokenize(query)
    for chunk in chunks:
        score = len(query_tokens & chunk["tokens"])
        scored.append((score, chunk))
    scored.sort(key=lambda item: item[0], reverse=True)
    for score, chunk in scored[:3]:
        snippet = chunk["text"].replace("\n", " ")
        if len(snippet) > 420:
            snippet = snippet[:417].rstrip() + "..."
        results.append({
            "doc_name": chunk["doc_name"],
            "title": chunk["title"],
            "section": chunk["section"],
            "snippet": snippet,
            "score": round(score, 2),

• Un outil pour ouvrir un document par son nom de fichier :

def read_doc(doc_name: str) -> str:
    """Lit un document de politique par nom de fichier."""
    if doc_name not in docs:
        valid = ", ".join(sorted(docs))
        return f"Document inconnu : {doc_name}. Documents valides : {valid}"
    return docs[doc_name]["text"]

C'est ainsi que se construit l'agent RAG complet.

1.3 Exécution d'une question de politique

Nous avons testé l'agent avec une question concrète :

« Je participe à une conférence à Berlin. L'organisateur de la conférence liste un hôtel officiel, mais le tarif nocturne est supérieur au plafond normal des hôtels. Puis-je réserver cet hôtel, et quelle approbation dois-je obtenir avant de réserver ? »

L'agent a été exécuté avec :

from agents import Runner
result = await Runner.run(agent, PROMPT, max_turns=12)

L'agent a fourni la réponse correcte : l'employé peut réserver l'hôtel officiel de la conférence s'il y a une raison commerciale valable. Cette information a été extraite de conference_guidelines.md.

Concernant l'approbation, l'agent a d'abord identifié qu'une approbation était nécessaire en raison du tarif supérieur au plafond normal, puis a précisé les conditions d'approbation requises. L'agent a utilisé travel_policy.md, approval_matrix.md, et policy_updates_2026.md pour étayer sa réponse, ce qui correspondait parfaitement à nos attentes.

La partie la plus fascinante réside dans la trace, qui révèle le processus de réflexion de l'agent. Pour visualiser cette trace :

for item in result.new_items:
    print(type(item).__name__, item)

result.new_items contient les appels d'outils intermédiaires et les sorties générées par l'agent. Dans notre exécution, l'agent a d'abord utilisé search_docs() avec des mots-clés tels que « hôtel de conférence », « plafond de l'hôtel », « approbation » et « Berlin ». Ensuite, il a consulté list_docs() pour examiner les documents disponibles, avant d'ouvrir les fichiers pertinents avec read_doc(). Ce n'est qu'après avoir rassemblé ces informations qu'il a formulé sa réponse finale.

C'est précisément la boucle agentique que nous cherchions à observer.

3. Considérations avant de construire un Agentic RAG

L'étude de cas que nous venons d'explorer n'est qu'une introduction. Pour développer une solution agentic RAG efficace, il est crucial de répondre aux 5 questions suivantes :

• Q1 : Quelle liberté l'agent devrait-il avoir ? Une approche courante consiste à exposer quelques outils soigneusement sélectionnés, comme dans notre étude de cas, où l'agent est limité à ces outils pour mener ses recherches. Cela simplifie le contrôle, les tests et l'audit.

  Cependant, il est également possible de donner à l'agent un accès plus large, incluant un shell et un système de fichiers. Ainsi, l'agent peut exécuter des scripts pour rechercher et analyser des fichiers, voire effectuer un traitement de données supplémentaire de manière autonome.

  Ce modèle offre plus de puissance, mais augmente également les risques et rend le comportement de l'agent moins prévisible.

  Pour la plupart des applications RAG, il est conseillé de commencer par des outils sélectionnés, puis d'envisager un accès plus large uniquement si la complexité de la tâche le justifie.

• Q2 : L'agent doit-il rechercher uniquement du texte brut ? La plupart des projets RAG débutent avec du texte brut, tel que des PDF, des pages wiki ou des manuels. C'est une bonne base.

  Toutefois, en pratique, il est souvent utile de dériver une couche de connaissance au-dessus des textes bruts. Ces artefacts de connaissance peuvent inclure des métadonnées, des résumés, des liens inter-documents, ou même un graphe de connaissance complet.

  Ces artefacts aident l'agent à naviguer dans le corpus, tandis que les textes bruts restent la source de vérité.

• Q3 : Avons-nous encore besoin d'intégrations ? L'agentic RAG ne signifie pas nécessairement l'abandon des intégrations.

  Les intégrations vectorielles restent un moyen efficace de trouver des textes sémantiquement pertinents, souvent plus performant qu'une simple recherche par mots-clés. Dans l'agentic RAG, la récupération devient une "action" que l'agent peut entreprendre. Cette "action" peut être alimentée par un récupérateur basé sur des intégrations, des mots-clés, ou un hybride des deux.

  Les intégrations peuvent donc toujours être utiles, servant de support à l'outil de recherche de l'agent.

• Q4 : Un agent doit-il tout gérer ? La configuration agentic RAG la plus simple implique un agent unique qui effectue la recherche, la lecture et la réponse.

  Cependant, à mesure que la tâche se complexifie, il peut être judicieux de diviser le travail entre plusieurs agents, adoptant ainsi une stratégie multi-agents.

  Vous pouvez répartir le travail par rôle, par exemple en séparant les fonctions de planification, de récupération et de rédaction. Chaque agent se concentre alors sur une tâche spécifique, optimisant ainsi le processus global.

  Vous pouvez également diviser par type de source, chaque agent étant équipé d'outils personnalisés pour se concentrer sur un type de source particulier.

  Gardez à l'esprit que la configuration multi-agents ajoute de la complexité de coordination, sans garantie de performance supérieure par rapport à une configuration à agent unique. Les tests empiriques sont essentiels.

• Q5 : Devons-nous toujours utiliser l'agentic RAG ? Pas nécessairement.

  Le fait que l'agentic RAG soit en vogue ne signifie pas qu'il doit être adopté par défaut.

  Bien que l'agentic RAG offre plus de flexibilité, cela a un coût, notamment en termes de latence, de coût des tokens, et de comportement d'agent moins prévisible.

  Il est sage de commencer par des solutions simples, puis d'ajouter des boucles agentiques uniquement lorsque la question nécessite réellement une récupération itérative.