L'IA en maître d'orchestre : Une introduction au kit de développement OpenAI Agents

Description du projet

Le SDK Agents d'OpenAI est une boîte à outils Python conçue pour créer des flux de travail multi-agents. Il est indépendant des fournisseurs, prenant en charge les API OpenAI Responses et Chat Completions, ainsi que plus d'une centaine d'autres grands modèles linguistiques (LLM). Le SDK mise sur une conception légère et des capacités solides pour orchestrer les interactions entre plusieurs agents.

Concepts clés : - Agents : Des LLM configurés avec des instructions, des outils, des garde-fous et des transferts spécifiques. - Transferts (Handoffs) : Un appel d'outil spécialisé utilisé pour transférer le contrôle entre différents agents. - Garde-fous (Guardrails) : Des vérifications de sécurité configurables pour valider les entrées et les sorties. - Traçage (Tracing) : Fonctionnalité intégrée pour suivre, déboguer et optimiser l'exécution des agents.

Instructions d'utilisation

1. Configurez votre environnement Python :

python -m venv env
source env/bin/activate

2. Installez le SDK Agents :

pip install openai-agents

pip install 'openai-agents[voice]'

3. Exemple "Hello World" : Pour exécuter un agent basique :

from agents import Agent, Runner

agent = Agent(name="Assistant", instructions="Vous êtes un assistant utile")

result = Runner.run_sync(agent, "Écrivez un haïku sur la récursivité en programmation.")
print(result.final_output)

4. Exemple de transferts (Handoffs) : Pour démontrer les transferts d'agents basés sur la langue :

from agents import Agent, Runner
import asyncio

spanish_agent = Agent(
    name="Agent espagnol",
    instructions="Vous ne parlez qu'espagnol.",
)

english_agent = Agent(
    name="Agent anglais",
    instructions="Vous ne parlez qu'anglais",
)

triage_agent = Agent(
    name="Agent de triage",
    instructions="Transférez à l'agent approprié en fonction de la langue de la requête.",
    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())

5. Exemple de fonctions : Pour intégrer des fonctions personnalisées comme outils pour les agents :

import asyncio
from agents import Agent, Runner, function_tool

@function_tool
def get_weather(city: str) -> str:
    return f"La météo à {city} est ensoleillée."

agent = Agent(
    name="Bonjour le monde",
    instructions="Vous êtes un agent serviable.",
    tools=[get_weather],
)

async def main():
    result = await Runner.run(agent, input="Quel temps fait-il à Tokyo ?")
    print(result.final_output)

if __name__ == "__main__":
    asyncio.run(main())

Développement (pour contribuer au SDK) : 1. Assurez-vous que uv est installé. 2. Installez les dépendances : make sync 3. Exécutez les vérifications (lint/test) : make tests, make mypy, make lint

Fonctionnalités clés

• Flux de travail multi-agents : Un cadre de travail pour concevoir des interactions complexes entre plusieurs agents LLM.
• Indépendant des fournisseurs : Prise en charge des API OpenAI et de plus de 100 autres LLM.
• Configuration des agents : Les agents peuvent être configurés avec des instructions, des outils, des garde-fous et des transferts.
• Mécanisme de transfert (Handoff) : Appels d'outils spécialisés pour un transfert de contrôle fluide entre agents.
• Garde-fous : Implémentation de vérifications de sécurité configurables pour la validation des entrées et sorties.
• Traçage intégré : Suivi et débogage automatiques de l'exécution des agents, avec extensibilité pour des segments personnalisés et des destinations externes (par exemple, Logfire, AgentOps, Braintrust).
• Sorties structurées : Prend en charge la définition d'un output_type pour que les agents produisent des sorties finales structurées.
• Boucle d'agent flexible : S'exécute jusqu'à ce qu'une sortie finale soit produite, gérant les appels d'outils et les transferts de manière itérative, avec un paramètre max_turns pour le contrôle.
• Intégration d'outils : Permet aux agents d'utiliser des fonctions personnalisées comme outils.

Utilisateurs cibles

• Développeurs créant des applications d'IA multi-agents.
• Chercheurs et praticiens travaillant avec les LLM et les flux de travail d'IA.
• Utilisateurs ayant besoin d'orchestrer des tâches complexes impliquant plusieurs agents IA.

Liens du projet

• Dépôt GitHub : https://github.com/openai/openai-agents-python
• Documentation : openai.github.io/openai-agents-python/

Scénarios d'application

• Extraction et traitement complexes d'information : Les agents peuvent collaborer pour extraire, traiter et résumer des informations provenant de diverses sources.
• Service client automatisé : Un agent de triage peut diriger les requêtes vers des agents spécialisés, ou des agents peuvent gérer différentes étapes de l'interaction client (par exemple, accueil initial, diagnostic du problème, proposition de solution).
• Génération et débogage de code : Les agents peuvent être spécialisés pour différents langages de programmation ou tâches de débogage, avec des transferts se produisant au besoin.
• Flux de travail de création de contenu : Les agents peuvent collaborer à la rédaction, à l'édition et à l'affinage de contenu créatif, avec des garde-fous assurant le respect des guides de style ou des protocoles de sécurité.
• Analyse de données et rapports : Les agents peuvent se voir attribuer des rôles pour la récupération, l'analyse, la visualisation et la génération de rapports de données.
• Tutoriels interactifs et environnements d'apprentissage : Les agents peuvent guider les utilisateurs à travers les étapes, fournir des commentaires et adapter leurs réponses en fonction des entrées ou des progrès de l'utilisateur.