Concevoir des agents d'IA et des flux d'automatisation

Créez des systèmes d'IA agentiques et des flux d'automatisation avec des prompts réutilisables, une gestion d'état et des modèles d'intégration qui évoluent de manière fiable sur n8n, API et LLM.

By Copy&Prompt TEAM · Published June 2025 · Updated June 2025

Quick Answer: Concevez des agents d'IA en leur attribuant un rôle fixe, un ensemble restreint d'outils, une mémoire à court terme et une condition de fin. Connectez-les en flux d'automatisation à l'aide de déclencheurs déterministes (webhooks, planifications ou appels API) et transmettez du JSON structuré entre les étapes. Stockez chaque prompt d'agent réutilisable en externe afin que les mises à jour se propagent instantanément à tous les flux. Validez chaque agent contre trois modes d'échec avant l'enchaînement : délai d'expiration, boucle et appel d'outil halluciné.

Introduction

Vous souhaitez créer des agents d'IA qui ne s'effondrent pas après le troisième test. Vous voulez des flux d'automatisation qui survivent aux mises à jour des modèles et aux changements d'équipe. Vous voulez des systèmes qui récupèrent après un échec au lieu de l'amplifier.

Ce guide vous présente l'architecture que chaque équipe néglige. Nous abordons la gestion d'état, le versionnement des prompts, les contrats d'outils et les modèles d'intégration à l'aide de Copy&Prompt, n8n et les API LLM directes.

Estimation de durée : 45 minutes. Niveau : intermédiaire. Vous devez déjà savoir appeler une API et rédiger un prompt système de base.

Conditions préalables

• Une clé API OpenAI, Anthropic ou Gemini (ou un modèle auto-hébergé).
• Accès à Copy&Prompt pour le versionnement des prompts (le niveau gratuit suffit).
• Un outil de flux : n8n (local ou cloud), Make, ou un script Node.js léger.
• Connaissance élémentaire des schémas JSON et des API REST.
• Budget : zéro si vous utilisez les niveaux gratuits. Prévoyez des coûts d'API au-delà de 10 000 appels mensuels.

Étape 1 : Définir le contrat de l'agent

Commencez par un contrat, pas par du code. Chaque agent doit déclarer son rôle, ses entrées, ses sorties, son comportement en cas d'échec et ses outils dans un seul prompt versionné.

{
  "role": "Lead Research Analyst",
  "input": "A customer query string",
  "output": "Structured JSON with keys: intent, urgency, recommended_next_step",
  "timeout_seconds": 30,
  "max_retries": 2,
  "tools": ["web_search", "summarize"],
  "failure_mode": "escalate_to_human"
}

Tip : N'intègrez jamais le contrat dans la logique du flux. Stockez-le en tant que modèle de prompt dans Copy&Prompt afin que chaque flux utilise la même définition.

Pitfall : Définir les "outils" comme des chaînes de caractères librement formatées au lieu d'API typées. Le modèle hallucinera des paramètres.

Étape 2 : Externaliser les prompts dans une bibliothèque versionnée

La principale source d'écart vient des prompts intégrés. Lorsque vous mettez à jour un prompt système dans n8n, vous devez manuellement republier chaque flux. À la place, stockez les prompts en externe.

Utilisez Copy&Prompt pour héberger chaque prompt d'agent. Chaque prompt reçoit un identifiant stable :

GET https://api.copyandprompt.com/v1/prompts/{prompt_id}?version=latest

Les flux appellent cet endpoint à l'exécution. Une seule mise à jour de prompt se propage partout instantanément.

Tip : Verrouillez le hachage de version dans les flux de production. Activez la mise à jour automatique uniquement en environnement de test.

Pitfall : Utiliser "latest" en production. Une bonne modification de prompt peut dégrader silencieusement 80 % des flux en une nuit.

Étape 3 : Construire la boucle d'exécution

Chaque agent passe par trois phases : initialiser, agir, terminer.

1. Initialiser : Charger le contrat de prompt depuis votre bibliothèque versionnée.
2. Agit : Appeler le LLM avec le rôle + contexte + outils. Analyser la réponse JSON.
3. Terminer : Vérifier les conditions de sortie. Si elles sont remplies, retourner le résultat. Sinon, décider de l'action suivante.

while not exit_condition_met:
    response = call_llm(system_prompt, user_input, tools)
    action = parse_action(response)
    if action.type == "search":
        result = web_search(action.query)
        tool_result = summarize(result)
    elif action.type == "finish":
        return action.output
    else:
        escalate_to_human()

Tip : Limitez les itérations à 5–10 boucles. Aucun agent ne devrait tourner indéfiniment.
Pitfall : Pas de limite d'itération. Les agents tournent en rond sur les entrées ambiguës.

Étape 4 : Concevoir des points d'intégration déterministes
Les agents sont non déterministes. Les flux doivent être déterministes. Reliez-les avec des contrats structurés.

Chaque sortie d'agent devient un objet JSON transmis à l'étape suivante. Définissez des schémas à chaque transition :

{
  "type": "object",
  "properties": {
    "intent": {"type": "string", "enum": ["billing", "technical", "sales"]},
    "urgency": {"type": "integer", "minimum": 1, "maximum": 5},
    "next_step": {"type": "string"}
  },
  "required": ["intent", "urgency", "next_step"]
}

