Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Architecture des agents : la boucle raisonnement-outil

Oppitunti 2 / 25 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Architecture des agents : la boucle raisonnement-outil
  2. Le cycle de vie de l’agent
  3. Structure interne : éléments et messages
  4. Appels parallèles vs séquentiels
  5. Le paramètre max_turns
  6. Keskeiset asiat

Mis à jour le 3 novembre 2026 : Dans rechercher_produit, les clés prix et stock n’étaient pas entre guillemets, ce qui provoquait une NameError lors du premier appel d’outil.

Architecture des agents : la boucle raisonnement-outil

Pour créer des agents efficaces, tu dois comprendre leur architecture interne. Un agent OpenAI fonctionne selon une boucle de raisonnement : il reçoit une tâche, réfléchit, utilise un outil, observe le résultat, puis décide s’il a terminé ou s’il doit continuer. Tout ce que tu feras ensuite – déclarer des outils, définir des garde-fous, orchestrer plusieurs agents – repose sur cette boucle.

Le cycle de vie de l’agent

Chaque exécution suit six étapes :

  1. Réception : L’agent reçoit le message de l’utilisateur et les instructions système.
  2. Raisonnement : Le modèle analyse la demande et décide de la prochaine action.
  3. Appel d’outil : Si nécessaire, l’agent appelle un ou plusieurs outils.
  4. Observation : L’agent reçoit les résultats des outils.
  5. Décision : L’agent décide de continuer (retour à l’étape 2) ou de répondre.
  6. Réponse : L’agent produit sa réponse finale.

La clé réside dans la boucle entre les étapes 2 et 5, qui peut s’exécuter plusieurs fois. Un agent peut enchaîner 5, 10, voire 20 appels d’outils avant de produire une réponse finale, sans que tu n’écrives une seule ligne de code d’orchestration. L’exemple ci-dessous illustre cela : deux outils indépendants sont déclarés, et le modèle décide comment les enchaîner.

from agents import Agent, Runner, function_tool

@function_tool
def rechercher_produit(nom: str) -> str:
    """Searches for a product in the catalog."""
    # Simulation - in production, call your database
    catalogue = {
        "laptop-pro": {"prix": 1299, "stock": 45},
        "tablet-air": {"prix": 599, "stock": 120},
    }
    produit = catalogue.get(nom)
    if produit:
        return f"Produit {nom}: {produit['prix']}€, stock: {produit['stock']}"
    return f"Produit {nom} non trouvé"

@function_tool
def calculer_remise(prix: float, pourcentage: float) -> str:
    """Calculates the price after discount."""
    prix_final = prix * (1 - pourcentage / 100)
    return f"Prix après {pourcentage}% de remise : {prix_final:.2f}€"

agent = Agent(
    name="Sales Agent",
    instructions="You help customers find products and calculate discounts.",
    tools=[rechercher_produit, calculer_remise],
    model="gpt-5.6-terra",
)

# The agent will: 1) find the product, 2) calculate the discount, 3) respond
result = Runner.run_sync(
    agent,
    "What is the price of the laptop-pro with a 15% discount?"
)
print(result.final_output)

La question nécessite deux opérations qui ne sont pas explicitement liées dans le code. L’agent effectue automatiquement deux appels d’outils séquentiels : d’abord rechercher_produit, puis calculer_remise avec le prix récupéré. Cet enchaînement est une décision du modèle, pas ton instruction.

Structure interne : éléments et messages

L’API Responses structure chaque interaction sous forme d’éléments (items). Les lire te montre ce que ton agent a réellement fait. Trois types apparaissent dans la conversation :

  • message : un message texte (de l’utilisateur ou de l’agent)
  • function_call : un appel d’outil décidé par l’agent
  • function_call_output : le résultat renvoyé par l’outil
result = Runner.run_sync(agent, "Find the tablet-air")

# Inspect the reasoning steps
for item in result.raw_responses:
    print(f"Type: {type(item).__name__}")
    # You'll see: message input → function_call → function_call_output → message output

Prends l’habitude de tracer cette boucle chaque fois qu’un agent produit une réponse surprenante. Neuf fois sur dix, l’anomalie se trouve dans un function_call avec des arguments inattendus.

Appels parallèles vs séquentiels

Toutes les étapes ne dépendent pas les unes des autres. Lorsque deux appels sont indépendants, l’agent peut décider de les exécuter en parallèle.

@function_tool
def obtenir_meteo(ville: str) -> str:
    """Gets the current weather for a city."""
    meteos = {"Paris": "18°C, sunny", "Lyon": "16°C, cloudy"}
    return meteos.get(ville, "Data unavailable")

agent = Agent(
    name="Travel Agent",
    instructions="You help plan trips.",
    tools=[obtenir_meteo, rechercher_produit],
    model="gpt-5.6-terra",
)

# The agent will call obtenir_meteo("Paris") and obtenir_meteo("Lyon") in parallel
result = Runner.run_sync(
    agent,
    "What's the weather in Paris and Lyon?"
)

La météo à Lyon ne dépend pas de celle de Paris : le SDK gère automatiquement le parallélisme et lance les deux appels simultanément, réduisant ainsi la latence. Compare cela avec l’exemple de vente précédent, où le calcul de la remise devait attendre le prix : ici, la séquence s’impose d’elle-même.

Le paramètre max_turns

Une boucle autonome peut, dans le pire des cas, ne jamais s’arrêter : l’agent appelle un outil, le résultat le pousse à en appeler un autre, et ainsi de suite. La sauvegarde tient en un seul paramètre.

result = Runner.run_sync(
    agent,
    "Full catalog analysis",
    max_turns=10  # Maximum 10 loop iterations
)

Si l’agent atteint la limite, il s’arrête avec les résultats obtenus jusqu’alors. En production, c’est une sécurité essentielle : cela plafonne à la fois le temps de réponse et le coût.

Keskeiset asiat

  • Un agent fonctionne en boucle : raisonnement → outil → observation → décision
  • Cette boucle peut s’exécuter plusieurs fois avant de produire une réponse
  • Le modèle décide automatiquement quels outils appeler et dans quel ordre
  • Les appels d’outils indépendants s’exécutent en parallèle
  • max_turns limite le nombre d’itérations par sécurité