Flux de travail IA

Un workflow IA est un système qui combine de manière ordonnée plusieurs appels à des modèles d'IA, l'utilisation d'outils et des étapes de traitement de données en un pipeline automatisé.

Un seul appel à un LLM peut répondre à des questions, mais les tâches du monde réel nécessitent souvent : rechercher sur le Web → extraire des informations → analyser → rédiger un rapport → envoyer un e-mail. Le workflow IA consiste à enchaîner ces étapes afin que l'IA puisse accomplir automatiquement l'ensemble de la tâche, plutôt que de simplement répondre à une seule phrase.

Une analogie intuitive

Imaginez une chaîne de montage :

Mode	Analogie	Description
Appel unique à un LLM	Comme un artisan	Donnez-lui un morceau de fer, et il vous rend une épée
Flux de travail IA	Comme une chaîne de montage entière	Les matières premières entrent, passent automatiquement par la fusion → le forgeage → la trempe → le polissage → l'emballage, et des produits finis en sortent

Chaque étape peut être un modèle d'IA, une fonction de code, une API externe ou un nœud de révision humaine.

Évolution des questions-réponses à l'action

Pourquoi le workflow IA est nécessaire

Limites des appels uniques

Un seul appel à un LLM peut accomplir très peu de choses :

Fenêtre de contexte limitée : impossible de lire un livre entier d'un seul coup
Impossible d'accéder aux informations en temps réel : les données d'entraînement ont une date limite
Impossible d'effectuer des actions : impossible d'envoyer réellement des e-mails, d'écrire et d'exécuter du code
Impossible de s'auto-valider : impossible de prendre conscience des erreurs après les avoir générées et de les corriger
Les tâches complexes sont sujettes aux erreurs : en faire trop en une seule étape entraîne une dégradation de la qualité

Cinq problèmes fondamentaux résolus par le workflow IA

Composants principaux

Un workflow IA complet se compose des éléments fondamentaux suivants.

Explication détaillée de chaque composant

LLM (grand modèle de langage)- Le « cerveau » du Workflow, responsable du raisonnement, de la génération et de la prise de décision. Couramment utilisés : GPT-4o, Claude 3.5, Gemini 1.5, Llama 3 local.

Outils- Interfaces qui permettent à l'IA d'interagir avec le monde extérieur, notamment : moteurs de recherche (Tavily, Serper, Bing), exécuteurs de code (Python REPL, environnements sandbox), requêtes de base de données (SQL, DB vectorielle), API externes (météo, cours boursiers, e-mail, calendrier), opérations sur fichiers (lecture/écriture, analyse de PDF/Excel).

Mémoire- La mémoire à court terme stocke l'historique de conversation de la session en cours (stocké dans le prompt) ; la mémoire à long terme permet un stockage persistant entre les sessions via base de données vectorielle + RAG ; la mémoire de travail maintient l'état intermédiaire pendant l'exécution de la tâche.

État- Le support d'information transmis entre les étapes d'une tâche, comme un témoin de relais ; chaque étape peut lire le résultat de l'étape précédente et écrire de nouveaux résultats.

Routeur / Condition (Router)- Détermine dynamiquement l'étape suivante en fonction de la sortie de l'étape précédente, permettant un contrôle de flux complexe tel que le branchement, la boucle et le saut.

