Agents IA Claude OpenAI LangGraph : tutoriel pratique 2026

Lecture : 15 minutes · Niveau : développeur intermédiaire · Mise à jour : avril 2026

Les agents IA — LLM couplés à des outils, capables de planifier et d’exécuter des tâches multi-étapes en autonomie supervisée — sont passés en 2025-2026 du statut de démo à celui de brique d’architecture standard. Quatre frameworks dominent l’écosystème en 2026 : Claude Agent SDK (Anthropic, intégré aux capacités natives Claude comme MCP et Tool Use), OpenAI Agents SDK (équivalent OpenAI), LangGraph (LangChain, orchestration graph-based agnostique modèle), et Strands (AWS, intégration Bedrock). Ce tutoriel pratique couvre les patterns essentiels (ReAct, Plan-Execute, Multi-agent), des exemples Python exécutables, et les considérations production (latence, fiabilité, coût).

Pour le contexte stratégique global, voir le pillar IA générative avancée PME. Pour le RAG, voir RAG vector database.

1. Agent IA : concept et capacités

Définition. Un agent IA est un LLM auquel on donne :
– Tools (functions, APIs) qu’il peut invoquer.
– Instructions (system prompt) définissant son rôle.
– Mémoire (historique conversation, état persistant).

Le LLM décide quels outils invoquer, dans quel ordre, et compose une réponse finale après avoir observé les résultats.

Différence vs simple appel LLM.
– Appel LLM simple : prompt → réponse, en un coup.
– Agent : prompt → réflexion → action 1 → observation → réflexion → action 2 → … → réponse finale.

Capacités émergentes 2026.
– Multi-step planning et exécution.
– Auto-correction sur erreurs (retry, ajustement).
– Délégation à sous-agents spécialisés.
– État persistant entre sessions.
– Streaming actions (visibilité utilisateur sur ce que fait l’agent).

Différence vs workflow scripté.
– Workflow : séquence d’actions définie à l’avance.
– Agent : séquence dynamique, décidée à chaque étape.
– Agent quand séquence imprévisible (questions ouvertes, contextes variables).

2. Choix du framework 2026

Claude Agent SDK (Anthropic).
– Officiel Anthropic, intégré aux capacités natives Claude (Tool Use, Computer Use, MCP).
– Python et TypeScript SDKs.
– Strong sur agents long-running, sub-agents, orchestration.
– Naturel si stack Anthropic.

OpenAI Agents SDK.
– Officiel OpenAI, équivalent.
– Python.
– Bonne intégration GPT-5 et écosystème OpenAI (Assistants API, Threads).

LangGraph (LangChain).
– Open-source, agnostique modèle (Claude, OpenAI, Gemini, Ollama).
– Orchestration graph-based : nodes (steps) + edges (transitions).
– État explicite, durabilité (resume after crash).
– Python et TypeScript.
– Mature, communauté large.

Strands (AWS).
– Framework AWS, intégration Bedrock.
– Bon choix pour stack AWS-native.

Choix 2026.
– Anthropic stack : Claude Agent SDK.
– OpenAI stack : OpenAI Agents SDK.
– Multi-modèle / agnostique : LangGraph.
– AWS Bedrock : Strands.
– Démarrage simple sans framework : tool use direct via API (Anthropic ou OpenAI).

Recommandation pillar / PME : démarrer sans framework (tool use direct), passer à LangGraph si la complexité justifie.

3. Tool use : la brique fondamentale

Concept tool use. Le LLM peut appeler des fonctions (tools) que vous définissez, en passant des arguments structurés. La function s’exécute côté serveur, le résultat est renvoyé au LLM.

Exemple Anthropic (Claude tool use).

import anthropic
import json

client = anthropic.Anthropic()

# Définition outils
tools = [
    {
        "name": "get_weather",
        "description": "Récupère la météo actuelle pour une ville donnée",
        "input_schema": {
            "type": "object",
            "properties": {
                "city": {"type": "string", "description": "Nom de la ville"}
            },
            "required": ["city"]
        }
    },
    {
        "name": "get_orders",
        "description": "Liste les N dernières commandes d'un utilisateur",
        "input_schema": {
            "type": "object",
            "properties": {
                "user_id": {"type": "integer"},
                "limit": {"type": "integer", "default": 10}
            },
            "required": ["user_id"]
        }
    }
]

