Salt la conținutul principal
Română— Alege o limbă
Meniu

Scalabilité et architectures multi-agents

Lecția 25 din 25 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Scalabilité et architectures multi-agents
  2. Architecture de production
  3. Modèles multi-agents
  4. Gestion des limites de débit
  5. Optimisation des coûts à grande échelle
  6. Puncte cheie
  7. Testez vos connaissances

Scalabilité et architectures multi-agents

Votre agent fonctionne pour 10 utilisateurs. Comment le faire fonctionner pour 10 000 ? Les défis changent : il ne s’agit plus d’instructions qui échouent, mais de limites de débit du fournisseur, de mémoire serveur et de votre facture mensuelle. Dans cette dernière leçon, vous apprendrez à mettre à l’échelle vos agents, à concevoir des architectures multi-agents hautes performances et à gérer les contraintes de production à grande échelle.

Architecture de production

Le backend d’agent avec FastAPI

La première décision structurelle concerne le cycle de vie de l’agent. Construire un Agent pour chaque requête gaspille du temps et disperse la configuration ; lifespan de FastAPI vous permet de les instancier une seule fois au démarrage et de les conserver dans un registre indexé par type. La route lit le type demandé, le rejette proprement s’il n’existe pas, puis diffuse la réponse : run_streamed émet des deltas au fur et à mesure de la génération, faisant apparaître le texte à l’écran immédiatement au lieu de laisser l’utilisateur fixer un indicateur de chargement pendant huit secondes.

from fastapi import FastAPI, Request, Depends, HTTPException
from fastapi.responses import StreamingResponse
from agents import Agent, Runner, function_tool
from contextlib import asynccontextmanager
import asyncio

# Pool of pre-configured agents
agents_registry = {}

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Initialize agents at startup
    agents_registry["sales"] = Agent(
        name="Sales Agent",
        instructions="You assist customers with their purchases.",
        model="gpt-5.6-terra",
        tools=[search_product, calculate_price],
    )
    agents_registry["support"] = Agent(
        name="Support Agent",
        instructions="You provide technical support.",
        model="gpt-5.6-terra",
        tools=[check_ticket, create_ticket],
    )
    yield
    agents_registry.clear()

app = FastAPI(lifespan=lifespan)

@app.post("/api/chat/{agent_type}")
async def chat(agent_type: str, request: Request):
    agent = agents_registry.get(agent_type)
    if not agent:
        raise HTTPException(404, f"Agent '{agent_type}' not found")

    body = await request.json()

    async def stream():
        result = Runner.run_streamed(agent, body["messages"])
        async for event in result.stream_events():
            if event.type == "raw_response_event":
                if hasattr(event.data, "delta") and event.data.delta:
                    yield f"data: {event.data.delta}\n\n"
        yield "data: [DONE]\n\n"

    return StreamingResponse(stream(), media_type="text/event-stream")

Gestion de la concurrence

Partager des objets Agent entre toutes les requêtes de cette manière est sûr car chaque requête crée un Runner indépendant : l’agent détient la configuration, le Runner détient l’état d’exécution. Le SDK gère la concurrence nativement, et le traitement d’un lot de messages consiste à empiler des coroutines dans asyncio.gather. Le détail clé ici est return_exceptions=True : sans cela, une seule requête échouée annule tout le lot. Avec cela, vous obtenez les erreurs sous forme de valeurs, vous les associez à leur message d’origine et vous traitez les quatre-vingt-dix-neuf résultats valides.

import asyncio
from agents import Agent, Runner

agent = Agent(
    name="Concurrent Agent",
    instructions="You answer questions.",
    model="gpt-5.6-terra",
)

async def process_parallel_requests(messages: list[str]):
    """Process multiple requests in parallel."""
    tasks = [Runner.run(agent, msg) for msg in messages]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for msg, res in zip(messages, results):
        if isinstance(res, Exception):
            print(f"Error for '{msg}': {res}")
        else:
            print(f"'{msg}' -> {res.final_output[:50]}...")

    return results

Modèles multi-agents

Modèle Superviseur

Au-delà d’une certaine échelle, un seul agent avec quinze outils devient imprévisible : ses instructions gonflent, ses choix se dégradent. Le modèle superviseur répartit le travail entre des agents spécialisés — recherche, analyse, rédaction — et délègue le routage à un agent dédié via un handoff. Chaque spécialiste conserve des instructions courtes et un modèle adapté à sa tâche : l’analyse hérite d’un modèle de raisonnement, tandis que le superviseur, qui ne fait que choisir un destinataire, s’exécute sur un modèle rapide puisque sa décision repose sur quelques mots.

