Lorsque vous travaillez avec des modèles de langage, obtenir de bonnes performances nécessite souvent un bon prompt et les bons outils. Cependant, la gestion de plusieurs flux uniques peut devenir complexe. Ce guide introduit les concepts de routines et de transferts, démontrant comment ils peuvent être utilisés pour orchestrer plusieurs agents de manière simple, puissante et contrôlable.

Configuration de l'environnement

Pour commencer, assurez-vous d'avoir les imports et la configuration client nécessaires.

from openai import OpenAI
from pydantic import BaseModel
from typing import Optional
import json
 
client = OpenAI()

Comprendre les routines

Une "routine" est un ensemble d'étapes définies en langage naturel, représentées par un prompt système, ainsi que les outils nécessaires pour les accomplir. Par exemple, une routine de service client pourrait impliquer le triage d'un problème utilisateur, la suggestion d'une solution ou le traitement d'un remboursement.

system_message = (
    "Vous êtes un agent de support client pour ACME Inc."
    "Répondez toujours en une phrase ou moins."
    "Suivez la routine suivante avec l'utilisateur :"
    "1. D'abord, posez des questions d'approfondissement et comprenez mieux le problème de l'utilisateur."
    " - sauf si l'utilisateur a déjà fourni une raison."
    "2. Proposez une solution (inventez-en une)."
    "3. UNIQUEMENT si non satisfait, offrez un remboursement."
    "4. Si accepté, recherchez l'ID puis exécutez le remboursement."
)

Exécution des routines

Pour exécuter une routine, implémentez une boucle qui gère les entrées utilisateur, ajoute les messages et appelle le modèle.

def run_full_turn(system_message, messages):
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": system_message}] + messages,
    )
    message = response.choices[0].message
    messages.append(message)
 
    if message.content: print("Assistant:", message.content)
 
    return message

Gestion des appels de fonction

Les modèles nécessitent que les fonctions soient formatées comme un schéma de fonction. Définissez une fonction helper pour convertir les fonctions Python en schéma de fonction correspondant.

import inspect
 
def function_to_schema(func) -> dict:
    type_map = {
        str: "string",
        int: "integer",
        float: "number",
        bool: "boolean",
        list: "array",
        dict: "object",
        type(None): "null",
    }
 
    try:
        signature = inspect.signature(func)
    except ValueError as e:
        raise ValueError(
            f"Échec de l'obtention de la signature pour la fonction {func.__name__}: {str(e)}"
        )
 
    parameters = {}
    for param in signature.parameters.values():
        try:
            param_type = type_map.get(param.annotation, "string")
        except KeyError as e:
            raise KeyError(
                f"Annotation de type inconnue {param.annotation} pour le paramètre {param.name}: {str(e)}"
            )
        parameters[param.name] = {"type": param_type}
 
    required = [
        param.name
        for param in signature.parameters.values()
        if param.default == inspect._empty
    ]
 
    return {
        "type": "function",
        "function": {
            "name": func.__name__,
            "description": (func.__doc__ or "").strip(),
            "parameters": {
                "type": "object",
                "properties": parameters,
                "required": required,
            },
        },
    }

Implémenter les transferts

Les transferts permettent à un agent de transférer une conversation active à un autre agent, similaire à un transfert lors d'un appel téléphonique. Définissez une classe de base pour un Agent et modifiez le code pour supporter les transferts d'agent.

class Agent(BaseModel):
    name: str = "Agent"
    model: str = "gpt-4o-mini"
    instructions: str = "Vous êtes un Agent utile"
    tools: list = []
 
def run_full_turn(agent, messages):
    current_agent = agent
    num_init_messages = len(messages)
    messages = messages.copy()
 
    while True:
        tool_schemas = [function_to_schema(tool) for tool in current_agent.tools]
        tools = {tool.__name__: tool for tool in current_agent.tools}
 
        response = client.chat.completions.create(
            model=agent.model,
            messages=[{"role": "system", "content": current_agent.instructions}]
            + messages,
            tools=tool_schemas or None,
        )
        message = response.choices[0].message
        messages.append(message)
 
        if message.content:
            print(f"{current_agent.name}:", message.content)
 
        if not message.tool_calls:
            break
 
        for tool_call in message.tool_calls:
            result = execute_tool_call(tool_call, tools, current_agent.name)
 
            if type(result) is Agent:
                current_agent = result
                result = (
                    f"Transféré à {current_agent.name}. Adoptez la persona immédiatement."
                )
 
            result_message = {
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result,
            }
            messages.append(result_message)
 
    return Response(agent=current_agent, messages=messages[num_init_messages:])

Conclusion

En implémentant des routines et des transferts, vous pouvez gérer efficacement plusieurs agents, permettant une gestion dynamique des tâches et une efficacité améliorée. Cette approche fournit un cadre robuste pour orchestrer des workflows complexes.

Référence : Orchestrating Agents: Routines and Handoffs par Ilan Bigio, OpenAI.