Humain dans la boucle- Met en pause à des nœuds clés pour attendre la confirmation humaine, adapté aux opérations à haut risque (par ex., suppression de données, envoi d'e-mails, opérations financières).

Six modèles de Workflow courants

Voici les six modèles de conception les plus courants dans un Workflow IA, du plus simple au plus complexe, adaptés à différents scénarios.

Modèle 1 : Chaîne séquentielle

Le modèle le plus basique, où les étapes A → B → C s'exécutent linéairement, et la sortie de l'étape précédente est l'entrée de la suivante.

Dimension	Description
Scénarios applicables	Pipelines de traitement de documents, génération de contenu, transformation de données
Avantages	Simple, prévisible
Inconvénients	Rigide, ne peut pas s'ajuster dynamiquement en fonction du contenu

Modèle 2 : Routage conditionnel

Sélectionner dynamiquement différents chemins suivants en fonction du contenu de sortie d'une certaine étape.

Dimension	Description
Scénarios applicables	Service client intelligent, assistants multifonctions, classification et traitement des questions
Avantages	Flexible, utilisation élevée des ressources
Inconvénients	La logique de routage nécessite une conception minutieuse ; les erreurs de classification affectent l'ensemble du processus

Modèle 3 : Exécution parallèle

Plusieurs sous-tâches s'exécutent simultanément, et les résultats sont agrégés à la fin.

Dimension	Description
Scénarios applicables	Analyse multidimensionnelle, traitement par lots, sous-tâches indépendantes
Avantages	Vitesse considérablement améliorée
Inconvénients	Nécessite de gérer le contrôle de concurrence et la logique de fusion des résultats

Modèle 4 : Boucle ReAct (Raisonnement + Action)

L'IA raisonne d'abord pour décider quoi faire, puis agit pour appeler des outils, et continue à raisonner en fonction des résultats, en boucle jusqu'à ce que la tâche soit terminée. C'est le modèle central des Agents IA.

Dimension	Description
Scénarios applicables	Agent IA, exécution de tâches complexes, résolution de problèmes ouverts
Avantages	Dynamique et flexible, peut gérer des situations inconnues
Inconvénients	Le nombre de boucles n'est pas contrôlable, et un nombre maximal d'étapes doit être défini pour éviter une boucle infinie.

Modèle 5 : Planifier et exécuter

Laisser d'abord le LLM former un plan complet, puis exécuter étape par étape selon le plan. La différence avec ReAct est « réfléchir clairement d'abord, puis agir ».

Modèle 6 : Collaboration multi-Agents

Plusieurs Agents spécialisés travaillent en collaboration, et chaque Agent a son propre rôle et ensemble d'outils.

Dimension	Description
Scénarios applicables	Développement logiciel complexe, assistance à la recherche, automatisation d'entreprise
Avantages	Spécialisation dédiée, qualité supérieure, facile à mettre à l'échelle
Inconvénients	Complexité système élevée ; la communication entre Agents nécessite une conception minutieuse

Comparaison des principaux frameworks et outils

Voici une comparaison complète des frameworks de Workflow IA les plus courants, pour vous aider à choisir en fonction de votre situation.

Arbre de décision pour le choix du framework

En fonction de votre situation spécifique, suivez l'arbre de décision ci-dessous pour choisir le framework approprié :

你的情况是什么？
│
├─── 没有编程基础，想用可视化工具搭建
│    ├─── 主要是 AI 应用（问答、生成）→ Dify（首选）
│    └─── 需要连接 Slack/邮件等 SaaS 系统 → n8n
│
├─── 有 Python 基础，代码优先
│    ├─── 做知识库 / RAG 系统 → LlamaIndex
│    ├─── 做多 Agent 协作，想快速上手 → CrewAI
│    ├─── 需要复杂有状态流程控制 → LangGraph
│    └─── 通用场景，想要最大生态 → LangChain
│
└─── 已有明确场景，生产级要求
     ├─── 高并发、精细控制 → LangGraph + LangSmith
     └─── 企业部署、私有化 → Dify 自托管

Démarrage rapide : exemples de code Python

Les exemples suivants passent de la chaîne séquentielle la plus simple à une collaboration multi-Agent complexe, démontrant comment mettre en œuvre des Workflows IA étape par étape.

Chaîne séquentielle LangChain

Le modèle de Workflow le plus basique, en enchaînant plusieurs étapes d'appel LLM avec l'opérateur pipe |.

Installer les paquets de dépendances :

pip install langchain langchain-openai

Exemple

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o-mini", api_key="your-api-key")

# ─── Définir trois étapes ────────────────────────────────────────────
# Étape 1 : Traduire l'article en chinois
translate_prompt = ChatPromptTemplate.from_template(
Traduisez l'article anglais suivant en chinois, en préservant le sens original :\n\n{article}"
)

# Étape 2 : Extraire le résumé
summarize_prompt = ChatPromptTemplate.from_template(
Veuillez distiller l'article suivant en 3 points clés, une phrase chacun :\n\n{translated}"
)

# Étape 3 : Générer le titre
title_prompt = ChatPromptTemplate.from_template(
À partir du résumé suivant, générez un titre chinois attrayant (en 15 caractères maximum) :\n\n{summary}"
)

parser = StrOutputParser()

# ─── Enchaîner avec l'opérateur | pour former un pipeline ─────────────────────────────────
chain = (
{"translated": translate_prompt | llm | parser}
| {"summary": summarize_prompt | llm | parser,
"translated": lambda x: x["translated"]}
| title_prompt | llm | parser
)

# ─── Exécuter ────────────────────────────────────────────────────
article = """
L’intelligence artificielle transforme notre façon de travailler et de vivre.
De l’automatisation des tâches répétitives à l’assistance au travail créatif,
Les outils d’IA deviennent indispensables dans les flux de travail modernes...
"""

result = chain.invoke({"article": article})
print(result)

AI 正在重塑现代工作流：从自动化到创意辅助

Agent d’appel d’outils (mode ReAct)

ReAct est le mode central d’un agent IA, permettant à l’IA d’alterner entre réflexion et action jusqu’à ce que la tâche soit terminée.

Exemple

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.tools import tool
from langchain import hub
import requests, datetime

# ─── Définir les outils ────────────────────────────────────────────────
@tool
def get_weather(city: str) -> str:
"""Obtenir les informations météorologiques actuelles pour une ville spécifiée"""
# Remplacer par une API météo réelle en production
mock_data = {
"Beijing": "Ensoleillé, 22°C, légère brise",
"Shanghai": "Nuageux, 26°C, humidité 75%",
"Guangzhou": "Pluie légère, 30°C, prenez un parapluie",
}
return mock_data.get(city, f"Aucune donnée météorologique disponible pour {city}")

@tool
def search_web(query: str) -> str:
"""Rechercher des informations sur le web et renvoyer un résumé du contenu pertinent"""
# Intégrer Tavily / Serper API en production
return f"Résultats de recherche pour '{query}' : Ceci est un résultat de recherche simulé..."

@tool
def calculate(expression: str) -> str:
"""Calculer une expression mathématique, par ex., '2 + 3 * 4'"""
try:
result = eval(expression, {"__builtins__": {}}, {})
return str(result)
except Exception as e:
return f"Erreur de calcul : {e}"

@tool
def get_date() -> str:
"""Obtenir la date d'aujourd'hui"""
return datetime.date.today().strftime("%Y-%m-%d")

# ─── Créer un agent ───────────────────────────────────────────────
tools = [get_weather, search_web, calculate, get_date]
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# Utiliser le prompt ReAct standard de LangChain Hub
prompt = hub.pull("hwchase17/react")

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True, # Afficher chaque étape de raisonnement pour faciliter le débogage
max_iterations=8, # Empêcher les boucles infinies
handle_parsing_errors=True
)