def get_weather(city):
    # Appel API météo réel
    return {"city": city, "temp": 28, "condition": "ensoleillé"}

def get_orders(user_id, limit=10):
    # Requête DB
    return [{"id": 1, "total": 50000}, {"id": 2, "total": 32000}]

def execute_tool(name, args):
    if name == "get_weather":
        return get_weather(**args)
    elif name == "get_orders":
        return get_orders(**args)

# Conversation avec tool use
messages = [
    {"role": "user", "content": "Quelles sont les 5 dernières commandes du client 42, et quel temps fait-il à Dakar ?"}
]

while True:
    response = client.messages.create(
        model="claude-sonnet-4-6-20250101",
        max_tokens=1024,
        tools=tools,
        messages=messages
    )

    if response.stop_reason == "tool_use":
        # L'agent demande d'invoquer un ou plusieurs tools
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result)
                })

        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})
    else:
        # Réponse finale
        print(response.content[0].text)
        break

Boucle agent.
1. Envoyer requête + tools.
2. Si LLM demande tool_use → exécuter → renvoyer résultat.
3. Répéter jusqu’à stop_reason == "end_turn".

OpenAI tool use.
Format légèrement différent (tools comme functions), même principe.

4. Pattern ReAct avec Claude

ReAct = Reasoning + Acting. Le LLM verbalise son raisonnement entre les actions, ce qui améliore la qualité des décisions.

System prompt ReAct.

Tu es un assistant qui utilise les outils disponibles pour répondre.

Pour chaque étape :
1. Réfléchis (en quelques phrases) à ce qu'il faut faire.
2. Décide quel outil utiliser, ou conclus.
3. Si action, invoque l'outil avec les bons arguments.
4. Observe le résultat.
5. Continue jusqu'à pouvoir répondre.

Les modèles Claude récents font naturellement du ReAct : il suffit de leur donner les tools.

Exemple agent recherche & synthèse.

tools = [
    {
        "name": "search_web",
        "description": "Recherche web via API Brave",
        "input_schema": {...}
    },
    {
        "name": "fetch_url",
        "description": "Récupère contenu d'une URL",
        "input_schema": {...}
    },
    {
        "name": "search_internal_docs",
        "description": "Cherche dans documents internes via RAG",
        "input_schema": {...}
    }
]

# L'agent va orchestrer search → fetch → synthèse autonome.

Limites ReAct.
– Boucles infinies possibles si tool fails.
– Latence (multiples LLM calls).
– Coût multiplié.

Garde-fous.
– max_iterations = 10 typique.
– Timeout global (60 sec).
– Logging chaque step pour audit.

5. LangGraph : orchestration graph-based

Concept. LangGraph définit un agent comme un graphe d’états : nodes (étapes) + edges (transitions conditionnelles). Plus structuré que ReAct pur, plus simple à debugger.

Installation.

pip install langgraph langchain-anthropic

Exemple agent simple LangGraph.

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated, Sequence
from langchain_core.messages import BaseMessage, HumanMessage, ToolMessage
from langchain_anthropic import ChatAnthropic
from langgraph.prebuilt import ToolNode

class AgentState(TypedDict):
    messages: Annotated[Sequence[BaseMessage], "messages"]

# Outils
def get_weather(city: str) -> str:
    return f"À {city} : 28°C, ensoleillé"

def get_orders(user_id: int) -> str:
    return f"Commandes user {user_id} : [50k, 32k, 15k]"

tools = [get_weather, get_orders]

# Modèle
model = ChatAnthropic(model="claude-sonnet-4-6-20250101").bind_tools(tools)

# Nodes
def call_model(state: AgentState):
    response = model.invoke(state["messages"])
    return {"messages": [response]}

def should_continue(state: AgentState):
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

