Agentic RAG : laissez l’agent rechercher

L’application que nous construisons est une application RAG.

La recette est simple : fragmenter, intégrer, récupérer, puis répondre.

Cela semble propre sur le papier. Mais une fois que vous l’utilisez sur des cas réels, les choses se gâtent très rapidement : la recherche de similarité trouve des formulations similaires mais pas nécessairement des fragments utiles, la bonne preuve n’apparaît jamais dans le contexte récupéré car elle est trop basse, ou un contexte important peut être divisé entre les limites des fragments.

Avec un contexte insuffisant, le LLM a peu de marge de reprise.

Alors, que diriez-vous de faire une récupération itératif? Et si le modèle pouvait rechercher, lire, décider s’il dispose de suffisamment de preuves et effectuer une nouvelle recherche si nécessaire ? Nous n’avons probablement même pas besoin des intégrations vectorielles en premier lieu.

C’est la prémisse de RAG agentique.

Dans cet article, nous allons créer un mini workflow RAG agentique avec le SDK OpenAI Agents. Nous examinerons comment l’agent recherche, lit et fonde sa réponse de manière itérative.

À la fin, nous prendrons du recul et discuterons brièvement des considérations à prendre en compte pour créer une solution RAG agentique pratique.

---

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

Pour notre étude de cas, nous allons créer un agent RAG de politique sur une collection de documents de politique d’entreprise.

1.1 Organiser la collection de documents

Ici, j’ai créé six documents synthétiques sur la politique de l’entreprise. Ce sont tous des fichiers de démarque. Chacun a un titre, une date d’entrée en vigueur, un bref résumé et le texte de la politique.

Pour être réaliste, ces documents couvrent 6 domaines politiques communs à l’entreprise :

1. approval_matrix.mdcontenant les niveaux d’approbation pour les décisions courantes en matière de voyages d’affaires, à compter du 1er juillet 2025.
2. conference_guidelines.mdcontenant les règles de participation à des événements externes, en vigueur le 15 mai 2025.
3. faq.mdcontenant des réponses informelles aux questions courantes sur les voyages, à compter du 1er septembre 2025.
4. policy_updates_2026.mdcontenant des mises à jour sur l’hébergement, les déplacements pour les conférences et le calendrier d’approbation pour 2026, à compter du 1er janvier 2026.
5. remote_work_policy.mdcontenant des règles pour le travail à distance, en vigueur le 1er février 2026.
6. travel_policy.mdcontenant les règles standard de réservation de voyages pour les vols, l’hébergement, les repas et le transport, en vigueur le 1er mars 2025.

Nous avons fait intentionnellement en sorte que la réponse à une question politique ne puisse pas figurer dans un seul document. Cela nous permet de voir le comportement agent souhaité.

Vous pouvez retrouver les documents synthétiques complets et le notebook d’implémentation agentic RAG ici.

1.2 Définir l’agent

Ensuite, nous configurons l’agent. Pour cela, nous utilisons le SDK OpenAI Agents.

À un niveau élevé, l’agent est simplement ceci :

# pip install openai-agents
from agents import Agent

agent = Agent(
    name="Policy research assistant",
    instructions=INSTRUCTIONS,
    model="gpt-5.4",
    tools=[list_docs, search_docs, read_doc],
)

Nous devons parcourir deux parties : l’instruction de l’agent et les outils auxquels il a accès.

Tout d’abord, les instructions. C’est ici que nous définissons le comportement de recherche souhaité :

# Note: This instruction is iterated with AI
INSTRUCTIONS = """
[Role]
You are a careful internal policy research assistant.

[Research behavior]
Answer employee policy questions using the document tools.
Find enough relevant evidence to support the answer.
Keep conclusions grounded in the policy documents.

[Expected output]
Give a direct answer first.
Then briefly explain the evidence.
Cite the document filenames used for each important claim.
""".strip()

Pour cette étude de cas, nous exigeons que l’agent puisse toucher les documents uniquement via trois outils prédéfinis :

Le premier est un outil qui donne à l’agent un aperçu rapide des documents existants :

@function_tool
def list_docs() -> list[dict]:
    """List available policy documents without returning their body text."""
    return [
        {
            "doc_name": doc["doc_name"],
            "title": doc["title"],
            "effective": doc["effective"],
            "summary": doc["summary"],
        }
        for doc in docs.values()
    ]

Le deuxième outil est un outil de recherche par mots clés. Nous gardons les choses simples ici : chaque document est divisé en morceaux de paragraphe, et chaque requête est comparée à ces morceaux par chevauchement de jetons :

@function_tool
def search_docs(query: str) -> list[dict]:
    """Search policy documents and return the top three short snippets."""
    query_tokens = tokenize(query)
    scored = []

    for chunk in chunks:
        score = len(query_tokens & chunk["tokens"])
        if score:
            scored.append((score, chunk))

    scored.sort(key=lambda item: item[0], reverse=True)

    results = []
    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),
        })

    return results

Le dernier outil permet à l’agent d’ouvrir un document par nom de fichier :

@function_tool
def read_doc(doc_name: str) -> str:
    """Read one policy document by filename."""
    if doc_name not in docs:
        valid = ", ".join(sorted(docs))
        return f"Unknown document: {doc_name}. Valid documents: {valid}"

    return docs[doc_name]["text"]

C’est l’agent RAG complet.

1.3 Exécuter une question de politique

Nous testons maintenant l’agent avec une question concrète :