# ─── Exécuter ────────────────────────────────────────────────────
result = agent_executor.invoke({
"input": "Quelle est la date d'aujourd'hui ? Quel temps fait-il à Pékin ? Si vous marchez 5km en extérieur, vous brûlez environ 300 calories, "
"Courir la même distance brûle environ 1.6 fois celle de la marche. Veuillez calculer les calories brûlées en courant."
})

print(result["output"])
# L'agent décidera automatiquement : d'abord appeler get_date → get_weather("Beijing") → calculate("300*1.6")
# Enfin, combinez toutes les informations pour donner une réponse complète

Flux de travail avec état LangGraph

LangGraph définit des flux de travail complexes à l'aide de graphes, où chaque nœud est une fonction et les arêtes définissent la logique de transition.

Exemple

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, Annotated
import operator

# ─── Définir la structure d'état (données transmises entre les nœuds) ────────────────────────
class ResearchState(TypedDict):
topic: str # Sujet de recherche
research_notes: str # Notes de recherche
draft: str # Brouillon
review_feedback: str # Retour de révision
final_report: str # Rapport final
revision_count: Annotated[int, operator.add] # Nombre de révisions (cumulatif)

llm = ChatOpenAI(model="gpt-4o")

# ─── Définir les fonctions de nœud ─────────────────────────────────────────────
def research_node(state: ResearchState) -> dict:
"""Nœud 1 : Phase de recherche"""
response = llm.invoke(
f"Veuillez effectuer une brève recherche sur le sujet suivant et énumérer 5 points clés : {state['topic']}"
)
return {"research_notes": response.content}

