OpenAI Agents SDK : Un cadre Python pour la construction de flux de travail collaboratifs multi-intelligents

Introduction générale

Le SDK OpenAI Agents est un outil de développement léger d'OpenAI conçu pour construire des flux de travail multi-intelligents. Basé sur Python, il est facile à prendre en main et permet aux développeurs d'automatiser des tâches complexes en configurant des agents, des Handoffs, des Guardrails et du Tracing. Par exemple, vous pouvez l'utiliser pour créer un assistant qui écrit du code ou un système intelligent qui gère les interactions multilingues. Le point fort est sa compatibilité et sa flexibilité avec tous les fournisseurs de modèles qui supportent le format de l'API OpenAI Chat Completions. Une documentation détaillée et des exemples de code sont officiellement fournis pour permettre aux développeurs de tous niveaux de démarrer rapidement.

Liste des fonctions

• Personnalisation intelligente du corps: Définir des commandes, des outils et des restrictions pour les modèles linguistiques afin de créer des assistants intelligents exclusifs.
• Changement de tâcheL'assistant anglais permet de passer d'une intelligence à l'autre en toute transparence, par exemple en passant de l'assistant anglais à l'assistant espagnol.
• certification de sécuritéLes contrôles d'entrée et de sortie intégrés garantissent des résultats sûrs et fiables.
• Suivi opérationnelLa fonction d'enregistrement automatique du processus de fonctionnement de l'organisme intelligent permet de faciliter le débogage et l'optimisation.
• Extension de l'outil: Permet l'ajout d'outils personnalisés, tels que la vérification de la météo ou le traitement de tâches spécifiques.
• compatibilité des modèlesLes fournisseurs de modèles multiples sont pris en charge, à condition qu'ils se conforment au format de l'API OpenAI.

Utiliser l'aide

Processus d'installation

Pour utiliser le SDK OpenAI Agents, vous devez d'abord créer un environnement Python. Voici les étapes à suivre :

1. Créer un environnement virtuel
   Créez un environnement Python séparé pour éviter les conflits avec d'autres projets en entrant la commande suivante dans le terminal :

python -m venv env

Activez ensuite l'environnement :

• Fenêtres :env\Scripts\activate
• Systèmes Mac/Linux :source env/bin/activate

2. Installation du SDK
   Après avoir activé l'environnement, exécutez la commande suivante pour installer le SDK :

pip install openai-agents

3. Configuration des clés API
   Avant d'exécuter le code, vous devez définir la clé API OpenAI. Saisissez-la dans le terminal :

export OPENAI_API_KEY='你的密钥'

Ou chargez-la dans le code via une variable d'environnement. Veillez à sécuriser la clé.

Une fois que vous avez terminé les étapes ci-dessus, vous êtes prêt à utiliser l'outil.

Comment l'utiliser

Au cœur du SDK des agents OpenAI se trouvent Agent répondre en chantant Runner Classe.Agent utilisée pour définir le comportement des intelligences.Runner Responsable de l'exécution et du retour des résultats. Voici une description détaillée du fonctionnement des principales fonctions.

1. créer un assistant intelligent de base

Vous voulez commencer rapidement ? Essayez cet exemple simple d'un corps intelligent qui écrit un haïku sur la programmation :

from agents import Agent, Runner
agent = Agent(name="Assistant", instructions="You are a helpful assistant")
result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)

procédure: :

• Créer un renseignement, définir le nom et les instructions.
• dépense ou frais Runner.run_sync Synchronisez l'exécution et saisissez les exigences de la tâche.
• En l'exécutant, vous obtiendrez quelque chose comme "Code dans le code, la fonction s'appelle elle-même, danse de la boucle infinie".

2. activer le changement de tâche

Le changement de tâche est une fonctionnalité du SDK qui permet à plusieurs intelligences de collaborer. Par exemple, le traitement des demandes multilingues :

from agents import Agent, Runner
import asyncio
spanish_agent = Agent(name="Spanish agent", instructions="You only speak Spanish.")
english_agent = Agent(name="English agent", instructions="You only speak English.")
triage_agent = Agent(
name="Triage agent",
instructions="Handoff to the appropriate agent based on the language of the request.",
handoffs=[spanish_agent, english_agent],
)
async def main():
result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())