from agents import Agent, Runner, Handoff

search_agent = Agent(
    name="Search",
    instructions="You search for information on the web and in databases.",
    tools=[WebSearchTool(), search_crm],
    model="gpt-5.6-terra",
)

analysis_agent = Agent(
    name="Analysis",
    instructions="You analyze data and produce insights.",
    model="gpt-5.6-sol",
)

writing_agent = Agent(
    name="Writing",
    instructions="You write professional reports in English.",
    model="gpt-5.6-terra",
)

supervisor_agent = Agent(
    name="Supervisor",
    instructions="""You coordinate a team of specialized agents.
    For each request:
    1. Analyze what is needed
    2. Delegate to specialized agents via handoff
    3. The last agent produces the final response

    Available agents:
    - Search: to collect data
    - Analysis: to analyze and interpret
    - Writing: to produce the final deliverable""",
    handoffs=[
        Handoff(agent=search_agent, description="Collect data"),
        Handoff(agent=analysis_agent, description="Analyze data"),
        Handoff(agent=writing_agent, description="Write a report"),
    ],
    model="gpt-5.6-terra",  # Fast for routing
)

Modèle Pipeline

Lorsque la séquence est connue à l’avance, laisser un modèle décider de la chaîne est une dépense inutile. Le modèle pipeline câble les étapes dans votre code : collecter, analyser, rédiger. Une analyse concurrentielle commence donc par deux collectes lancées ensemble — le web et le CRM n’ont aucune raison d’attendre l’un l’autre — puis transmet tout à l’analyse, dont la sortie alimente la rédaction. Vous obtenez un flux de travail reproductible, traçable étape par étape, dont la durée totale correspond à celle de la collecte la plus lente plus les deux étapes suivantes.

async def competitive_analysis_pipeline(company: str):
    # Step 1: Parallel data collection
    web_task = Runner.run(search_agent, f"Search for information about {company}")
    crm_task = Runner.run(crm_agent, f"CRM data for {company}")
    results = await asyncio.gather(web_task, crm_task)

    data = f"""Web data: {results[0].final_output}
    CRM data: {results[1].final_output}"""

    # Step 2: Analysis
    analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")

    # Step 3: Report
    report = await Runner.run(
        writing_agent,
        f"Write a competitive analysis report: {analysis.final_output}"
    )

    return report.final_output

Modèle Map-Reduce

Le troisième modèle répond à un problème de volume plutôt que de complexité. Deux mille verbatims clients ne tiennent pas dans une seule requête et ne peuvent pas être analysés séquentiellement dans un délai raisonnable. La phase MAP classe chaque retour en parallèle avec un modèle rapide et une sortie typée ; la phase REDUCE agrège ces classifications, bien plus compactes que les textes originaux, et confie la synthèse à un modèle plus performant. Le coût s’effondre par rapport à une analyse complète, car la majeure partie du volume est traitée par le modèle le moins cher.

async def analyze_feedbacks(feedbacks: list[str]):
    # MAP: analyze each feedback in parallel
    classifier_agent = Agent(
        name="Classifier",
        instructions="Classify the feedback: positive, negative, or neutral. Identify the main theme.",
        model="gpt-5.6-terra",
        output_type=FeedbackClassification,
    )

    tasks = [Runner.run(classifier_agent, fb) for fb in feedbacks]
    classifications = await asyncio.gather(*tasks)

    # REDUCE: synthesize results
    summary_data = [
        {"feedback": fb, "class": c.final_output.dict()}
        for fb, c in zip(feedbacks, classifications)
    ]

    synthesizer_agent = Agent(
        name="Synthesizer",
        instructions="Synthesize the feedback classifications into a report with statistics and insights.",
        model="gpt-5.6-terra",
    )

    import json
    report = await Runner.run(
        synthesizer_agent,
        f"Synthesize these {len(feedbacks)} classified feedbacks: {json.dumps(summary_data, ensure_ascii=False)}"
    )

    return report.final_output

Gestion des limites de débit

Lancer deux mille appels simultanés ne les fait pas finir plus vite : le fournisseur vous refuse et vous perdez le lot. Un sémaphore limite le nombre d’exécutions concurrentes, et le gestionnaire ci-dessous ajoute un backoff exponentiel plafonné à soixante secondes lorsqu’une erreur de limite survient. Le compteur d’erreurs se réinitialise dès qu’un appel réussit, évitant une pénalisation à long terme du service pour un incident transitoire.

