OpenAI Swarm - Présentation détaillée du framework d'orchestration multi-agents

Aperçu du projet

OpenAI Swarm est un framework éducatif conçu pour explorer l'orchestration multi-agents légère et ergonomique. Ce projet, géré par l'équipe des solutions d'OpenAI, vise à fournir aux développeurs un outil simple, flexible et contrôlable pour la construction de systèmes multi-agents.

Mise à jour importante: Swarm a été remplacé par le SDK OpenAI Agents, qui est une version prête pour la production de Swarm. L'équipe OpenAI recommande à tous les cas d'utilisation en production de migrer vers le SDK Agents.

Caractéristiques principales

1. Philosophie de conception

• Léger: Axé sur la simplicité et la facilité d'utilisation
• Hautement contrôlable: Fournit des mécanismes de contrôle précis des agents
• Facile à tester: Prend en charge des processus de test et de débogage simples
• Orienté vers l'éducation: Sert de ressource éducative pour l'apprentissage de l'orchestration multi-agents

2. Concepts d'abstraction fondamentaux

Swarm réalise la coordination des agents grâce à deux abstractions fondamentales :

Agent (Agent)

• Contient des instructions et des outils
• Peut transférer la conversation à un autre agent à tout moment
• Prend en charge les instructions dynamiques et les variables de contexte

Handoffs (Transferts)

• Mécanisme de transition transparente entre les agents
• Prend en charge les réseaux et les flux de travail complexes d'agents
• Maintient la continuité de la conversation

Installation et utilisation de base

Configuration système requise

• Python 3.10+

Méthode d'installation

pip install git+ssh://git@github.com/openai/swarm.git
# Ou
pip install git+https://github.com/openai/swarm.git

Exemple de base

from swarm import Swarm, Agent

client = Swarm()

def transfer_to_agent_b():
    return agent_b

agent_a = Agent(
    name="Agent A",
    instructions="You are a helpful agent.",
    functions=[transfer_to_agent_b],
)

agent_b = Agent(
    name="Agent B",
    instructions="Only speak in Haikus.",
)

response = client.run(
    agent=agent_a,
    messages=[{"role": "user", "content": "I want to talk to agent B."}],
)

print(response.messages[-1]["content"])

Exemple de sortie :

Hope glimmers brightly,
New paths converge gracefully,
What can I assist?

Architecture technique

Mécanisme d'exécution du client

La fonction client.run() de Swarm implémente la boucle suivante :

1. Obtient une réponse complète de l'agent actuel
2. Exécute les appels d'outils et ajoute les résultats
3. Change d'agent si nécessaire
4. Met à jour les variables de contexte
5. Renvoie le résultat s'il n'y a pas de nouveaux appels de fonction

Configuration des paramètres

Paramètre	Type	Description	Valeur par défaut
agent	Agent	L'agent (initial) à appeler	(Obligatoire)
messages	List	Liste d'objets de message	(Obligatoire)
context_variables	dict	Variables de contexte	{}
max_turns	int	Nombre maximal de tours	float("inf")
model_override	str	Remplacement du modèle	None
execute_tools	bool	Indique s'il faut exécuter les outils	True
stream	bool	Indique s'il faut activer la réponse en flux	False
debug	bool	Indique s'il faut activer les journaux de débogage	False

Configuration de l'agent

Champs de la classe Agent

Champ	Type	Description	Valeur par défaut
name	str	Nom de l'agent	"Agent"
model	str	Modèle utilisé	"gpt-4o"
instructions	str ou fonction	Instructions de l'agent	"You are a helpful agent."
functions	List	Liste des fonctions appelables	[]
tool_choice	str	Stratégie de sélection d'outil	None

Exemple d'instructions dynamiques

def instructions(context_variables):
    user_name = context_variables["user_name"]
    return f"Help the user, {user_name}, do whatever they want."

agent = Agent(instructions=instructions)

response = client.run(
    agent=agent,
    messages=[{"role":"user", "content": "Hi!"}],
    context_variables={"user_name":"John"}
)

