Skalning och fleragentarkitekturer
På denna sida
Skalning och fleragentarkitekturer
Din agent fungerar för 10 användare. Hur får du den att köras för 10 000? Utmaningarna förändras: det handlar inte längre om att instruktioner misslyckas, utan om leverantörens hastighetsbegränsningar, serverminne och din månadskostnad. I denna sista lektion lär du dig hur du skalar dina agenter, designar högpresterande fleragentarkitekturer och hanterar produktionsbegränsningar i stor skala.
Produktionsarkitektur
Agent-backend med FastAPI
Det första strukturella valet gäller agentens livscykel. Att bygga en Agent för varje förfrågan slösar tid och sprider konfigurationen; FastAPI:s lifespan låter dig instansiera dem en gång vid start och hålla dem i ett register indexerat efter typ. Routen läser den begärda typen, avvisar den rent om den inte finns, och strömmar sedan svaret: run_streamed emitterar deltan medan genereringen pågår, vilket gör att texten visas på skärmen omedelbart istället för att låta användaren stirra på en laddningsindikator i åtta 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 av förkonfigurerade agenter
agents_registry = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Initiera agenter vid start
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")
Hantering av samtidighet
Att dela Agent-objekt mellan alla förfrågningar på detta sätt är säkert eftersom varje förfrågan skapar en oberoende Runner: agenten håller konfigurationen, Runnern håller exekveringstillståndet. SDK:t hanterar samtidighet inbyggt, och bearbetning av en batch med meddelanden innebär att korutiner staplas i asyncio.gather. Nyckeldetaljen här är return_exceptions=True: utan den avbryter en enda misslyckad förfrågan hela batchen. Med den får du fel som värden, matchar dem mot deras ursprungliga meddelande och bearbetar de nittionio giltiga resultaten.
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]):
"""Bearbeta flera förfrågningar parallellt."""
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
Mönster för flera agenter
Supervisor-mönstret
Utöver en viss skala blir en enskild agent med femton verktyg oförutsägbar: dess instruktioner sväller, dess val försämras. Supervisor-mönstret delar upp arbetet mellan specialiserade agenter – forskning, analys, skrivande – och delegerar routning till en dedikerad agent via handoff. Varje specialist håller korta instruktioner och en modell lämpad för sin uppgift: analys ärver en resonemangsmodell, medan supervisorn, som bara väljer en mottagare, körs på en snabb modell eftersom dess beslut hänger på några 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", # Snabb för routning
)
Pipeline-mönstret
När sekvensen är känd i förväg är det en onödig kostnad att låta en modell bestämma kedjan. Pipeline-mönstret kopplar ihop steg i din kod: samla, analysera, skriv. En konkurrensanalys börjar alltså med två insamlingar som startas samtidigt – webben och CRM har ingen anledning att vänta på varandra – och skickar sedan allt till analys, vars utmatning matar skrivandet. Du får ett reproducerbart arbetsflöde, spårbart steg för steg, vars totala varaktighet är den för den långsammaste insamlingen plus de två följande stegen.
async def competitive_analysis_pipeline(company: str):
# Steg 1: Parallell datainsamling
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}"""
# Steg 2: Analys
analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")
# Steg 3: Rapport
report = await Runner.run(
writing_agent,
f"Write a competitive analysis report: {analysis.final_output}"
)
return report.final_output
Map-Reduce-mönstret
Det tredje mönstret adresserar ett volymproblem snarare än komplexitet. Tvåtusen kundcitryck får inte plats i en enda förfrågan och kan inte analyseras sekventiellt på rimlig tid. MAP-fasen klassificerar varje feedback parallellt med en snabb modell och typad utmatning; REDUCE-fasen aggregerar dessa klassificeringar, betydligt mer kompakta än originaltexterna, och anförtro syntesen till en mer kapabel modell. Kostnaden kollapsar jämfört med fullständig analys, eftersom bulkvolymen bearbetas av den billigaste modellen.
async def analyze_feedbacks(feedbacks: list[str]):
# MAP: analysera varje feedback parallellt
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: syntetisera resultat
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
Hantering av hastighetsbegränsningar
Att starta tvåtusen samtidiga anrop gör inte att de blir klara snabbare: leverantören nekar dig och du förlorar batchen. En semaphore begränsar antalet samtidiga exekveringar, och hanteraren nedan lägger till exponentiell backoff med tak på sextio sekunder när ett begränsningsfel inträffar. Felräknaren nollställs så snart ett anrop lyckas, vilket undviker långsiktig bestraffning av tjänsten för en tillfällig 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)
Kostnadsoptimering i stor skala
Sedan har vi fakturan. Två hävstänger minskar den utan att försämra tjänsten. Den första är att inte betala för en resonemangsmodell för att svara på “vad är era öppettider”: en uppslagstabell mappar komplexitetsnivå till lämplig modell, från den mest ekonomiska för enkla frågor till den mest kapabla för kritiska fall, med en standard för allt oklassificerat. Den andra utnyttjar upprepning – i kundsupport återkommer samma frågor hundratals gånger om dagen, och en cache indexerad på ett meddelandehash returnerar svaret omedelbart och gratis. Reservera denna cache för frågor vars svar varken beror på användaren eller tiden: en returpolicy cachar bra, en orderstatus gör det aldrig.
# Modellstrategi efter komplexitet
def choose_model(complexity: str) -> str:
models = {
"simple": "gpt-5.6-terra", # Enkla frågor: billigt
"medium": "gpt-5.6-terra", # De flesta fall
"complex": "gpt-5.6-terra", # Snabbt resonemang
"critical": "gpt-5.6-sol", # Kritiska fall: maximal kvalitet
}
return models.get(complexity, "gpt-5.6-terra")
# Cache för frekventa 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
Viktiga punkter
- Förkonfigurera dina agenter vid start och återanvänd dem över förfrågningar
- SDK:t hanterar samtidighet inbyggt via
asyncio.gather() - Supervisor-mönstret koordinerar specialiserade agenter via handoffs
- Map-reduce-mönstret parallelliserar bearbetning av stora volymer
- Hantera hastighetsbegränsningar med en semaphore och exponentiell backoff
- Optimera kostnader med modellval efter komplexitet och cachelagring
Testa dina kunskaper
Innan du skalar upp, kontrollera dina kunskaper om agentarkitektur.
1. Vad är byggstenarna i Agents SDK?
Svar: Agent (rollen och dess instruktioner), Runner (exekveringsloopen), Tool (kapaciteterna) och Guardrail (validering av in-/utdata) – anatomin för vilken SDK-agent som helst.
2. Vad används Guardrails till?
Svar: För att validera vad som kommer in och lämnar agenten: filtrera bort förfrågningar utanför scope, kontrollera utdata innan de agerar – säkerhet deklarerad i arkitekturen, inte hoppad på från prompten.
3. Vad är en handoff?
Svar: Överföringen av en konversation från en agent till en annan, mer specialiserad: fleragentorkestrering där varje agent gör det den kan bäst, med kontexten följande med.
4. Varför är spårning oumbärlig i produktion?
Svar: Eftersom en agent beslutar dynamiskt: utan spår av steg, anropade verktyg och beslut är felsökning eller utvärdering omöjlig – spårgradering poängsätter dessa exekveringar precist.
5. När bör du byta till en fleragentarkitektur?
Svar: När en enskild agent ackumulerar för många roller och verktyg: du specialiserar (triage, expertis, exekvering) och orkestrerar via handoffs – varje agent blir enkel och testbar igen.
SDK, guardrails, handoffs, spårning: ställningen är komplett – skalningen ovan berättar för dig hur du distribuerar den utan att försvaga den.