Tip : Utilisez des schémas Zod en TypeScript pour valider les sorties d'agents avant le routage.
Pitfall : Transmettre du texte brut entre agents. Les données non structurées accumulent les erreurs.

Étape 5 : Enchaîner les agents en flux
Utilisez n8n ou un exécuteur de scripts pour orchertrer. Chaque nœud appelle un agent via HTTP.

Exemple de flux n8n :

Webhook reçoit un e-mail client.
Nœud 1 appelle l'agent Classifieur d'intention. Analyse la sortie JSON.
Nœud 2 acache vers l'agent Facturation ou Technique selon l'intention.
Nœud 3 appelle l'agent Base de connaissance avec un contexte structuré.
Nœud final envoie la réponse par e-mail ou Slack.


Tip : Insérez un nœud de « porte de qualité » entre les agents. Validez le schéma JSON avant de transmettre.
Pitfall : Chaînes linéaires sans secours en cas d'erreur. Un seul mauvais agent casse tout le flux.

Étape 6 : Gérer la gestion d'état
La plupart des échecs d'agents proviennent de contexte perdu. Utilisez un magasin d'état persistant.

Implémentez un magasin clé-valeur simple (Redis, SQLite, ou même un fichier JSON) par instance de flux :

{
  "run_id": "abc-123",
  "current_agent": "knowledge_base",
  "history": [
    {"agent": "intent_classifier", "output": {...}},
    {"agent": "knowledge_base", "output": {...}}
  ],
  "user_context": {
    "customer_id": "cust_99",
    "previous_ticket": "TKT-3321"
  }
}

Tip : Enregistrez chaque interaction d'agent. La récupération commence par la traçabilité.
Pitfall : Pas de persistance d'état. Les flux à long terme oublient les décisions précédentes.

Étape 7 : Mettre en place la surveillance et la récupération
Surveillez trois métriques par agent :

Taux de sortie : Pourcentage de tests atteignant un état terminal.
Taux de nouvelle tentative : Pourcentage d'appels d'outils nécessitant une nouvelle tentative.
Taux d'hallucination : Pourcentage de sorties JSON malformées.


Activez des alertes lorsque l'un de ces taux dépasse 5 %. Réessayez automatiquement les agents ayant échoué une fois, puis escalate.

Tip : Stockez les tests ayant échoué avec leur contexte complet. Réexécutez-les avec un prompt corrigé pour tester la récupération.
Pitfall : Pas d'alerte. Une dégradation silencieuse détruit la confiance dans le système.

Comment vérifier que cela fonctionne
Testez chaque agent contre trois scénarios :

Chemin heureux : Entrée claire correspondant au contrat de prompt.
Entrée ambiguë : Cas limite oblige l'agent à demander des précisions.
Outil défaillant : Simulez un délai d'expiration ou une erreur API. Confirmez que l'escalade se déclenche.


Les trois tests doivent réussir avant le déploiement.

Dépannage des échecs courants
L'agent tourne indéfiniment
Cause : Pas de limite d'itération ou condition de sortie incorrecte.
Solution : Imposer une limite stricte de 10 tours. Enregistrer chaque itération.

Incohérences de schéma de sortie
Cause : Dérive du prompt ou modèles non versionnés.
Solution : Valider chaque sortie contre son schéma. Verrouiller les versions de prompts.

Le flux stagne sur un agent
Cause : Pas de gestion des délais ou logique de nouvelle tentative.
Solution : Ajouter une logique de disjoncteur. Acenser les échecs vers un nœud d'escalade humaine.

Enseignements clés

Définir chaque agent avec un contrat fixe stocké à l'extérieur du code.
Externaliser les prompts dans une bibliothèque versionnée comme Copy&Prompt.
Limitez les boucles d'agents. Ne laissez jamais tourner indéfiniment.
Transmettez du JSON structuré entre agents. Jamais de texte brut.
Surveillez les taux de sortie, de nouvelle tentative et d'hallucination. Alertes à 5 %.
Testez les agents sur des entrées heureuses, ambiguës et échouantes.


Prochaine étape
Prenez votre meilleur agent en cours d'exécution aujourd'hui. Déplacez son prompt dans Copy&Prompt. Remplacez la version intégrée par un appel API. Déployez un flux utilisant ce modèle. Vous détecterez les écarts avant qu'ils n'impactent la production.

Questions fréquentes

Puis-je créer des agents sans n8n ?
Oui. Utilisez un script Node.js léger avec Express pour les déclencheurs HTTP. n8n n'apporte aucune fonctionnalité unique au-delà de l'orchestration visuelle. La clé réside dans les transitions structurées et l'état persistant.


Combien d'agents un flux devrait-il contenir ?
Limiter à 5–7 agents par flux. Au-delà, la complexité de débogage augmente exponentiellement. Moins d'agents avec un accès riche aux outils évoluent mieux qu'une longue chaîne.



Améliorez vos résultats d'IA dès aujourd'hui - Créez de meilleurs prompts et obtenez des réponses plus précises avec Copy&Prompt. Copy&Prompt →