Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Škálování a architektury s více agenty

Lekce 25 z 25 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Škálování a architektury s více agenty
  2. Produkční architektura
  3. Vzory pro více agentů
  4. Správa limitů rychlosti (Rate Limits)
  5. Optimalizace nákladů ve velkém měřítku
  6. Klíčové poznatky
  7. Ověř si své znalosti

Škálování a architektury s více agenty

Tvůj agent funguje pro 10 uživatelů. Jak zajistíš, aby běžel pro 10 000? Výzvy se mění: už nejde o to, že instrukce selhávají, ale o limity poskytovatele, paměť serveru a tvou měsíční fakturu. V této závěrečné lekci se naučíš, jak škálovat své agenty, navrhovat vysoce výkonné architektury s více agenty a zvládat produkční omezení ve velkém měřítku.

Produkční architektura

Backend agenta s FastAPI

První strukturální rozhodnutí se týká životního cyklu agenta. Vytváření instance Agent pro každý požadavek plýtvá časem a roztříští konfiguraci; lifespan ve FastAPI ti umožní instantiate je jednou při startu a udržet je v registru indexovaném podle typu. Trasa přečte požadovaný typ, čistě jej odmítne, pokud neexistuje, a poté streamuje odpověď: run_streamed emituje delty během generování, takže se text objeví na obrazovce okamžitě, místo aby uživatel osm sekund zíral na točící se indikátor načítání.

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 předkonfigurovaných agentů
agents_registry = {}

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Inicializace agentů při startu
    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")

Správa souběžnosti

Sdílení objektů Agent napříč všemi požadavky tímto způsobem je bezpečné, protože každý požadavek vytváří nezávislého Runnera: agent drží konfiguraci, Runner drží stav provádění. SDK zvládá souběžnost nativně a zpracování dávky zpráv znamená skládání korutin v asyncio.gather. Klíčovým detailem zde je return_exceptions=True: bez něj by jediný neúspěšný požadavek zrušil celou dávku. S ním získáš chyby jako hodnoty, spáruješ je s původní zprávou a zpracuješ devadesát devět platných výsledků.

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]):
    """Zpracování více požadavků paralelně."""
    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"Chyba pro '{msg}': {res}")
        else:
            print(f"'{msg}' -> {res.final_output[:50]}...")

    return results

Vzory pro více agentů

Vzor Supervizor

Nad určitou škálou se jeden agent s patnácti nástroji stává nepředvídatelným: jeho instrukce bobtnají, jeho rozhodování degraduje. Vzor supervizor rozděluje práci mezi specializované agenty – výzkum, analýza, psaní – a deleguje směrování na vyhrazeného agenta prostřednictvím předání (handoff). Každý specialista udržuje krátké instrukce a model vhodný pro svůj úkol: analýza zdědí model pro uvažování, zatímco supervizor, který pouze vybírá příjemce, běží na rychlém modelu, protože jeho rozhodnutí závisí na několika slovech.

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",  # Rychlý pro směrování
)

Vzor Pipeline

Když je posloupnost známá předem, nechat model rozhodovat o řetězci je zbytečný výdaj. Vzor pipeline propojuje kroky ve tvém kódu: sběr, analýza, psaní. Konkurenční analýza tak začíná dvěma souběžnými sběry – web a CRM nemají důvod čekat jeden na druhého – poté vše předá analýze, jejíž výstup napájí psaní. Získáš reprodukovatelný pracovní postup, sledovatelný krok za krokem, jehož celková doba trvání odpovídá nejpomalejšímu sběru plus dvěma následujícím krokům.

