Swarm framework : agents légers

Swarm : framework d'agents légers d'OpenAI

Swarm est un framework expérimental d'OpenAI pour construire des systèmes multi-agents légers et ergonomiques. Il est conçu pour être simple, transparent et facilement personnalisable, en privilégiant la lisibilité du code plutôt que la magie abstraite.

Philosophie de Swarm

Swarm repose sur deux primitives fondamentales : - Agents : Un system prompt + des fonctions/outils - Handoffs : Transférer la conversation à un autre agent

C'est un framework de coordination, pas un wrapper d'API. Chaque appel est stateless et utilise l'API Chat Completions standard.

Installation et utilisation

pip install git+https://github.com/openai/swarm.git

from swarm import Swarm, Agent

client = Swarm()

# Définir un agent simple
agent = Agent(
    name="Mon Assistant",
    instructions="Tu es un assistant utile et concis.",
)

response = client.run(
    agent=agent,
    messages=[{"role": "user", "content": "Bonjour !"}]
)
print(response.messages[-1]["content"])

Agents avec fonctions

def get_weather(city: str) -> str:
    """Obtient la météo pour une ville."""
    return f"Il fait 22°C à {city}"

def transfer_to_booking():
    """Transfère à l'agent de réservation."""
    return booking_agent

weather_agent = Agent(
    name="Agent Météo",
    instructions="Tu donnes des informations météo. Si l'utilisateur veut réserver, transfère à l'agent de réservation.",
    functions=[get_weather, transfer_to_booking]
)

booking_agent = Agent(
    name="Agent Réservation",
    instructions="Tu gères les réservations de voyage.",
    functions=[create_booking, cancel_booking]
)

Handoffs entre agents

Le transfert entre agents se fait simplement en retournant un Agent depuis une fonction :

def transfer_to_support():
    """Transfère au support technique."""
    return support_agent

def transfer_to_sales():
    """Transfère au commercial."""
    return sales_agent

triage_agent = Agent(
    name="Triage",
    instructions="""Tu aiguilles les demandes :
    - Questions techniques → support
    - Questions commerciales → sales""",
    functions=[transfer_to_support, transfer_to_sales]
)

Variables de contexte

Partagez du contexte entre agents sans le mettre dans les messages :

def get_user_info(context_variables: dict) -> str:
    user_id = context_variables["user_id"]
    return f"Utilisateur : {user_id}, Plan : Premium"

agent = Agent(
    name="Support",
    instructions="Tu es un agent de support.",
    functions=[get_user_info]
)

response = client.run(
    agent=agent,
    messages=[{"role": "user", "content": "Mon compte"}],
    context_variables={"user_id": "12345"}
)

Pattern : Service client complet

def escalate_to_human():
    """Escalade vers un humain quand le problème est trop complexe."""
    return "ESCALATION_NEEDED"

def refund_order(order_id: str) -> str:
    """Effectue un remboursement."""
    return f"Remboursement effectué pour la commande {order_id}"

support_agent = Agent(
    name="Support Client",
    instructions="""Tu es un agent de support bienveillant.
    Règles :
    - Remboursement max 50€ sans validation
    - Au-delà, escalade vers un humain
    - Toujours vérifier le numéro de commande""",
    functions=[refund_order, escalate_to_human, transfer_to_sales]
)

Différences avec le SDK Agents officiel

Quand utiliser Swarm

• Prototypage rapide : Tester des architectures multi-agents
• Apprentissage : Comprendre les patterns d'orchestration
• Cas simples : Systèmes avec peu d'agents et des transferts clairs
• Personnalisation totale : Quand vous voulez contrôler chaque aspect

Bonnes pratiques

• Fonctions documentées : Les docstrings servent de description pour le modèle
• Agents focalisés : Un agent = une responsabilité
• Transferts explicites : Le nom de la fonction doit indiquer clairement le transfert
• Tests unitaires : Testez chaque agent individuellement avant de les connecter