import asyncio
from agents import Runner

class RateLimitManager:
    def __init__(self, max_concurrent: int = 10):
        self.semaphore = asyncio.Semaphore(max_concurrent)
        self.error_count = 0

    async def execute(self, agent, message, **kwargs):
        async with self.semaphore:
            try:
                result = await Runner.run(agent, message, **kwargs)
                self.error_count = 0
                return result
            except Exception as e:
                if "rate_limit" in str(e).lower():
                    self.error_count += 1
                    wait_time = min(2 ** self.error_count, 60)
                    await asyncio.sleep(wait_time)
                    return await self.execute(agent, message, **kwargs)
                raise

manager = RateLimitManager(max_concurrent=20)

Optimisation des coûts à grande échelle

Ensuite, il y a la facture. Deux leviers la réduisent sans dégrader le service. Le premier consiste à ne pas payer un modèle de raisonnement pour répondre à „quelles sont vos horaires“ : une table de correspondance mappe le niveau de complexité au modèle adapté, du plus économique pour les questions simples au plus performant pour les cas critiques, avec un défaut pour tout ce qui n’est pas classifié. Le second exploite la répétition — dans le support client, les mêmes questions reviennent des centaines de fois par jour, et un cache indexé sur un hachage de message renvoie la réponse instantanément et gratuitement. Réservez ce cache aux questions dont la réponse ne dépend ni de l’utilisateur ni du moment : une politique de retour se cache bien, un statut de commande jamais.

# Model strategy by complexity
def choose_model(complexity: str) -> str:
    models = {
        "simple": "gpt-5.6-terra",      # Simple questions: cheap
        "medium": "gpt-5.6-terra",       # Most cases
        "complex": "gpt-5.6-terra",     # Fast reasoning
        "critical": "gpt-5.6-sol",      # Critical cases: maximum quality
    }
    return models.get(complexity, "gpt-5.6-terra")

# Cache for frequent responses
from functools import lru_cache
import hashlib

response_cache = {}

async def execute_with_cache(agent, message: str):
    key = hashlib.md5(message.encode()).hexdigest()
    if key in response_cache:
        return response_cache[key]

    result = await Runner.run(agent, message)
    response_cache[key] = result.final_output
    return result.final_output

Puncte cheie

  • Préconfigurez vos agents au démarrage et réutilisez-les entre les requêtes
  • Le SDK gère la concurrence nativement via asyncio.gather()
  • Le modèle superviseur coordonne des agents spécialisés via des handoffs
  • Le modèle map-reduce parallélise le traitement de grands volumes
  • Gérez les limites de débit avec un sémaphore et un backoff exponentiel
  • Optimisez les coûts par sélection de modèle selon la complexité et mise en cache

Testez vos connaissances

Avant de passer à l’échelle, vérifiez vos connaissances en architecture d’agents.

1. Quels sont les blocs de construction du SDK Agents ?

Réponse : Agent (le rôle et ses instructions), Runner (la boucle d’exécution), Tool (les capacités) et Guardrail (validations d’entrée/sortie) — l’anatomie de tout agent SDK.

2. À quoi servent les Guardrails ?

Réponse : À valider ce qui entre et sort de l’agent : filtrer les requêtes hors sujet, contrôler les sorties avant qu’elles n’agissent — une sécurité déclarée dans l’architecture, pas espérée depuis le prompt.

3. Qu'est-ce qu'un handoff ?

Réponse : Le transfert d’une conversation d’un agent à un autre, plus spécialisé : une orchestration multi-agents où chaque agent fait ce qu’il sait faire de mieux, avec le contexte qui suit.

4. Pourquoi le tracing est-il indispensable en production ?

Réponse : Parce qu’un agent décide dynamiquement : sans traces des étapes, des outils appelés et des décisions, le débogage ou l’évaluation est impossible — le grading de trace score précisément ces exécutions.

5. Quand faut-il passer à une architecture multi-agents ?

Réponse : Lorsqu’un seul agent accumule trop de rôles et d’outils : vous spécialisez (tri, expertise, exécution) et orchestrez via des handoffs — chaque agent redevient simple et testable.

SDK, guardrails, handoffs, tracing : l’échafaudage est complet — la mise à l’échelle ci-dessus vous indique comment le déployer sans l’affaiblir.