def write_node(state: ResearchState) -> dict:
"""Nœud 2 : Rédiger le brouillon"""
prompt = f"""
Sujet : {state['topic']}
Notes de recherche : {state['research_notes']}
{'Commentaires de la révision précédente : ' + state.get('review_feedback', '') if state.get('review_feedback') else ''}

Veuillez rédiger un brouillon de 300 mots d'un rapport d'analyse basé sur le contenu ci-dessus.
"""
response = llm.invoke(prompt)
return {"draft": response.content, "revision_count": 1}

def review_node(state: ResearchState) -> dict:
"""Nœud 3 : Révision du brouillon"""
response = llm.invoke(
f"Examinez le rapport suivant. Si la qualité répond au standard, répondez 'APPROVED' ; sinon, fournissez des suggestions de révision spécifiques :\n\n{state['draft']}"
)
return {"review_feedback": response.content}

def finalize_node(state: ResearchState) -> dict:
"""Nœud 4 : Finalisation"""
return {"final_report": state["draft"]}

# ─── Fonction de routage : déterminer quel chemin prendre après révision ─────────────────────────────
def should_revise(state: ResearchState) -> str:
if "APPROVED" in state["review_feedback"]:
return "finalize" # → Finaliser
elif state["revision_count"] >= 3:
return "finalize" # → Dépasse 3 révisions, terminaison forcée
else:
return "revise" # → Retour au nœud de rédaction pour révision

# ─── Construire le graphe de workflow ─────────────────────────────────────────────
workflow = StateGraph(ResearchState)

# Ajouter les nœuds
workflow.add_node("research", research_node)
workflow.add_node("write", write_node)
workflow.add_node("review", review_node)
workflow.add_node("finalize", finalize_node)

# Définir le point d'entrée
workflow.set_entry_point("research")

# Ajouter les arêtes (définir la logique de transition)
workflow.add_edge("research", "write") # Recherche → Rédaction
workflow.add_edge("write", "review") # Rédaction → Révision

# Arête conditionnelle : choisir le chemin en fonction du résultat de la révision
workflow.add_conditional_edges(
"review",
should_revise,
{
"revise": "write", # Nécessite une révision → Retour à la rédaction
"finalize": "finalize" # Approuvé → Finaliser
}
)

workflow.add_edge("finalize", END)

# Compiler et exécuter
app = workflow.compile()

result = app.invoke({"topic": "L'impact de l'IA générative sur l'industrie du développement logiciel", "revision_count": 0})
print(result["final_report"])

Collaboration multi-agents avec CrewAI

CrewAI permet à plusieurs agents de collaborer comme une équipe en définissant des rôles et des tâches.

Exemple

from crewai import Agent, Task, Crew, Processus
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

# ─── Définir l'Agent (Rôle) ────────────────────────────────────────
researcher = Agent(
role=Chercheur de marché,
goal=Collecter et organiser des informations de marché complètes et précises sur le sujet cible.,
backstory=Vous êtes un analyste de marché expérimenté, habile à extraire des enseignements clés à partir de vastes quantités d'informations.,
llm=llm,
verbose=True
)

analyst = Agent(
role=Analyste de données,
goal=À partir des informations fournies par le chercheur, mener une analyse approfondie et tirer des conclusions précieuses.,
backstory=Vous excellez dans l'utilisation des données pour communiquer et savez déceler les tendances et opportunités cachées dans l'information.,
llm=llm,
verbose=True
)

