Orchestration multi-agents OpenAI

Orchestration multi-agents avec OpenAI

L'orchestration multi-agents consiste à coordonner plusieurs agents IA spécialisés pour résoudre des tâches complexes. Chaque agent a un rôle précis, et un orchestrateur route les tâches entre eux.

Patterns d'orchestration

Pattern 1 : Routeur central

Utilisateur → Agent Routeur → Agent Spécialiste A
                            → Agent Spécialiste B
                            → Agent Spécialiste C

L'agent routeur analyse la requête et la dirige vers le spécialiste approprié.

Pattern 2 : Pipeline séquentiel

Input → Agent Recherche → Agent Analyse → Agent Rédaction → Output

Chaque agent traite une étape et passe le résultat au suivant.

Pattern 3 : Parallèle avec agrégation

Tâche → Agent A (sous-tâche 1) ─┐
      → Agent B (sous-tâche 2) ─┼→ Agent Synthèse → Résultat
      → Agent C (sous-tâche 3) ─┘

Plusieurs agents travaillent en parallèle, un agent final synthétise.

Implémentation avec le SDK OpenAI Agents

OpenAI propose le SDK openai-agents (Python) pour l'orchestration :

from agents import Agent, Runner, handoff

# Définir les agents spécialisés
research_agent = Agent(
    name="Chercheur",
    instructions="Tu recherches des informations sur le web pour répondre aux questions.",
    tools=[web_search_tool]
)

writer_agent = Agent(
    name="Rédacteur",
    instructions="Tu rédiges du contenu clair et structuré à partir des recherches fournies.",
)

# Agent orchestrateur avec handoffs
orchestrator = Agent(
    name="Coordinateur",
    instructions="""Tu coordonnes une équipe d'agents.
    - Pour les recherches d'information : transfère au Chercheur
    - Pour la rédaction finale : transfère au Rédacteur""",
    handoffs=[handoff(research_agent), handoff(writer_agent)]
)

# Exécution
result = await Runner.run(orchestrator, "Rédige un article sur les tendances IA 2025")

Handoffs (transferts)

Les handoffs permettent à un agent de transférer le contrôle à un autre agent :

# Le transfert peut inclure du contexte
support_agent = Agent(
    name="Support",
    instructions="Tu gères les demandes de support technique.",
    handoffs=[handoff(
        billing_agent,
        condition="Si la question concerne la facturation"
    )]
)

Architecture en TypeScript

Pour une implémentation manuelle en TypeScript :

type Agent = {
  name: string;
  systemPrompt: string;
  tools?: Tool[];
};

async function routeToAgent(agents: Agent[], userMessage: string) {
  // L'orchestrateur choisit l'agent
  const routingResponse = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "system", content: `Choisis l'agent approprié parmi : ${agents.map(a => a.name).join(", ")}. Réponds uniquement avec le nom.` },
      { role: "user", content: userMessage }
    ]
  });

  const selectedAgent = agents.find(
    a => a.name === routingResponse.choices[0].message.content?.trim()
  );

  // Exécuter avec l'agent sélectionné
  const result = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "system", content: selectedAgent.systemPrompt },
      { role: "user", content: userMessage }
    ],
    tools: selectedAgent.tools
  });

  return result;
}

Bonnes pratiques

• Agents focalisés : Chaque agent a une responsabilité unique et claire
• Instructions détaillées : Décrivez précisément quand transférer à un autre agent
• Contexte partagé : Passez un résumé du contexte lors des transferts
• Fallback : Prévoyez un agent par défaut si le routage échoue
• Limites de profondeur : Évitez les boucles infinies entre agents (max 5-10 transferts)
• Observabilité : Loggez chaque décision de routage et transfert

Quand utiliser le multi-agents

• Tâches nécessitant des compétences variées (recherche + analyse + rédaction)
• Workflows complexes avec des branches conditionnelles
• Quand un seul prompt ne peut pas capturer toute la logique
• Pour la séparation des responsabilités et la maintenabilité