Agentic RAG : Au-delà des simples chatbots
Le mot à la mode « agent IA » est partout. Mais qu’est-ce que cela signifie réellement et pourquoi devriez-vous vous en soucier ?
Les chatbots simples utilisant le RAG (Retrieval-Augmented Generation) de base sont limités : ils répondent à des questions statiques à partir d’une base de connaissances fixe. Ils ne peuvent pas raisonner à partir de plusieurs sources, planifier une séquence d'actions ou se corriger lorsque quelque chose ne va pas.
Agentic RAG change cela. Il donne aux LLM la capacité de penser, planifier, récupérer, agir et s'auto-corriger, ce qui les rend capables de gérer des flux de travail complexes en plusieurs étapes qui vont bien au-delà des robots FAQ.
Cet article est votre guide pratique pour créer des agents IA qui fonctionnent réellement en production.
Table of Contents
- Pourquoi Simple RAG échoue
- L'architecture agentique RAG
- Éléments de base : cadres et outils
- Un exemple complet : agent de support client
- Modèles avancés
- Liste de contrôle de préparation à la production
- Quand NE PAS utiliser d'agents
- Le résultat
- Points clés à retenir
- Besoin d'aide pour créer des agents
Pourquoi Simple RAG échoue
!Agentic RAG system architecture: retrieval, reasoning, action, and memory components
Le RAG de base fonctionne comme ceci :
- L'utilisateur pose une question
- Le système récupère les documents pertinents à partir d'une base de données vectorielle
- LLM génère une réponse basée sur ces documents
- Retourner la réponse
C'est idéal pour les FAQ, mais fragile pour tout ce qui nécessite :
- Raisonnement en plusieurs étapes : "Quel est le meilleur fournisseur de cloud pour une application de streaming vidéo qui nécessite également une formation en ML et en conformité avec le RGPD ?" nécessite de comparer AWS, GCP et Azure sur trois dimensions.
- Utilisation de l'outil : "Réservez-moi le vol aller-retour le moins cher vers Tokyo la semaine prochaine, qui arrive avant 10h00 et dispose d'un siège côté hublot." nécessite une recherche de vol, une comparaison de prix, une sélection de siège.
- Mémoire et état : « Sur la base de mes commandes précédentes, quel produit dois-je envisager ensuite ? » a besoin d’accéder à l’historique des commandes.
- Récupération d'erreur : si une recherche sur le Web échoue ou renvoie des erreurs, un simple système RAG abandonne tout simplement. Un agent peut réessayer avec une requête différente ou revenir à un résultat mis en cache.
L'architecture agentique RAG
Un système agentique ajoute trois couches au RAG de base :
Voici un flux d'agent typique :
Utilisateur : « Quel temps fera-t-il à Tokyo la semaine prochaine et dois-je emporter un parapluie ? »
Agent (Planificateur) :
Étape 1 : Obtenez les prévisions météo pour Tokyo
Étape 2 : En fonction des prévisions, déterminez si un parapluie est nécessaire
Agent (exécuteur étape 1) :
- Recherche sur le Web : "Prévisions météo de Tokyo la semaine prochaine"
- Analyser les résultats, extraire les températures et les précipitations
Agent (exécuteur étape 2) :
- Si précipitations > 30% → "Oui, emportez parapluie"
- Sinon → "Pas besoin de parapluie"
Agent (critique) :
- Vérifiez : avons-nous obtenu les bonnes dates ? (la semaine prochaine = 7 jours à partir d'aujourd'hui ?)
- Vérifiez : avons-nous analysé les nombres correctement ? (seuil de 30% arbitraire ?)
- En cas de doute, demandez à l'utilisateur : "Voulez-vous des prévisions détaillées au jour le jour ?"
Réponse finale : « Tokyo sera généralement ensoleillée avec 20 % de chances de pluie. Aucun parapluie n'est nécessaire. »Éléments de base : cadres et outils
Vous n'êtes pas obligé de construire cela à partir de zéro. Plusieurs frameworks open source prennent en charge les workflows agents :
1. LangGraph (par LangChain)
LangGraph vous permet de définir des graphiques cycliques où les nœuds sont des appels ou des outils LLM. Parfait pour les agents qui doivent boucler jusqu'à ce qu'une condition soit remplie.
à partir de langgraph.graph importer StateGraph, FIN
à partir de langchain_core.messages importer HumanMessage
classe AgentState (TypedDict) :
messages : liste [HumanMessage]
suivant: str
def retrieve_node (état : AgentState) :
requête = état['messages'][-1].content
docs = vector_db.search (requête)
return {"messages": [SystemMessage(content=f"Context: {docs}")]}
def Reasoning_node (état : AgentState) :
réponse = llm.invoke(state['messages'])
return {"messages": [réponse]}
def devrait_continue (état : AgentState) -> str :
dernier = état['messages'][-1].content
si "J'ai besoin de plus d'informations" en dernier :
retourner "récupérer"
sinon :
retourner "fin"
flux de travail = StateGraph (AgentState)
workflow.add_node("récupérer", récupérer_node)
workflow.add_node("raison", raisonnement_node)
workflow.add_conditional_edges("reason", Should_continue, {"retrieve": "retrieve", "end": END})
workflow.set_entry_point("récupérer")
agent = workflow.compile()LangGraph gère la persistance de l'état, les points de contrôle et l'interruption humaine dans la boucle.
2. LlamaIndex + AgentWorkflow
La classe AgentWorkflow de LlamaIndex facilite la collaboration multi-agent :
à partir de llama_index.core.agent.workflow importer AgentWorkflow
à partir de llama_index.core.tools importer FunctionTool
def search_knowledge_base (requête : str) -> str :
"""Recherchez dans la base de connaissances interne."""
retourner vector_db.query(requête)
def search_web (requête : str) -> str :
"""Recherchez des informations actuelles sur le Web."""
retourner web_search (requête)
def exécuter_sql(requête : str) -> str :
"""Exécutez des requêtes SQL sur la base de données analytique."""
retourner sql_db.execute (requête)
workflow = AgentWorkflow.from_tools_or_functions(
[search_knowledge_base, search_web,execute_sql],
llm=OpenAI(model="gpt-4-turbo"),
system_prompt="Vous êtes un assistant utile qui peut effectuer des recherches dans des bases de données de connaissances, Web et analytiques."
)
réponse = wait workflow.run(user_msg="Quelles ont été nos ventes au premier trimestre en Europe et comment cela se compare-t-il aux tendances du secteur ?")L'agent décide automatiquement quel(s) outil(s) utiliser et dans quel ordre.
3. Personnalisé avec des contours
Pour un contrôle total, utilisez « Outlines » pour forcer la sortie structurée (schéma JSON, regex) à partir du LLM, puis acheminez vers les outils basés sur la réponse structurée.
importer des contours
à partir de l'importation pydantic BaseModel, Field
classe ToolCall (BaseModel) :
outil : str = Field(description="Nom de l'outil à appeler")
arguments : dict = Field(description="Arguments pour l'outil")
model = outlines.models.transformers("meta-llama/Llama-3-70b-chat-hf")
invite = f"""
Utilisateur : {user_query}
Outils disponibles : search_web, query_db, send_email
Décidez quel outil utiliser et avec quels arguments. Sortie JSON.
"""
résultat = outlines.generate.json (invite, schéma = ToolCall, model = modèle)
## résultat : {"tool": "search_web", "arguments": {"query": "foo"}}Un exemple complet : agent de support client
Créons un agent capable de :
- Rechercher l'historique des commandes
- Vérifiez l'inventaire
- Trouver les politiques pertinentes
- Générez une réponse utile (ou faites remonter)
à partir de llama_index.core.agent.workflow importer AgentWorkflow
à partir de llama_index.core.tools importer FunctionTool
depuis llama_index.llms.openai importer OpenAI
def get_order_history(user_id : str) -> dict :
"""Récupérer l'historique des commandes de l'utilisateur à partir de la base de données."""
query = f"SELECT * FROM commandes WHERE user_id = '{user_id}' ORDER BY create_at DESC LIMIT 10"
retourner sql_db.execute (requête)
def check_inventory(sku: str) -> dict :
"""Vérifiez si un produit est en stock."""
retourner inventor_db.lookup (sku)
def search_knowledge_base (requête : str) -> str :
"""Recherchez des documents d'aide, des politiques et des informations d'expédition."""
retourner vector_db.search (requête)
def create_ticket (user_id : str, problème : str) -> str :
"""Ouvrez un ticket de support pour un suivi humain."""
ticket_id = zendesk.create_ticket(user_id, problème)
return f"Ticket créé : {ticket_id}"
workflow = AgentWorkflow.from_tools_or_functions(
tools=[get_order_history, check_inventory, search_knowledge_base, create_ticket],
llm=OpenAI(model="gpt-4-turbo"),
system_prompt="""
Vous êtes agent de support client pour Acme E-commerce.
Votre objectif : résoudre le problème de l'utilisateur à l'aide des outils disponibles.
Règles :
- Vérifiez toujours l'historique des commandes en premier si l'utilisateur mentionne une commande
- Si le produit est en rupture de stock, proposez des alternatives ou une date de réapprovisionnement
- Si le problème est complexe ou émotionnel, créez un ticket pour un suivi humain
- Soyez poli, concis et serviable.
"""
)
## Exécuter
user_query = "J'ai commandé le SKU-12345 la semaine dernière mais je n'ai pas reçu de confirmation d'expédition. Mon numéro de commande est ABC-789."
réponse = attendre workflow.run(user_msg=user_query)
imprimer (réponse)L'agent :
- Appelez « get_order_history » avec l'ID utilisateur dérivé du numéro de commande
- Vérifiez que la commande est « en cours de traitement » mais n'est pas expédiée
- Appelez « search_knowledge_base » pour connaître la politique d'expédition (« Le traitement de la commande prend 1 à 3 jours ouvrables »)
- Générez la réponse : "Votre commande ABC-789 est toujours en cours de traitement. L'expédition prend généralement 1 à 3 jours ouvrables. Vous recevrez un numéro de suivi par e-mail lors de l'expédition."
Si la commande a dépassé la fenêtre d'expédition, elle peut appeler « create_ticket ».
Modèles avancés
Chaînage d'outils et transmission de données
Les agents peuvent enchaîner des outils où la sortie de l’un devient l’entrée du suivant. Le cadre de workflow gère cela automatiquement lorsque vous structurez correctement l'historique des conversations.
Gestion de la mémoire et du contexte
Pour les longues conversations, vous devez compresser ou résumer l'historique pour l'adapter à la fenêtre contextuelle. Techniques :
- Tampons de résumé : Résumez périodiquement les anciens messages et ne conservez que les plus récents + résumé
- Score de pertinence : stockez toutes les interactions passées dans une base de données vectorielle et récupérez uniquement celles qui sont pertinentes à chaque tour.
- État de session : conserver l'état structuré (par exemple,
current_order_id,user_name) dans un magasin séparé et l'injecter dans l'invite à chaque étape
Collaboration multi-agents
Des tâches complexes peuvent être réparties entre des agents spécialisés, coordonnés par un superviseur :
Agent superviseur
├─ Agent de recherche (recherches web, base de connaissances)
├─ Data Agent (exécute SQL, analyse les données)
└─ Write Agent (génère la réponse finale)LangGraph le prend en charge de manière native : chaque nœud peut être un workflow d'agent complet.
Humain dans la boucle
Les agents doivent savoir quand s'arrêter et demander à un humain. Ajoutez un outil «ask_human(question)» qui suspend l'exécution et envoie la question à un canal ou un tableau de bord Slack. Lorsque l'humain répond, l'agent reprend.
Liste de contrôle de préparation à la production
Quand NE PAS utiliser d'agents
Les agents sont puissants mais ajoutent de la complexité. Évitez-les quand :
- La tâche consiste en une simple question-réponse à partir d'une base de connaissances statique (un RAG de base suffit)
- Vous avez besoin d'une latence ultra-faible (< 200 ms) : les agents ajoutent 1 à 3 étapes de surcharge
- Le coût des appels LLM supplémentaires dépasse les avantages
- Vous ne pouvez pas définir des outils clairs avec des résultats déterministes
- La conformité réglementaire nécessite une prévisibilité totale (les agents ne sont pas déterministes)
Le résultat
Agentic RAG va au-delà des simples chatbots pour devenir des systèmes de raisonnement en plusieurs étapes qui peuvent planifier, récupérer, agir et s'auto-corriger. Des frameworks comme LangGraph, LlamaIndex et Outlines le rendent accessible.
Commencez petit : choisissez un flux de travail unique à grande valeur ajoutée (support client, analyse de données, assistant de recherche) et créez un agent pour celui-ci. Mesurez le succès par la réduction des escalades humaines, et pas seulement par la qualité des réponses.
L'avenir des applications d'IA ne se limite pas à de meilleures invites : il s'agit également d'une intelligence orchestrée.
Points clés à retenir
- Le RAG simple est limité aux questions et réponses statiques ; les agents ajoutent la planification, l'utilisation des outils, la mémoire et l'autocorrection
- Frameworks de base : LangGraph (graphiques cycliques), LlamaIndex (AgentWorkflow), Outlines (sortie structurée)
- Créer des agents pour des flux de travail en plusieurs étapes : support client, analyse de données, recherche
- Préparation à la production : délais d'attente, tentatives, contrôles des coûts, observabilité, garde-corps
- Savoir quand NE PAS utiliser d'agents (tâches simples, faible latence, déterminisme strict)
Besoin d'aide pour créer des agents ?
Nous concevons et déployons des agents d'IA de qualité production qui s'intègrent à vos données, outils et flux de travail. Prenez contact pour un atelier technique.
<a href="/get-started/" class="btn btn-primary">Planifier l'atelier</a>
Nombre de mots : ~1050
Langues cibles : Anglais (source), arabe, espagnol, allemand, français