Terminez d'abord "Leçon 4 : Appel d’outils et intégrations externes" pour débloquer cette leçon.Aller à la leçon précédente

Introduction

En production, les systèmes d’agents se cassent de manières surprenantes. Le LLM hallucine le nom d’un outil. Une API retourne un 500. L’utilisateur pose une question hors du champ de l’agent. Une boucle s’exécute indéfiniment parce que le modèle appelle sans cesse le même outil avec le même input. Rien de tout cela n’est théorique — tout agent qui tourne pendant un certain temps y sera confronté.

Ce chapitre couvre les motifs qui rendent les agents fiables : réessais avec backoff, validation des entrées avant les appels d’outils, validation des sorties après les réponses du modèle, disjoncteurs pour arrêter les boucles incontrôlées, et reprises gracieuses lorsque le modèle produit quelque chose que vous ne pouvez pas analyser. L’objectif n’est pas de rendre l’agent parfait — mais de rendre les échecs prévisibles, enregistrés et récupérables.

Validation des entrées avant l’exécution de l’outil

Avant de passer quoi que ce soit à un outil externe, validez-le. Le mode d’échec le plus courant est que l’agent génère un argument d’outil qui semble syntaxiquement correct mais est sémantiquement nulle — une date dans l’année 9999, un identifiant utilisateur qui n’existe pas, une requête SQL avec une clause manquante.

python
def get_user_orders(user_id: str, date_from: str, date_to: str) -> dict:
# Validate user_id is numeric and exists
if not user_id.isdigit() or not user_exists(user_id):
return {"error": "invalid_user_id", "message": f"User {user_id} not found"}
# Validate date format
try:
from datetime import datetime
datetime.strptime(date_from, "%Y-%m-%d")
datetime.strptime(date_to, "%Y-%m-%d")
except ValueError:
return {"error": "invalid_date", "message": "Dates must be YYYY-MM-DD"}
# Validate date range
if date_from > date_to:
return {"error": "invalid_range", "message": "date_from must be before date_to"}
# Now safe to call the actual tool
return query_orders(user_id, date_from, date_to)

Lorsque la validation échoue, retournez un objet d’erreur structuré — pas une exception. L’agent lit cela et décide quoi faire ensuite : demander des éclaircissements à l’utilisateur, essayer une approche différente ou abandonner gracieusement.

Réessais, Backoff et Disjoncteurs

Les échecs transitoires (délai réseau, erreurs 503, limites de taux) méritent des réessais. Mais des réessais naïfs aggravent les choses — si le service en aval est surchargé, le marteler davantage le maintient au silence.

python
import time
import random
def call_with_retry(fn, max_attempts=3, base_delay=1.0):
for attempt in range(max_attempts):
try:
result = fn()
if attempt > 0:
log_recovery(attempt) # Log that retry succeeded
return result
except RetryableError as e:
if attempt == max_attempts - 1:
raise
delay = base_delay * (2 ** attempt) + random.uniform(0, 0.5)
log_retry_attempt(attempt, e, delay)
time.sleep(delay)

Backoff exponentiel avec jitter étale le trafic de réessai afin que vous ne synchronisiez pas tous vos agents à se réessayer au même instant. Réessayez uniquement sur les erreurs classées comme transitoires — ne réessayez jamais sur 400 Bad Request, car la même entrée produira le même échec à chaque fois.

Les disjoncteurs vont encore plus loin : si un outil échoue N fois d'affilée, arrêtez de l'appeler pendant une période de refroidissement et échouez rapidement. Cela vous protège des agents qui s'embrouillent dans un service défaillant.

python
class CircuitBreaker:
def __init__(self, failure_threshold=5, cooldown_seconds=60):
self.failures = 0
self.threshold = failure_threshold
self.cooldown = cooldown_seconds
self.open_until = 0
def call(self, fn):
if time.time() < self.open_until:
raise CircuitOpenError(f"Circuit open until {self.open_until}")
try:
result = fn()
self.failures = 0
return result
except Exception:
self.failures += 1
if self.failures >= self.threshold:
self.open_until = time.time() + self.cooldown
raise
Machine à états pour le disjoncteur montrant les transitions fermée -> ouverte -> semi-ouverte

Validation de la sortie du modèle et gestion des boucles

Le modèle produira parfois une sortie qui ne correspond pas à votre schéma attendu — un blob JSON manquant d'un champ requis, un appel d'outil avec des arguments d'un type incorrect, un "appel de fonction" qui est en réalité une phrase en langage naturel halluciné. Vous avez besoin d'une couche qui intercepte cela.

python
def parse_agent_response(raw: str) -> AgentAction:
try:
parsed = json.loads(raw)
except json.JSONDecodeError:
return AgentAction.recover("Model returned non-JSON output")
if "tool" not in parsed or "arguments" not in parsed:
return AgentAction.recover("Missing tool or arguments field")
if parsed["tool"] not in ALLOWED_TOOLS:
return AgentAction.reject(f"Model tried to call unknown tool: {parsed['tool']}")
return AgentAction.execute(parsed["tool"], parsed["arguments"])

La détection de boucle est tout aussi importante. Suivez les N dernières paires (outil, arguments). Si la même paire se répète plus de M fois, abandonnez l'agent et affichez une erreur à l'utilisateur — quelque chose comme « Il semble que je fasse encore la même étape ». Sans cette protection, un modèle confus peut dépenser des milliers de jetons en appelant sans fin le même outil sans issue.

Diminution élégante et erreurs orientées utilisateur

Lorsque l'agent ne peut pas accomplir une tâche, la réponse à l'utilisateur doit être spécifique et actionnable. « Une erreur est survenue » est inutile. « Je n'ai pas pu récupérer vos commandes car le service de commandes est temporairement indisponible. Veuillez réessayer dans une minute, ou je peux vous montrer plutôt le récapitulatif de votre compte » indique à l'utilisateur ce qui s'est passé et propose une alternative.

Construire une chaîne de secours : si l'outil principal échoue, essayer un outil secondaire plus simple (par exemple des données mises en cache plutôt que des données en direct, ou un appel LLM différent avec une portée plus réduite). Si tout échoue, renvoyez une réponse finale qui explique honnêtement la limitation. Ne fabriquez jamais silencieusement des données pour couvrir un appel d’outil manquant — les utilisateurs le remarqueront et la confiance s’envolera.

Résumé

Des agents fiables se construisent à partir de couches de validation, de réessai et de gestion d’erreurs élégante. Validez les entrées avant les outils, réessayez les erreurs transitoires avec un backoff exponentiel et du jitter, utilisez des disjoncteurs pour stopper les boucles incontrôlées, validez la sortie du modèle par rapport à un schéma strict, détectez les actions répétées pour prévenir les boucles infinies et donnez toujours à l'utilisateur une réponse spécifique et honnête lorsque les choses tournent mal. Les modèles de cette leçon s’appliquent que vous construisiez avec LangChain, une orchestration personnalisée ou tout autre cadre d’agent — le cadre peut gérer certains de ces aspects pour vous, mais vous devez quand même comprendre ce qui se passe en dessous.

Entraînement

Point de contrôle de la leçon

Révisez la leçon et recevez des conseils sur votre travail.

0/1
Répondu · 0/1