« Je participe à une conférence à Berlin. L’organisateur de la conférence répertorie un hôtel officiel, mais le tarif par nuit est supérieur au plafond hôtelier normal. Puis-je réserver cet hôtel et de quelle approbation ai-je besoin avant de réserver ? »« 

Nous exécutons l’agent avec :

from agents import Runner

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

L’agent a donné la bonne réponse : oui, l’employé peut réserver l’hôtel officiel de la conférence s’il y a une raison professionnelle pratique. Il a obtenu cette information de conference_guidelines.md.

Pour la partie approbation, l’agent a d’abord identifié qu’une approbation était nécessaire car l’hôtel se situe au-dessus du plafond normal. Ensuite, il a donné les conditions d’approbation correspondantes. L’agent utilisé travel_policy.md, approval_matrix.mdet policy_updates_2026.md pour étayer sa réponse, ce qui est exactement ce à quoi nous nous attendrions.

La partie la plus intéressante est la trace, à partir de laquelle nous pouvons apprendre comment pense l’agent. Nous pouvons montrer la trace de la manière suivante :

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

result.new_items contient les appels d’outils intermédiaires et les sorties d’outils produites par l’agent. Dans ma course, je peux voir que l’agent a d’abord appelé search_docs() avec des mots-clés comme hôtel de conférence, plafond d’hôtel, approbation et Berlin. Ensuite, il a appelé list_docs() pour inspecter les documents de politique disponibles. Après cela, il a ouvert les fichiers concernés avec read_doc(). Ce n’est qu’à ce moment-là que la réponse définitive a été apportée.

C’est exactement la boucle agentique que nous voulions voir.

---

3. Que décider avant de créer un RAG agentique

L’étude de cas que nous venons de parcourir n’a fait qu’effleurer la surface. Pour réellement construire une solution RAG agentique pratique, basée sur mon expérience, je vous propose de répondre aux 5 questions suivantes :

Q1 : De quelle liberté l’agent doit-il disposer ?

Une option courante est exactement ce que nous avons fait dans l’étude de cas précédente : nous avons exposé quelques outils soigneusement sélectionnés, et l’agent n’est autorisé à utiliser ces outils que pour mener l’enquête. C’est simple en termes de contrôle, de tests et d’audit.

Mais nous pouvons également donner à l’agent un accès plus large, comme le shell et le système de fichiers. De cette façon, l’agent peut exécuter directement des scripts pour rechercher et inspecter des fichiers, et peut-être même effectuer un traitement ultérieur des données pour générer des artefacts utiles, tout seul.

Ce modèle peut être beaucoup plus puissant, mais il augmente également le risque et rend le comportement plus difficile à prévoir.

Ainsi, pour la plupart des applications RAG, je commencerais par des outils sélectionnés et n’ajouterais un accès au shell/au système de fichiers que lorsque la complexité de la tâche le justifie.

Q2 : L’agent doit-il rechercher uniquement du texte brut ?

La plupart des projets RAG peuvent commencer avec du texte brut comme des PDF, des pages wiki, des manuels, etc.

Mais en pratique, nous pouvons souvent faciliter la récupération en dérivant un couche de connaissances au-dessus des textes bruts.

Ces artefacts de connaissances dérivés peuvent être des métadonnées de documents, des résumés, des liens entre documents, ou nous pouvons aller plus loin et mettre en œuvre un graphe de connaissances approprié.

Ces artefacts de connaissances dérivés 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 ?

Agentic RAG ne signifie pas nécessairement que les intégrations ont disparu.

Les intégrations vectorielles restent un moyen efficace de trouver des textes sémantiquement pertinents, et elles surpassent souvent une pure stratégie de recherche par mots clés.

Dans RAG agentique, ce qui a essentiellement changé, c’est que la récupération devient une « action » que l’agent peut entreprendre. Dans ce cadre, « l’action » peut toujours être alimentée par un outil de récupération basé sur l’intégration, un outil basé sur des mots clés, ou même un outil hybride.

Les intégrations peuvent donc toujours être utiles. Ils ne constituent qu’un moyen possible d’alimenter l’outil de recherche de l’agent.

Q4 : Un seul agent devrait-il tout gérer ?

La configuration RAG agentique la plus simple consiste en un seul agent qui effectue la recherche, la lecture et la réponse.

Mais à mesure que la tâche devient plus complexe, vous souhaiterez peut-être répartir le travail entre plusieurs agents. Plus concrètement, vous devrez peut-être adopter une stratégie multi-agents.

Vous pouvez diviser le travail par rôle. Par exemple, le planificateur-récupérateur-écrivain divisé, où le planificateur décide quelles preuves sont nécessaires, le récupérateur les collecte et l’écrivain produit la réponse finale en utilisant les preuves collectées.

Vous pouvez également diviser par type de sourceoù chaque agent est équipé d’outils personnalisés et se concentre sur un type de source spécifique.

Gardez simplement à l’esprit : une configuration multi-agent ajoute de la complexité à la coordination et rien ne garantit qu’elle fonctionnera mieux qu’une configuration à agent unique. Les tests empiriques sont très importants.

Q5 : Devons-nous toujours utiliser du RAG agent ?

Peut-être pas toujours.

Ce n’est pas parce que le RAG agentique devient un sujet à la mode que vous devez toujours l’utiliser par défaut.

Agentic RAG offre plus de flexibilité, mais cela a un coût. Ce coût ne concerne pas seulement la latence ou le coût des jetons, mais également le comportement moins prévisible des agents.

Commencez toujours simplement, puis ajoutez des boucles agentiques lorsque la question nécessite réellement une récupération itérative.