# Build graph
workflow = StateGraph(AgentState)
workflow.add_node("agent", call_model)
workflow.add_node("tools", ToolNode(tools))
workflow.set_entry_point("agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_edge("tools", "agent")

app = workflow.compile()

# Usage
result = app.invoke({
    "messages": [HumanMessage(content="Météo Dakar et commandes user 42")]
})
print(result["messages"][-1].content)

Avantages LangGraph.
– Visualisation graphe (debug).
– État explicite et persistant (durabilité).
– Reprise après crash.
– Multi-modèle (switch facile entre Claude / OpenAI / Gemini).
– Streaming natif.

6. OpenAI Agents SDK

Installation.

pip install openai-agents

Exemple.

from openai_agents import Agent, Runner, tool

@tool
def get_weather(city: str) -> str:
    """Récupère la météo d'une ville."""
    return f"À {city} : 28°C, ensoleillé"

@tool
def get_orders(user_id: int) -> str:
    """Liste les commandes d'un utilisateur."""
    return f"Commandes user {user_id} : [50k, 32k]"

agent = Agent(
    name="ServiceClient",
    instructions="Tu es un assistant service client. Utilise les outils pour répondre.",
    tools=[get_weather, get_orders],
    model="gpt-5"
)

result = Runner.run_sync(agent, "Météo Dakar et commandes user 42")
print(result.final_output)

Forces.
– Décorateur @tool simple.
– Threads et persistance natifs (Assistants API).
– Multi-agent handoffs.

7. Multi-agent collaboration

Pattern multi-agent. Plusieurs agents spécialisés collaborent : researcher, writer, reviewer, etc.

Exemple LangGraph multi-agent.

from langgraph.graph import StateGraph

# Agent Chercheur
research_agent = create_research_agent(tools=[search_web, search_internal_docs])

# Agent Rédacteur
writer_agent = create_writer_agent()

# Agent Reviewer
reviewer_agent = create_reviewer_agent()

workflow = StateGraph(...)
workflow.add_node("research", research_agent)
workflow.add_node("write", writer_agent)
workflow.add_node("review", reviewer_agent)

workflow.set_entry_point("research")
workflow.add_edge("research", "write")
workflow.add_edge("write", "review")

# Loop si reviewer demande révisions
workflow.add_conditional_edges(
    "review",
    lambda state: "write" if state["needs_revision"] else END
)

Cas d’usage multi-agent.
– Génération article de blog (research → write → review).
– Customer support escalation (triage → agent spécialisé → manager).
– Code generation (architect → coder → tester).
– Data analysis (extractor → analyzer → reporter).

Limites.
– Latence cumulée (somme des agents).
– Coût multiplié.
– Risque drift (agents qui partent en boucle).
– Debug complexe.

Recommandation. Multi-agent uniquement si vraiment justifié. Souvent un agent unique avec sub-tasks suffit.

8. Cas d’usage PME

Agent qualification leads.
– Lead form → agent recherche LinkedIn + site → enrichissement → scoring → CRM.
– Outils : Apollo/Clay APIs, fetch_url, HubSpot API.

Agent service client niveau 1.
– Question utilisateur → RAG FAQ + docs → réponse personnalisée.
– Si non résolu → escalation humain via Slack.
– Outils : RAG search, get_user_orders, create_ticket.

Agent veille concurrentielle quotidienne.
– Cron quotidien → scan sources définies → extraction insights → email rapport.
– Outils : scrape_url, summarize, send_email.

Agent recherche documents internes.
– Question équipe → RAG sur Notion / Drive → réponse structurée.
– Outils : RAG search, fetch_doc, summarize.

Agent traitement factures fournisseurs.
– Email avec PDF facture → OCR → extraction → vérification → ERP.
– Outils : ocr_pdf, extract_data, validate, post_to_erp.

Agent code review.
– PR ouverte → analyse diff → suggestions → commentaires.
– Outils : github_get_pr, fetch_files, analyze, github_comment.

9. Production : latence, fiabilité, coût

Latence.
– Agent simple (2-3 tool calls) : 5-15 secondes.
– Agent complexe (5-10 tool calls) : 20-60 secondes.
– Multi-agent : 30 secondes – 5 minutes.
– Streaming essentiel pour UX (afficher actions en cours).

Fiabilité.
– Taux succès typique 70-90 % en production.
– Validation humaine sur actions critiques (financier, juridique).
– Retry automatique sur échecs transitoires (API 5xx).
– Circuit breaker si tool échoue répétitivement.

Coût.
– Agent simple : 5-15× coût d’un appel LLM seul (multiples calls + tools).
– Agent complexe : 50-200× plus cher.
– Optimisations : prompt caching, modèle adapté, eviction history long.

Monitoring obligatoire.
– Trace de chaque step (tool calls, args, results).
– Alerts sur taux échec.
– Coût par requête mesurable.
– Outils : LangSmith, Langfuse, Helicone, Datadog AI.

Évaluation continue.
– Dataset de tests représentatifs.
– Replay automatique régulier.
– Comparaison versions.

Sécurité.
– Tools sensibles (write DB, send email) → validation humaine ou allowlist.
– Logging actions pour audit.
– Permissions minimales par tool.
– Rate limiting agent.

10. Pièges fréquents

Boucle infinie. Agent appelle même tool indéfiniment. max_iterations strict.

Pas de timeout. Agent peut tourner 10 min, freeze user. Timeout global 60 sec typique.

Tools mal décrits. L’agent choisit mal quel tool quand. Descriptions précises et différenciatrices.

Schema d’input flou. L’agent envoie args mal formés. JSON schema strict avec required.

Pas de validation outputs. Agent retourne hallucinations. LLM-as-judge ou règles de validation.

Modèle trop léger. Haiku ou GPT-5 nano sur agent complexe = decisions médiocres. Sonnet 4.6 minimum pour agents non triviaux.

Pas de logging. Debug impossible quand ça échoue. Trace complète obligatoire.

Tools dangereux sans confirmation. Send email, write DB, delete files = validation humaine.

Coût non monitoré. Agent qui boucle = facture explosive. Alerts spending obligatoires.

Pas de fallback. Tool échoue → agent crash. Try/catch + plan B.

Trop de tools. 30 tools dans le prompt = confusion. Limiter à 5-10 vraiment pertinents.

FAQ

Quel framework agent choisir en 2026 ?

Claude Agent SDK pour stack Anthropic, OpenAI Agents SDK pour stack OpenAI, LangGraph pour multi-modèle ou agnostique. Pour démarrer simple : tool use direct via API sans framework, puis LangGraph dès que la complexité justifie.

Combien coûte un agent IA en production ?

Agent simple : 0,02-0,10 USD par requête. Agent complexe avec multi-step : 0,10-0,50 USD par requête. Multi-agent : 0,50-3 USD par requête. À multiplier par volume mensuel pour budget.

Comment garantir qu’un agent ne fait pas n’importe quoi ?

1) Tools allowlist strict avec validation côté serveur, 2) Validation humaine sur actions critiques, 3) Rate limiting, 4) Logging et monitoring complets, 5) Tests sur dataset représentatif avant prod, 6) Timeout et max_iterations.

