Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Skalering og multi-agent-arkitekturer

Lektion 25 af 25 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Skalering og multi-agent-arkitekturer
  2. Produktionsarkitektur
  3. Multi-agent-mønstre
  4. Håndtering af rate limits
  5. Omkostningsoptimering i stor skala
  6. Vigtige pointer
  7. Test din viden

Skalering og multi-agent-arkitekturer

Din agent fungerer for 10 brugere. Hvordan får du den til at køre for 10.000? Udfordringerne ændrer sig: Det handler ikke længere om instrukser, der fejler, men om udbyderens rate limits, serverhukommelse og din månedlige regning. I denne sidste lektion lærer du at skalere dine agenter, designe højtydende multi-agent-arkitekturer og håndtere produktionsbegrænsninger i stor skala.

Produktionsarkitektur

Agent-backend med FastAPI

Den første strukturelle beslutning vedrører agentens livscyklus. At bygge en Agent for hver anmodning spilder tid og spreder konfigurationen; FastAPI’s lifespan lader dig instantiere dem én gang ved opstart og holde dem i et register indekseret efter type. Ruten læser den ønskede type, afviser den rent, hvis den ikke eksisterer, og streamer derefter svaret: run_streamed udsender deltas, mens genereringen skrider frem, hvilket får teksten til at vises på skærmen med det samme i stedet for at lade brugeren stirre på et loadingspinner i otte sekunder.

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 af prækonfigurerede agenter
agents_registry = {}

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Initialiser agenter ved opstart
    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")

Håndtering af samtidighed

At dele Agent-objekter på tværs af alle anmodninger på denne måde er sikkert, fordi hver anmodning skaber en uafhængig Runner: agenten indeholder konfigurationen, mens Runneren indeholder eksekveringstilstanden. SDK’et håndterer samtidighed nativt, og behandling af en batch af beskeder betyder at stable coroutine’er i asyncio.gather. Nøgledetaljen her er return_exceptions=True: uden den vil en enkelt mislykket anmodning annullere hele batchen. Med den får du fejl som værdier, matcher dem til deres oprindelige besked og behandler de nioghalvfems gyldige resultater.

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]):
    """Behandl flere anmodninger parallelt."""
    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

Multi-agent-mønstre

Supervisor-mønsteret

Ud over en vis skala bliver en enkelt agent med femten værktøjer uforudsigelig: dens instrukser svulmer op, og dens valg forringes. Supervisor-mønsteret opdeler arbejdet mellem specialiserede agenter – research, analyse, skrivning – og delegerer routing til en dedikeret agent via handoff. Hver specialist beholder korte instrukser og en model, der passer til opgaven: analyse arver en ræsonnementsmodel, mens supervisoren, som kun vælger en modtager, kører på en hurtig model, da dens beslutning afhænger af få ord.

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
)

Pipeline-mønsteret

Når sekvensen er kendt på forhånd, er det en unødvendig udgift at lade en model beslutte kæden. Pipeline-mønsteret forbinder trin i din kode: indsamling, analyse, skrivning. En konkurrenceanalyse starter således med to indsamlinger, der lanceres sammen – web og CRM har ingen grund til at vente på hinanden – og sender derefter alt til analyse, hvis output fodrer skrivning. Du får et reproducerbart workflow, der kan spores trin for trin, og hvis samlede varighed er den langsomste indsamling plus de to følgende trin.