Mécanisme d'appel de fonction

Appel de fonction de base

def greet(context_variables, language):
    user_name = context_variables["user_name"]
    greeting = "Hola" if language.lower() == "spanish" else "Hello"
    print(f"{greeting}, {user_name}!")
    return "Done"

agent = Agent(functions=[greet])

Transfert d'agent

sales_agent = Agent(name="Sales Agent")

def transfer_to_sales():
    return sales_agent

agent = Agent(functions=[transfer_to_sales])

Retour de résultats complexes

def talk_to_sales():
    print("Hello, World!")
    return Result(
        value="Done",
        agent=sales_agent,
        context_variables={"department": "sales"}
    )

Exemples de projets

Swarm propose plusieurs exemples de projets illustrant différents cas d'utilisation :

1. basic - Exemple de base

Démonstration de l'utilisation de base de la configuration, des appels de fonction, des transferts et des variables de contexte

2. triage_agent - Agent de triage

Configuration de triage simple, transférant les demandes à l'agent approprié

3. weather_agent - Agent météo

Exemple simple illustrant les appels de fonction

4. airline - Service client de compagnie aérienne

Configuration multi-agents, traitant différents types de demandes de service client de compagnie aérienne

5. support_bot - Robot de support

Inclut un agent d'interface utilisateur et un agent de centre d'aide avec divers outils

6. personal_shopper - Assistant personnel de shopping

Assistant personnel de shopping aidant à la vente et au traitement des commandes de remboursement

Traitement en flux

Swarm prend en charge les réponses en flux, en utilisant les mêmes événements que l'API Chat Completions :

stream = client.run(agent, messages, stream=True)
for chunk in stream:
    print(chunk)

Nouveaux types d'événements :

• {"delim":"start"} et {"delim":"end"} - Marquent le début et la fin du traitement d'un seul message par l'agent
• {"response": Response} - Renvoie l'objet Response complet à la fin du flux

Tests et évaluation

Tests de développement

Utilisez run_demo_loop pour les tests en ligne de commande :

from swarm.repl import run_demo_loop

run_demo_loop(agent, stream=True)

Recommandations d'évaluation

• Le projet encourage les développeurs à apporter leurs propres suites d'évaluation
• Des références d'évaluation sont fournies dans les exemples airline, weather_agent et triage_agent
• Prend en charge les métriques de test de performance personnalisées

Différences avec les autres produits OpenAI

Comparaison avec l'API Assistants

• API Assistants: Fournit des threads entièrement gérés et une gestion de la mémoire intégrée
• Swarm: S'exécute entièrement côté client, conception sans état, plus adapté à l'apprentissage et à l'expérimentation

Caractéristiques techniques

• Construit sur l'API Chat Completions
• Ne conserve pas l'état entre les appels
• Implémentation client légère
• Axé sur l'éducation et l'apprentissage

Cas d'utilisation

Swarm est particulièrement adapté aux situations suivantes :

• Scénarios nécessitant le traitement d'un grand nombre de fonctions et d'instructions indépendantes
• Tâches complexes difficiles à coder dans une seule invite
• Apprentissage des concepts d'orchestration multi-agents
• Développement rapide de prototypes et expérimentation

État du projet

Remarque: Bien que Swarm ait été remplacé par le SDK OpenAI Agents, il reste une excellente ressource éducative pour aider les développeurs à comprendre les concepts de base et la mise en œuvre des systèmes multi-agents. Pour les environnements de production, il est recommandé de migrer vers le SDK Agents officiel.

Conclusion

OpenAI Swarm fournit un framework simple et puissant pour l'apprentissage et le développement de systèmes multi-agents. Grâce aux deux concepts fondamentaux d'agents et de transferts, les développeurs peuvent construire des flux de travail d'IA complexes tout en conservant la lisibilité et la maintenabilité du code. Bien qu'il ait été remplacé par un nouveau SDK, sa philosophie de conception et sa valeur éducative restent importantes.