Skalering og multi-agent-arkitekturer
På denne side
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.