async def competitive_analysis_pipeline(company: str):
    # Trin 1: Parallel dataindsamling
    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}"""

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

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

    return report.final_output

Map-Reduce-mønsteret

Det tredje mønster adresserer et volumenproblem snarere end kompleksitet. To tusinde kundecitater passer ikke i en enkelt anmodning og kan ikke analyseres sekventielt på rimelig tid. MAP-fasen klassificerer hver feedback parallelt med en hurtig model og typet output; REDUCE-fasen aggregerer disse klassifikationer, der er langt mere kompakte end originalteksterne, og overlader syntesen til en mere capable model. Omkostningerne kollapser sammenlignet med fuld analyse, fordi hovedparten af volumenet behandles af den billigste model.

async def analyze_feedbacks(feedbacks: list[str]):
    # MAP: analysér hver feedback parallelt
    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: syntetisér resultater
    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

Håndtering af rate limits

At lancere to tusind samtidige opkald får dem ikke til at blive hurtigere færdige: udbyderen afviser dig, og du mister batchen. En semaphore begrænser antallet af samtidige eksekveringer, og manageren nedenfor tilføjer eksponentiel backoff capped ved tres sekunder, når en limit-fejl opstår. Fejltælleren nulstilles, så snart et opkald lykkes, hvilket undgår langvarig straf til tjenesten for en forbigående hændelse.

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)

Omkostningsoptimering i stor skala

Så er der regningen. To løftestænger reducerer den uden at forringe servicen. Den første er ikke at betale for en ræsonnementsmodel til at svare på „hvad er jeres åbningstider”: en opslagstabel mapper kompleksitetsniveau til den passende model, fra den mest økonomiske til simple spørgsmål til den mest capable til kritiske tilfælde, med en standard for alt uklassificeret. Den anden udnytter gentagelse – i kundesupport vender de samme spørgsmål tilbage hundredvis af gange om dagen, og en cache indekseret på en besked-hash returnerer svaret øjeblikkeligt og gratis. Reserver denne cache til spørgsmål, hvis svar hverken afhænger af brugeren eller tidspunktet: en returpolitik cachér godt, en ordrestatus gør det aldrig.

# Modelstrategi efter kompleksitet
def choose_model(complexity: str) -> str:
    models = {
        "simple": "gpt-5.6-terra",      # Simple spørgsmål: billige
        "medium": "gpt-5.6-terra",       # De fleste tilfælde
        "complex": "gpt-5.6-terra",     # Hurtigt ræsonnement
        "critical": "gpt-5.6-sol",      # Kritiske tilfælde: maksimal kvalitet
    }
    return models.get(complexity, "gpt-5.6-terra")

# Cache til hyppige svar
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

Vigtige pointer

  • Prækonfigurer dine agenter ved opstart og genbrug dem på tværs af anmodninger
  • SDK’et håndterer samtidighed nativt via asyncio.gather()
  • Supervisor-mønsteret koordinerer specialiserede agenter via handoffs
  • Map-reduce-mønsteret paralleliserer behandling af store volumener
  • Håndtér rate limits med en semaphore og eksponentiel backoff
  • Optimér omkostninger med modelvalg efter kompleksitet og caching

Test din viden

Før du skalerer op, så tjek din viden om agentarkitektur.

1. Hvad er byggestenene i Agents SDK?

Svar: Agent (rollen og dens instrukser), Runner (eksekveringsløkken), Tool (funktionerne) og Guardrail (validering af input/output) – anatomien af enhver SDK-agent.

2. Hvad bruges Guardrails til?

Svar: Til at validere, hvad der går ind i og ud af agenten: filtrér anmodninger uden for scope, kontrollér outputs før de handler – sikkerhed deklareret i arkitekturen, ikke håbet på fra prompten.

3. Hvad er en handoff?

Svar: Overførslen af en samtale fra én agent til en anden, mere specialiseret én: multi-agent-orkestrering, hvor hver agent gør det, den er bedst til, med konteksten følgende med.

4. Hvorfor er tracing uundværlig i produktion?

Svar: Fordi en agent beslutter dynamisk: uden spor af trin, kaldte værktøjer og beslutninger er debugging eller evaluering umulig – trace-grading scorer præcist disse eksekveringer.

5. Hvornår skal du skifte til en multi-agent-arkitektur?

Svar: Når en enkelt agent akkumulerer for mange roller og værktøjer: du specialiserer (triage, ekspertise, eksekvering) og orkestrerer via handoffs – hver agent bliver simpel og testbar igen.

SDK, guardrails, handoffs, tracing: stilladset er komplet – skaleringen ovenfor fortæller dig, hvordan du udruller det uden at svække det.