writer = Agent(
role=Expert en rédaction de rapports,
goal=Rédigez les conclusions analytiques dans un rapport clair, professionnel et convaincant.,
backstory=Vous avez une grande expérience de la rédaction professionnelle et pouvez rendre une analyse complexe facile à comprendre.,
llm=llm,
verbose=True
)

# ─── Définir la tâche ────────────────────────────────────────
research_task = Task(
description=Recherchez l'état actuel du marché chinois des véhicules à énergie nouvelle, y compris les principales marques, la part de marché et les tendances de croissance.,
expected_output=Un rapport d'étude de marché contenant 5 points de données clés, y compris des chiffres et des faits précis.,
agent=researcher
)

analysis_task = Task(
description=Sur la base du rapport de recherche, analysez les opportunités et les risques au cours des 3 prochaines années et fournissez des recommandations de notation d'investissement.,
expected_output=Tableau d'analyse SWOT + notation d'investissement (fortement recommandé/recommandé/neutre/prudent) + justification,
agent=analyst,
context=[research_task] Sortie de la tâche de recherche dépendante
)

writing_task = Task(
description=Intégrez la recherche et l'analyse dans une note d'information professionnelle sur l'investissement de 500 mots avec une mise en forme claire.,
expected_output=Une note d'information comprenant quatre sections : résumé exécutif, état du marché, opportunités et risques, et recommandations d'investissement.,
agent=writer,
context=[research_task, analysis_task]
)

# ─── Constituer l'équipe et exécuter ───────────────────────────────────────────
crew = Crew(
agents=[researcher, analyst, writer],
tasks=[research_task, analysis_task, writing_task],
process=Process.sequential, # Exécution séquentielle (peut aussi être changée en hiérarchique)
verbose=True
)

result = crew.kickoff()
print(result)

Boucle de validation humaine (Nœud de révision manuelle)

LangGraph permet de suspendre l'exécution aux étapes critiques pour attendre la confirmation humaine avant de continuer.

Exemple

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from typing import TypedDict

class EmailState(TypedDict):
recipient: str
content: str
approved: bool

def draft_email(state: EmailState) -> dict:
Rédiger un e-mail.
content = fCher {state['recipient']},\n\nCeci est le contenu de l'e-mail rédigé par l'IA...\n\nCordialement
return {"content": content}

