Le SDK Agent d’OpenAI est un framework open source léger qui transforme les modèles de langage en agents autonomes capables d’invoquer des outils externes, de collaborer entre eux et d’exécuter des workflows en plusieurs étapes. À son cœur se trouvent trois concepts — Agent, Tool et Runner — qui vous permettent de définir les consignes d’un agent, d’enregistrer des fonctions utilitaires ou des API, et de piloter la boucle de raisonnement sans vous soucier de l’historique des messages ou du code d’appel de fonction.
Dans ce tutoriel, vous créerez d’abord un agent unique « Math Tutor » pour répondre à des questions arithmétiques, puis vous l’enrichirez avec un outil « Currency Checker » pour récupérer des taux de change en temps réel. Nous montrerons comment chaîner des agents via des transferts programmatiques et agentiques (speech-to-text → summariser ; Tier-1 → Tier-2 support), comment diriger les requêtes vers plusieurs agents spécialistes, et enfin comment traiter un agent comme un outil appelable dans un schéma planner→executor pour générer des itinéraires de voyage détaillés. À la fin, vous verrez comment quelques primitives débloquent des applications IA puissantes et collaboratives.
Une armée d’agents IA à votre disposition
Certaines bibliothèques empilent les abstractions si haut qu’il faut une corde de sécurité pour les gravir. Le SDK Agent d’OpenAI emprunte la voie inverse : il conserve un modèle mental léger et transparent tout en vous permettant de construire des workflows multi-agents robustes.
Ce que nous allons voir ici
- Un agent math-tutor qui résout des problèmes arithmétiques.
- Un agent currency-checker qui interroge une API de taux de change.
- Un transfert (« hand-off ») d’un agent speech-to-text vers un agent summariser.
- Un flux d’assistance passant de la prise en charge Tier-1 à Tier-2.
- L’utilisation d’un agent translator strictement comme outil interne.
- Un schéma hiérarchique planner → executor pour générer des itinéraires de voyage détaillés.
1 · Agent unique « Math Tutor »
Lorsque vous posez une question, elle est envoyée directement à l’Agent, qui ajoute ses instructions avant de la transmettre au LLM. Le LLM répond — en utilisant les outils nécessaires en cours de route — et l’Agent formate cette réponse pour la renvoyer à l’utilisateur. Vous obtenez ainsi une seule réponse claire, même si plusieurs étapes ont été exécutées en coulisses. Le chemin des données est simple : utilisateur → agent → LLM → agent → utilisateur.
import asyncio
from agents import Agent, Runner
math_agent = Agent(
name="Math Tutor",
instructions=(
"Vous êtes un tuteur amical. Fournissez la réponse au calcul arithmétique "
"demandé et expliquez brièvement les étapes en un court paragraphe."
),
)
async def run(question: str):
result = await Runner.run(math_agent, question)
return result.final_output
if __name__ == "__main__":
q = input("Posez une question de maths : ")
print(asyncio.run(run(q)))
Exécutez le script, tapez 17*23, et l’agent expliquera la multiplication avant de donner 391.
2 · Ajout d’un outil : « Currency Checker »
Les outils permettent à un agent d’interroger des services externes. Ici, l’outil appelle un endpoint REST pour récupérer le taux EUR → USD du jour.
import httpx, asyncio
from agents import Agent, Runner, function_tool
@function_tool
def eur_usd_rate() -> str:
# Retourne le taux EUR→USD du jour sous forme de texte.
data = httpx.get(
"https://api.exchangerate.host/convert", params={"from": "EUR", "to": "USD"}
).json()
return f"1 EUR ≈ {data['result']:.2f} USD"
fx_agent = Agent(
name="Currency Checker",
instructions="Utilisez l’outil pour répondre à toute question sur la valeur EUR/USD aujourd’hui.",
tools=[eur_usd_rate],
)
print(Runner.run_sync(fx_agent, "Que valent 50 EUR en dollars ?").final_output)
3 · Transfert programmatique
Imaginez deux mini-applications successives : vous envoyez d’abord un texte phonétique à l’agent « Speech-to-Text », qui renvoie une transcription en anglais standard. Plutôt que de renvoyer tout l’historique interne, vous prenez simplement cette transcription et la transmettez à l’agent « Summariser ». C’est comme prendre un sandwich préparé d’une station et le passer à la suivante pour la découpe : pas besoin de transporter des données superflues.
from agents import Agent, Runner
import asyncio
stt_agent = Agent(
name="Speech-to-Text",
instructions="Transcrivez la phrase phonétique en anglais courant.",
)
summary_agent = Agent(
name="Summariser",
instructions="Résumez le texte donné en une seule phrase.",
)
async def go(audio):
text = await Runner.run(stt_agent, audio)
summary = await Runner.run(summary_agent, text.final_output)
return summary.final_output
print(asyncio.run(go("wun smol step fer man")))
4 · Transfert agentique (Tier-1 → Tier-2)
C’est comme un service client : vous parlez d’abord à l’agent « Tier-1 ». S’il peut répondre (mot de passe oublié, question courante), il vous répond directement. Si vous évoquez un problème complexe (facturation ou réseau), il fait appel à l’expert « Tier-2 » en lui fournissant toute la conversation. Ainsi, Tier-2 voit exactement ce qui a été dit et reprend immédiatement là où Tier-1 s’est arrêté.
from agents import Agent, Runner
senior = Agent(
name="Tier-2 Support",
instructions="Résolvez les problèmes de facturation ou de réseau avancés avec tout le contexte.",
)
tier1 = Agent(
name="Tier-1 Support",
instructions=(
"Répondez aux questions courantes. Si l’utilisateur mentionne une "
"anomalie de facturation ou des déconnexions VPN, transférez à Tier-2 Support."
),
handoffs=[senior],
)
print(Runner.run_sync(tier1, "Mon VPN se déconnecte tout le temps et ma facture est erronée !").final_output)
5 · Routage vers plusieurs agents
Ajoutez des agents Billing, Connectivity et General-Info à la liste handoffs ; Tier-1 sélectionnera automatiquement le spécialiste approprié. Le code reste identique, seule la liste des hand-offs change.
6 · Agents comme outils : planner → executor
Imaginez que vous esquissiez un itinéraire : « Jour 1 : quartier historique », « Jour 2 : plage », « Jour 3 : marchés ». C’est votre agent Planner. Au lieu de rédiger vous-même chaque détail, vous transmettez chaque point à l’agent Executor comme s’il s’agissait d’un outil. L’Executor transforme le point en 2–3 phrases vivantes, conseils locaux et astuces.
from agents import Agent, Runner
executor = Agent(
name="Itinerary Step Writer",
instructions="Développez une puce en 2–3 phrases dynamiques pour voyageurs à petit budget.",
)
planner = Agent(
name="Trip Planner",
instructions=(
"Élaborez un itinéraire de 3 jours. Pour chaque point, appelez l’outil write_step "
"pour l’enrichir, puis renvoyez le markdown final."
),
tools=[executor.as_tool(
tool_name="write_step", tool_description="Enrichir un point d’itinéraire"
)],
)
print(Runner.run_sync(planner, "Planifiez trois jours à Lisbonne").final_output)
Sorties structurées
Pour garantir une réponse JSON bien formée, fournissez un modèle Pydantic via output_type. Le SDK validera et convertira automatiquement la sortie.
Avec seulement trois primitives — Agent, Tool et Runner — vous pouvez orchestrer des workflows multi-agents complexes :
- Boucles à agent unique
- Invocation d’outils externes
- Transferts programmatiques vs agentiques
- Routage et escalade multi-agents
- Réutilisation d’agents comme outils
Par défaut, le SDK utilise l’API Responses d’OpenAI, mais une seule ligne permet de passer à l’API Chat Completions — et donc à tout LLM compatible :
from agents import set_default_openai_api
set_default_openai_api("chat_completions")
Mistral, Anthropic ou votre propre modèle — vous êtes prêt à construire la prochaine grande application multi-agents. Bon codage ! ✨