procédure: :

• Définir les intelligences multiples, chacune avec des instructions spécifiques.
• Création de l'intelligence primaire (triage_agent), et de spécifier des intelligences commutables.
• dépense ou frais Runner.run Exécution asynchrone et saisie des questions espagnoles.
• Le corps intelligent principal change en fonction de la langue. spanish_agentet de répondre quelque chose comme "¡Hola ! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás ?".

3. ajouter des outils personnalisés

Vous pouvez utiliser le function_tool Définir des outils qui permettent aux intelligences d'appeler des fonctions externes. Par exemple, vérifier le temps qu'il fait :

from agents import Agent, Runner, function_tool
@function_tool
def get_weather(city: str) -> str:
return f"The weather in {city} is sunny."
agent = Agent(
name="Weather agent",
instructions="You are a helpful agent.",
tools=[get_weather],
)
async def main():
result = await Runner.run(agent, input="What's the weather in Tokyo?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())

procédure: :

• Définir une fonction avec @function_tool Décoration.
• Ajouter des outils à la panoplie d'un organisme intelligent tools Paramètres.
• Après avoir fonctionné, la société intelligente appelle l'outil et renvoie le message suivant : "Le temps à Tokyo est ensoleillé".

4. utilisation du suivi de la course

Le SDK dispose d'une fonction de suivi intégrée qui enregistre les détails des actions du corps intelligent à chaque exécution. Vous pouvez en savoir plus sur le fonctionnement du corps intelligent en utilisant la fonction result Objets permettant de visualiser les processus en cours ou d'intégrer des outils externes (par exemple Logfire) à des fins d'analyse. Fonctionne par défaut sans paramètres supplémentaires.

5) Mise en place de l'authentification de sécurité

La validation de la sécurité (Guardrails) peut vérifier les entrées et les sorties. Par exemple, empêcher un utilisateur de faire faire ses devoirs de mathématiques par un corps intelligent :

from agents import Agent, Runner, input_guardrail
from pydantic import BaseModel
class MathCheck(BaseModel):
is_math_homework: bool
reasoning: str
guardrail_agent = Agent(
name="Guardrail check",
instructions="Check if the user is asking you to do their math homework.",
output_type=MathCheck,
)
@input_guardrail
async def math_guardrail(ctx, agent, input):
result = await Runner.run(guardrail_agent, input)
return GuardrailFunctionOutput(
output_info=result.final_output,
tripwire_triggered=result.final_output.is_math_homework,
)
agent = Agent(
name="Support agent",
instructions="Help customers with their questions.",
input_guardrails=[math_guardrail],
)
async def main():
try:
await Runner.run(agent, "Can you solve 2x + 3 = 11?")
except Exception as e:
print("Guardrail stopped the request")

procédure: :

• Définir une intelligence de garde qui vérifie l'entrée.
• dépense ou frais @input_guardrail Créer des fonctions de garde.
• Ajoutez les gardiens à l'intelligence principale. L'exécution est interrompue si l'entrée implique un travail mathématique.

Détails du processus d'opération

• circulation intelligente: Appel Runner.run() Dans ce cas, le SDK exécute les étapes suivantes :
  1. Invoquer le modèle linguistique pour générer une réponse.
  2. Vérifier les appels d'outils ou les changements de tâches.
  3. Exécuter l'appel d'outil et enregistrer les résultats.
  4. S'il existe un commutateur de tâches, il faut passer au nouveau corps intelligent.
  5. Boucle jusqu'à ce que la sortie finale soit générée, ou jusqu'à ce que l'option max_turns Cap.
• Type de sortieSi vous réglez l'option output_typel'intelligence génère une sortie structurée du type spécifié ; dans le cas contraire, la réponse au premier appel ou commutateur sans outil constitue la sortie finale.

Recommandations d'utilisation

• ajuster les composants pendant les essaisLes résultats de l'analyse de l'information sont présentés en détail grâce à la fonction de suivi, ce qui permet de repérer rapidement les problèmes.
• optimisationLes services de l'État : mis en place en fonction des besoins de la mission max_turnsen évitant de faire trop de vélo.
• extensionsRéférence à des documents officiels examples pour explorer d'autres utilisations.

Documentation officielle : https://openai.github.io/openai-agents-python/