def send_email(state: EmailState) -> dict:
Envoyer un e-mail (opération à haut risque, nécessite un examen manuel avant exécution)
print(fL'e-mail a été envoyé à {state['recipient']})
return {}

# Routage : décider d'envoyer ou non en fonction du résultat de l'examen manuel.
def check_approval(state: EmailState) -> str:
return "send" if state.get("approved") else END

workflow = StateGraph(EmailState)
workflow.add_node("draft", draft_email)
workflow.add_node("send", send_email)
workflow.set_entry_point("draft")

# Pause après la fin du brouillon, attendre la revue humaine (interrupt_after)
workflow.add_conditional_edges("draft", check_approval, {"send": "send", END: END})
workflow.add_edge("send", END)

# Utiliser MemorySaver pour prendre en charge l'interruption et la reprise
memory = MemorySaver()
app = workflow.compile(
checkpointer=memory,
interrupt_after=["draft"] # Pause après le nœud draft
)

config = {"configurable": {"thread_id": "email-001"}}

# Premier lancement : pause après l'exécution jusqu'à draft
state = app.invoke({"recipient": "Client A", "approved": False}, config)
print("Brouillon généré, en attente de révision :")
print(state["content"])

# Après examen manuel, mettre à jour le statut et poursuivre l'exécution
user_input = input("\nApprouver l'envoi ? (y/n) : ")
if user_input.lower() == "y":
app.update_state(config, {"approved": True})
app.invoke(None, config) # Continuer depuis le point d'arrêt
print("E-mail envoyé")
else:
print("Envoi annulé")

Ingénierie des prompts : techniques clés dans le flux de travail

Dans le flux de travail d'IA, la qualité du prompt affecte directement la qualité de sortie de chaque nœud.

Exemple

# Définition de rôle floue
# system_prompt = "Vous êtes un assistant IA, aidez-moi à analyser ce document"

# Définition de rôle claire (recommandée)
system_prompt = """
Vous êtes un analyste financier professionnel, spécialisé dans l'identification des signaux de risque dans les rapports financiers.
Votre tâche : Extraire tous les points de données clés liés aux passifs, aux flux de trésorerie et à la rentabilité à partir du rapport suivant.
Format de sortie : JSON, contenant risk_level (high/medium/low) et key_findings (liste).
Remarque : Ne produire que du JSON, ne pas ajouter de texte explicatif.
"""

Exemple

# Passer du texte non structuré
# state["previous_output"] = "Résultat de l'analyse : Cette entreprise semble bonne, il y a quelques risques..."

# Passer des données structurées (recommandé)
state["analysis_result"] = {
"risk_level": "moyen",
"key_findings": ["Ratio d'endettement 45%, moyenne du secteur 38%", "Le flux de trésorerie est positif, T3 en baisse de 12% par rapport au trimestre précédent"],
"recommendation": "Conserver avec prudence"
}

Exemple

# Forcer la sortie JSON dans le prompt
prompt = """
Veuillez analyser le sentiment du texte suivant.
Produisez strictement le format JSON suivant, n'ajoutez aucun autre contenu :
{
"sentiment": "positif" | "négatif" | "neutre",
"confidence": 0.0-1.0,
"reason": "brève explication"
}

Texte : {text}
"""

Gestion des erreurs et réessai

Exemple

from tenacity import retry, stop_after_attempt, wait_exponential
import logging

@retry(
stop=stop_after_attempt(3), # Réessayer jusqu'à 3 fois
wait=wait_exponential(multiplier=1, min=2, max=10) # Attente avec repli exponentiel
)
def call_llm_with_retry(prompt: str) -> str:
try:
response = llm.invoke(prompt)
return response.content
except Exception as e:
logging.error(f"L'appel au LLM a échoué : {e}")
raise

def safe_parse_json(text: str) -> dict:
"""Analyser en toute sécurité la sortie JSON du LLM"""
import json, re
# Extraire la partie JSON (le LLM ajoute parfois du texte explicatif supplémentaire)
json_match = re.search(r'\{.*\}', text, re.DOTALL)
if json_match:
try:
return json.loads(json_match.group())
except json.JSONDecodeError:
pass
return {"error": Échec de l'analyse, "raw": text}

Contrôle des coûts

Exemple

# ─── Sélectionner les modèles selon l'importance de la tâche ────────────────────────────────
def get_llm(task_type: str):
if task_type == "classification": # Pour les tâches de classification, un modèle léger suffit
return ChatOpenAI(model="gpt-4o-mini")
elif task_type == "generation": # Pour les tâches de génération, utilisez un modèle moyen
return ChatOpenAI(model="gpt-4o-mini")
elif task_type == "reasoning": # Pour un raisonnement complexe, utilisez un modèle puissant
return ChatOpenAI(model="gpt-4o")

# ─── Mettre en cache les requêtes répétées ──────────────────────────────────────────
from langchain.globals import set_llm_cache
from langchain_community.cache import InMemoryCache
set_llm_cache(InMemoryCache()) # Renvoyer directement le résultat mis en cache pour une entrée identique ; pas de facturation en double

# ─── Découper le texte pour éviter une longueur excessive ──────────────────────────────────────
from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
chunk_size=2000, # 2000 caractères par segment
chunk_overlap=200 # Chevauchement de 200 caractères pour maintenir la cohérence du contexte
)
chunks = splitter.split_text(long_document)

Scénarios d'application typiques

AI Workflow a été largement adopté dans de multiples domaines. Les six scénarios les plus représentatifs sont les suivants.

Bonnes pratiques et pièges courants

Pièges courants et solutions

Voici les problèmes les plus courants rencontrés par les débutants lors de l'utilisation d'AI Workflow.

Piège	Symptôme	Solution
Cascade d'hallucinations	La sortie précédente de l'IA est incorrecte, transmise comme un fait à l'étape suivante, amplifiant l'erreur.	Ajoutez des étapes de vérification aux nœuds clés ; utilisez des outils pour les informations numériques.
Boucle infinie	L'agent ReAct appelle à plusieurs reprises des outils sans savoir quand s'arrêter.	Définissez max_iterations ; donnez au LLM des conditions d'arrêt explicites.
Explosion du contexte	À mesure que les étapes augmentent, le texte transmis au LLM devient plus long et dépasse la fenêtre.	Ne transmettez que les champs nécessaires à chaque étape ; compressez les informations historiques avec des résumés.
Abus d'outils	L'agent peut répondre directement mais continue d'appeler des outils.	Optimisez les descriptions des outils ; indiquez clairement au LLM quand les outils ne sont pas nécessaires.
Échec d'analyse JSON	Le format de sortie du LLM est instable, ce qui fait planter le programme.	Ajoutez safe_parse_json ; utilisez OutputParser de LangChain.
Dépassement des coûts	L'utilisation des tokens n'est pas estimée, et la facture mensuelle dépasse les attentes.	Testez d'abord avec gpt-4o-mini ; utilisez LangSmith pour surveiller l'utilisation.
Conflit de concurrence	Plusieurs Agents écrivant simultanément dans le même état provoquent une corruption des données.	Utilisez la gestion d'état intégrée de LangGraph ; évitez de partager un état mutable.

Résumé et parcours d'apprentissage

Révision des connaissances essentielles

Parcours d'apprentissage recommandé

Phase 1 : Comprendre les bases (1 semaine)

Comprendre les appels API LLM, être capable d'effectuer des requêtes avec le SDK OpenAI
Parcourir l'exemple de chaîne séquentielle LangChain dans cet article
Comprendre les principes de base de l'ingénierie des prompts

Phase 2 : Outils et Agents (2 semaines)

Apprendre à définir des outils avec le décorateur @tool
Parcourir l'exemple ReAct Agent, observer les logs verbeux pour comprendre la logique de boucle
Utiliser Dify ou n8n pour construire un prototype de Workflow visuel

Phase 3 : Workflow complexe (3 semaines)

Apprendre les graphes d'état LangGraph, implémenter un workflow avec branchement conditionnel
Utiliser CrewAI pour implémenter une tâche de collaboration à deux Agents
Intégrer de vrais outils (Tavily Search, Python REPL)
Utiliser LangSmith pour observer et déboguer votre Workflow

Phase 4 : Prêt pour la production (en continu)

Implémenter la nouvelle tentative en cas d'erreur et l'analyse de sortie structurée
Surveillance et optimisation des coûts (utilisation de modèles par niveaux)
Déployer en production, mettre en place la surveillance et les alertes

Ressources de référence

autres extensions

Outils pour agents intelligents

Implémentation d’agents intelligents en Python

Flux de travail IA

Une analogie intuitive

Évolution des questions-réponses à l'action

Pourquoi le workflow IA est nécessaire

Limites des appels uniques

Cinq problèmes fondamentaux résolus par le workflow IA

Composants principaux

Explication détaillée de chaque composant

Six modèles de Workflow courants

Modèle 1 : Chaîne séquentielle

Modèle 2 : Routage conditionnel

Modèle 3 : Exécution parallèle

Modèle 4 : Boucle ReAct (Raisonnement + Action)

Modèle 5 : Planifier et exécuter

Modèle 6 : Collaboration multi-Agents

Comparaison des principaux frameworks et outils

Arbre de décision pour le choix du framework

Démarrage rapide : exemples de code Python

Chaîne séquentielle LangChain

Exemple

Agent d’appel d’outils (mode ReAct)

Exemple

Flux de travail avec état LangGraph

Exemple

Collaboration multi-agents avec CrewAI

Exemple

Boucle de validation humaine (Nœud de révision manuelle)

Exemple

Ingénierie des prompts : techniques clés dans le flux de travail

Exemple

Exemple

Exemple

Gestion des erreurs et réessai

Exemple

Contrôle des coûts

Exemple

Scénarios d'application typiques

Bonnes pratiques et pièges courants

Pièges courants et solutions

Résumé et parcours d'apprentissage

Révision des connaissances essentielles

Parcours d'apprentissage recommandé

Ressources de référence