async def competitive_analysis_pipeline(company: str):
    # Krok 1: Paralelní sběr dat
    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}"""

    # Krok 2: Analýza
    analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")

    # Krok 3: Zpráva
    report = await Runner.run(
        writing_agent,
        f"Write a competitive analysis report: {analysis.final_output}"
    )

    return report.final_output

Vzor Map-Reduce

Třetí vzor řeší problém objemu, nikoliv složitosti. Dva tisíce zákaznických ohlasů se nevejde do jediného požadavku a nelze je analyzovat sekvenčně v rozumném čase. Fáze MAP klasifikuje každou zpětnou vazbu paralelně pomocí rychlého modelu a typovaného výstupu; fáze REDUCE agreguje tyto klasifikace, které jsou mnohem kompaktnější než původní texty, a syntézu svěří schopnějšímu modelu. Náklady se hroutí ve srovnání s plnou analýzou, protože většina objemu je zpracována nejlevnějším modelem.

async def analyze_feedbacks(feedbacks: list[str]):
    # MAP: analýza každého ohlasu paralelně
    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: syntéza výsledků
    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

Správa limitů rychlosti (Rate Limits)

Spuštění dvou tisíc současných volání je nezrychlí: poskytovatel tě odmítne a dávku ztratíš. Semafór omezuje počet souběžných provádění a níže uvedený správce přidává exponenciální čekání (backoff) omezené na šedesát sekund, když dojde k chybě limitu. Počítadlo chyb se resetuje, jakmile se volání úspěšně provede, čímž se vyhneš dlouhodobému penalizování služby za přechodný incident.

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)

Optimalizace nákladů ve velkém měřítku

Pak je tu faktura. Dvě páky ji sníží bez degradace služby. První je neplatit za model pro uvažování, aby odpověděl na „jaké máte otevírací hodiny“: vyhledávací tabulka mapuje úroveň složitosti na vhodný model, od nejúspornějšího pro jednoduché otázky po nejschopnější pro kritické případy, s výchozím nastavením pro vše neklasifikované. Druhá využívá opakování – v zákaznické podpoře se stejné otázky vracejí stokrát denně a mezipaměť indexovaná hashem zprávy vrátí odpověď okamžitě a zdarma. Tuto mezipaměť vyhraď pro otázky, jejichž odpověď nezávisí ani na uživateli, ani na čase: politika vracení zboží se dobře cacheuje, stav objednávky nikdy.

# Strategie modelu podle složitosti
def choose_model(complexity: str) -> str:
    models = {
        "simple": "gpt-5.6-terra",      # Jednoduché otázky: levné
        "medium": "gpt-5.6-terra",       # Většina případů
        "complex": "gpt-5.6-terra",     # Rychlé uvažování
        "critical": "gpt-5.6-sol",      # Kritické případy: maximální kvalita
    }
    return models.get(complexity, "gpt-5.6-terra")

# Mezipaměť pro časté odpovědi
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

Klíčové poznatky

  • Předkonfiguruj své agenty při startu a znovu je využívej napříč požadavky
  • SDK zvládá souběžnost nativně prostřednictvím asyncio.gather()
  • Vzor supervizor koordinuje specializované agenty prostřednictvím předání (handoffs)
  • Vzor map-reduce paralelizuje zpracování velkých objemů
  • Spravuj limity rychlosti pomocí semaforu a exponenciálního čekání (backoff)
  • Optimalizuj náklady výběrem modelu podle složitosti a cachingem

Ověř si své znalosti

Než začneš škálovat, zkontroluj si znalosti architektury agentů.

1. Jaké jsou stavební kameny Agents SDK?

Odpověď: Agent (role a její instrukce), Runner (smyčka provádění), Tool (schopnosti) a Guardrail (validace vstupu/výstupu) – anatomie jakéhokoliv agenta v SDK.

2. K čemu slouží Guardrails?

Odpověď: K validaci toho, co vstupuje do agenta a co z něj vychází: filtrování požadavků mimo rozsah, kontrola výstupů před jejich provedením – bezpečnost deklarovaná v architektuře, nikoliv doufaná z promptu.

3. Co je to handoff?

Odpověď: Přenos konverzace z jednoho agenta na druhého, specializovanějšího: orchestrace více agentů, kde každý dělá to, co umí nejlépe, s následujícím kontextem.

4. Proč je trasování (tracing) v produkci nezbytné?

Odpověď: Protože agent rozhoduje dynamicky: bez stop kroků, volaných nástrojů a rozhodnutí je ladění nebo evaluace nemožná – grading trasování přesně hodnotí tato provádění.

5. Kdy bys měl přejít na architekturu s více agenty?

Odpověď: Když jeden agent nahromadí příliš mnoho rolí a nástrojů: specializuješ se (třídění, expertíza, provedení) a orchestruješ prostřednictvím handoffs – každý agent se opět stane jednoduchým a testovatelným.

SDK, guardrails, handoffs, tracing: lešení je kompletní – výše uvedené škálování ti říká, jak jej nasadit, aniž bys ho oslabil.