Multi-agent vraiment nécessaire ?

Rarement pour PME. Un agent unique avec tools bien définis suffit dans 80 % des cas. Multi-agent pour workflows vraiment complexes (recherche → écriture → review avec révisions multiples) où la spécialisation apporte qualité mesurable.

Latence acceptable pour agent en UI ?

< 5 sec : excellent. 5-15 sec : acceptable avec streaming. 15-30 sec : limite haute, à signaler à l’utilisateur. >30 sec : préférer mode asynchrone (job queue + notification).

Comment debugger un agent qui foire ?

LangSmith, Langfuse, ou logs custom : voir step-by-step exactement quels tools ont été appelés avec quels args et quels résultats. Isoler step problématique. Tester ce step isolément. Ajuster prompt ou tool description.

Claude Agent SDK vs OpenAI Agents SDK ?

Claude Agent SDK : meilleur sur agents long-running, sub-agents, MCP. OpenAI Agents SDK : meilleure intégration Threads et Assistants API. Choix selon stack existante et préférence modèle. Performance brute proche en 2026 pour la majorité des cas.

Peut-on faire des agents avec des modèles open-source ?

Oui, Llama 4, Qwen 3, DeepSeek R1 supportent function calling. Performance souvent en deçà de Claude/GPT-5 sur agents complexes mais utilisable pour cas simples + souveraineté. LangGraph multi-modèle facilite l’expérimentation.

Articles liés (cluster IA générative avancée)

Voir aussi : MCP servers tutoriel développeur, Claude Code tutoriel pratique, Python pour PME guide complet, Automatisation no-code PME guide.

Article mis à jour le 26 avril 2026. Pour signaler une erreur ou suggérer une amélioration, écrivez-nous.