Mērogošana un vairāku aģentu arhitektūras
Šajā lapā
Mērogošana un vairāku aģentu arhitektūras
Tavs aģents strādā 10 lietotājiem. Kā panākt, lai tas darbotos 10 000 lietotāju apjomā? Izaicinājumi mainās: vairs nav runa par neizdodamām instrukcijām, bet gan par pakalpojumu sniedzēja ātruma ierobežojumiem, servera atmiņu un tavu ikmēneša rēķinu. Šajā noslēdzošajā nodarbībā tu iemācīsies, kā mērogot savus aģentus, projektēt augstas veiktspējas vairāku aģentu arhitektūras un pārvaldīt ražošanas ierobežojumus lielos apjomos.
Ražošanas arhitektūra
Aģenta backend ar FastAPI
Pirmais strukturālais lēmums attiecas uz aģenta dzīves ciklu. Katram pieprasījumam jauna Agent实例a izveide tērē laiku un izkliedē konfigurāciju; FastAPI lifespan ļauj tos inicializēt vienreiz startēšanas brīdī un glabāt reģistrā, kas indeksēts pēc veida. Maršruts nolasa pieprasīto veidu, tīri noraida to, ja tas neeksistē, un pēc tam straumē atbildi: run_streamed izdala deltas ģenerēšanas gaitā, liekot tekstam parādīties ekrānā uzreiz, nevis liekot lietotājam astoņas sekundes skatīties uz ielādes indikatoru.
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
# Iepriekš konfigurētu aģentu baseins
agents_registry = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Inicializē aģentus startēšanas brīdī
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")
Vienlaicīguma pārvaldība
Agent objektu koplietošana starp visiem pieprasījumiem šādā veidā ir droša, jo katrs pieprasījums izveido neatkarīgu Runner: aģents glabā konfigurāciju, bet Runner — izpildes stāvokli. SDK nodrošina vienlaicīgumu dabiski, un ziņojumu partijas apstrāde nozīmē korutīnu sakraušanu, izmantojot asyncio.gather. Šeit galvenā detaļa ir return_exceptions=True: bez tā viens neizdevies pieprasījums atceļ visu partiju. Ar to tu saņem kļūdas kā vērtības, saskaņo tās ar to sākotnējo ziņojumu un apstrādā deviņdesmit deviņus derīgos rezultātus.
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]):
"""Apstrādā vairākus pieprasījumus paralēli."""
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
Vairāku aģentu modeļi
Pārrauga (Supervisor) modelis
Pārsniedzot noteiktu mērogu, viens aģents ar piecpadsmit rīkiem kļūst neparedzams: tā instrukcijas uzbriest, tā izvēles pasliktinās. Pārrauga modelis sadala darbu specializētiem aģentiem — izpētei, analīzei, rakstīšanai — un deleģē maršrutēšanu specializētam aģentam, izmantojot nodošanu (handoff). Katrs speciālists saglabā īsas instrukcijas un modelim, kas piemērots tā uzdevumam: analīze mantot spriešanas modeli, savukārt pārraugs, kurš tikai izvēlas saņēmēju, darbojas uz ātra modeļa, jo tā lēmums ir atkarīgs no dažiem vārdiem.
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", # Ātrs maršrutēšanai
)
Konveijera (Pipeline) modelis
Kad secība ir zināma iepriekš, ļaut modelim lemt par ķēdi ir liekas izmaksas. Konveijera modelis savieno soļus tavā kodā: vākšana, analīze, rakstīšana. Konkurējošā analīze tādējādi sākas ar divām vienlaicīgi uzsāktām vākšanām — tīmeklim un CRM nav iemesla gaidīt vienam otru —, pēc tam viss tiek nodots analīzei, kuras izvade baro rakstīšanu. Tu iegūsti reproducējamu darbplūsmu, ko var izsekot soli pa solim, kuras kopējais ilgums ir vienāds ar lēnākās vākšanas ilgumu plus divi nākamie soļi.
async def competitive_analysis_pipeline(company: str):
# 1. solis: Paralēla datu vākšana
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}"""
# 2. solis: Analīze
analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")
# 3. solis: Ziņojums
report = await Runner.run(
writing_agent,
f"Write a competitive analysis report: {analysis.final_output}"
)
return report.final_output
Map-Reduce modelis
Trešais modelis risina apjoma problēmu, nevis sarežģītību. Divi tūkstoši klientu atsauksmju neietilpst vienā pieprasījumā un nevar tikt analizētas secīgi saprātīgā laikā. MAP fāze klasificē katru atsauksmi paralēli, izmantojot ātru modeli un tipētu izvadi; REDUCE fāze apkopo šīs klasifikācijas, kas ir daudz kompaktākas nekā sākotnējie teksti, un uztic sintēzi spējīgākam modelim. Izmaksas sabrūk, salīdzinot ar pilnu analīzi, jo lielāko apjoma daļu apstrādā lētākais modelis.
async def analyze_feedbacks(feedbacks: list[str]):
# MAP: analizē katru atsauksmi paralēli
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: rezultātu sintēze
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
Ātruma ierobežojumu pārvaldība
Divu tūkstošu vienlaicīgu izsaukumu uzsākšana neliek tiem ātrāk pabeigt darbu: pakalpojumu sniedzējs tevi noraida un tu zaudē partiju. Semafors ierobežo vienlaicīgu izpildījumu skaitu, un zemāk esošais pārvaldnieks pievieno eksponenciālu atkāpšanos, kas ierobežota līdz sešdesmit sekundēm, kad rodas ātruma ierobežojuma kļūda. Kļūdu skaitītājs tiek atiestatīts, tiklīdz izsaukums ir veiksmīgs, izvairoties no ilgtermiņa soda piemērošanas servisam par pārejošu incidentu.
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)
Izmaksu optimizācija lielos apjomos
Tad ir vēl rēķins. Divi sviras to samazina, nepasliktinot servisu. Pirmais ir nemaksāt par spriešanas modeli, lai atbildētu uz „kāds ir jūsu darba laiks”: meklēšanas tabula kartē sarežģītības līmeni ar piemērotu modeli, sākot no visekonomiskākā vienkāršiem jautājumiem līdz visspējīgākajam kritiskiem gadījumiem, ar noklusējumu visam neklasificētajam. Otrais izmanto atkārtošanos — klientu atbalstā tie paši jautājumi atgriežas simtiem reižu dienā, un kešatmiņa, kas indeksēta pēc ziņojuma haša, atgriež atbildi acumirklī un bez maksas. Rezervē šo kešatmiņu jautājumiem, kuru atbilde nav atkarīga ne no lietotāja, ne no laika: atgriešanas politika kešojas labi, pasūtījuma statuss — nekad.
# Modeļa stratēģija pēc sarežģītības
def choose_model(complexity: str) -> str:
models = {
"simple": "gpt-5.6-terra", # Vienkārši jautājumi: lēti
"medium": "gpt-5.6-terra", # Lielākā daļa gadījumu
"complex": "gpt-5.6-terra", # Ātra spriešana
"critical": "gpt-5.6-sol", # Kritiski gadījumi: maksimāla kvalitāte
}
return models.get(complexity, "gpt-5.6-terra")
# Kešatmiņa biežām atbildēm
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
Galvenās atziņas
- Iepriekš konfigurē savus aģentus startēšanas brīdī un atkārtoti izmanto tos starp pieprasījumiem
- SDK nodrošina vienlaicīgumu dabiski, izmantojot
asyncio.gather() - Pārrauga modelis koordinē specializētus aģentus, izmantojot nodošanas (handoffs)
- Map-reduce modelis paralēli apstrādā lielus apjomus
- Pārvaldi ātruma ierobežojumus ar semaforu un eksponenciālu atkāpšanos
- Optimizē izmaksas, izvēloties modeli pēc sarežģītības un izmantojot kešatmiņu
Pārbaudi savas zināšanas
Pirms mērogošanas pārbaudi savas zināšanas par aģentu arhitektūru.
1. Kādi ir Agents SDK pamatelementi?
Atbilde: Agent (loma un tās instrukcijas), Runner (izpildes cikls), Tool (spējas) un Guardrail (ievades/izvades validācijas) — jebkura SDK aģenta anatomija.
2. Kam paredzēti Guardrails?
Atbilde: Lai validētu to, kas ieiet un iziet no aģenta: filtrētu ārpus tēmām esošus pieprasījumus, kontrolētu izvades pirms to darbības — drošība, kas deklarēta arhitektūrā, nevis cerēta no uzvednes.
3. Kas ir handoff (nodošana)?
Atbilde: Sarunas pārsūtīšana no viena aģenta uz citu, specializētāku aģentu: vairāku aģentu orķestrācija, kur katrs aģents dara to, ko prot vislabāk, saglabājot kontekstu.
4. Kāpēc izsekošana (tracing) ir neatņemama ražošanā?
Atbilde: Tāpēc, ka aģents lemj dinamiski: bez soļu, izsaukto rīku un lēmumu pēdām atkļūdošana vai novērtēšana nav iespējama — izsekošanas vērtēšana precīzi novērtē šīs izpildes.
5. Kad jāpāriet uz vairāku aģentu arhitektūru?
Atbilde: Kad viens aģents uzkrāj pārāk daudz lomu un rīku: tu specializējies (trijaža, ekspertīze, izpilde) un orķestrē, izmantojot nodošanas — katrs aģents atkal kļūst vienkāršs un testējams.
SDK, guardrails, handoffs, izsekošana: sastatnes ir pabeigtas — iepriekš aprakstītā mērogošana tev pastāsta, kā to izvietot, to nevājinot.