Mastelis ir kelių agentų architektūros
Šiame puslapyje
Mastelis ir kelių agentų architektūros
Tavo agentas veikia 10-iai vartotojų. Kaip priversti jį veikti 10 000-čiui? Iššūkiai keičiasi: problema jau nebe tai, kad nepavyksta instrukcijos, o tiekėjo greičio apribojimai, serverio atmintis ir tavo mėnesio sąskaita. Šioje paskutinėje pamokoje sužinosi, kaip mastelinti savo agentus, kurti našias kelių agentų architektūras ir valdyti gamybos apribojimus dideliu mastu.
Gamybos architektūra
Agento galinė dalis naudojant „FastAPI“
Pirmasis struktūrinis sprendimas susijęs su agento gyvavimo ciklu. Kiekvienam užklausos prašymui kurti naują Agent švaisto laiką ir išbarsto konfigūraciją; „FastAPI“ lifespan leidžia juos sukurti vieną kartą paleidimo metu ir laikyti registre, indeksuotame pagal tipą. Maršrutas nuskoito prašomą tipą, švariai jį atmeta, jei tokio nėra, ir tada transliuoja atsakymą: run_streamed generavimo metu išleidžia deltas, todėl tekstas ekrane atsiranda iškart, o vartotojas nelaukia aštuonias sekundes žiūrėdamas į besisukantį krovimo indikatorių.
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
# Iš anksto sukonfigūruotų agentų baseinas
agents_registry = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Inicijuoti agentus paleidimo metu
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")
Lygiagretumo valdymas
Bendrinti Agent objektus visiems užklausoms taip, kaip parodyta aukščiau, yra saugu, nes kiekviena užklausa sukuria nepriklausomą „Runner“: agentas saugo konfigūraciją, o „Runner“ – vykdymo būseną. SDK lygiagretumą tvarko natūraliai, o žinučių grupės apdorojimas reiškia korutinų sudėliojimą naudojant asyncio.gather. Čia esminė detalė yra return_exceptions=True: be jo viena nepavykusi užklausa atšaukia visą grupę. Su juo gauni klaidas kaip reikšmes, susieji jas su originalia žinute ir apdoroji devyniasdešimt devynis galiojančius rezultatus.
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]):
"""Apdoroti kelias užklausas lygiagrečiai."""
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
Kelių agentų šablonai
Prižiūrėtojo šablonas
Viršijus tam tikrą mastelį, vienas agentas su penkiolika įrankių tampa nenuspėjamas: jo instrukcijos išsipučia, o pasirinkimai prastėja. Prižiūrėtojo šablonas darbą padalija specializuotiems agentams – tyrimams, analizei, rašymui – ir deleguoja maršrutizavimą specialiam agentui per perdavimą (handoff). Kiekvienas specialistas turi trumpas instrukcijas ir modeliui, pritaikytam jo užduočiai: analizė paveldi samprotavimo modelį, o prižiūrėtojas, kuris tik pasirenka gavėją, veikia greitu modeliu, nes jo sprendimas priklauso nuo kelių žodžių.
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", # Greitas maršrutizavimui
)
Vamzdyno šablonas
Kai seka žinoma iš anksto, leisti modeliui nuspręsti grandinę yra nereikalingos išlaidos. Vamzdyno šablonas sujungia žingsnius tavo kode: surinkti, analizuoti, rašyti. Taigi konkurencinė analizė prasideda dviem lygiagrečiai paleistais surinkimais – internetui ir CRM nėra priežasties laukti vienas kito – tada viskas perduodama analizei, kurios išvestis maitina rašymą. Gauni atkuriamą darbo eigą, kurią galima atsekti žingsnis po žingsnio, o bendra trukmė yra lygi lėčiausio surinkimo trukmei plius du sekantys žingsniai.
async def competitive_analysis_pipeline(company: str):
# 1 žingsnis: Lygiagretus duomenų rinkimas
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 žingsnis: Analizė
analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")
# 3 žingsnis: Ataskaita
report = await Runner.run(
writing_agent,
f"Write a competitive analysis report: {analysis.final_output}"
)
return report.final_output
„Map-Reduce“ šablonas
Trečiasis šablonas sprendžia ne sudėtingumo, o apimties problemą. Du tūkstančiai klientų atsiliepimų netelpa į vieną užklausą ir negali būti analizuojami nuosekliai per protingą laiką. MAP fazė lygiagrečiai klasifikuoja kiekvieną atsiliepimą naudodama greitą modelį ir tipizuotą išvestį; REDUCE fazė agreguoja šias klasifikacijas, kurios yra daug kompaktiškesnės nei originalūs tekstai, ir patiki sintezę pajėgesniam modeliui. Kaina smarkiai krenta, palyginti su pilna analize, nes didžioji dalis apimties apdorojama pigiausiu modeliu.
async def analyze_feedbacks(feedbacks: list[str]):
# MAP: analizuoti kiekvieną atsiliepimą lygiagrečiai
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: apibendrinti rezultatus
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
Greičio apribojimų valdymas
Dviejų tūkstančių vienalaikių kvietimų paleidimas nepriverčia jų greičiau baigtis: tiekėjas tave atmeta ir prarandi visą grupę. Semafonas apriboja vienalaikių vykdymų skaičių, o toliau pateiktas valdytojas, įvykus greičio apribojimo klaidai, taiko eksponentinį delsą, neviršijantį šešiasdešimties sekundžių. Klaidų skaitiklis iš naujo nustatomas iškart, kai kvietimas pavyksta, taip išvengiant ilgalaikės baudos servisui dėl laikino incidento.
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)
Išlaidų optimizavimas dideliu mastu
Tuomet lieka sąskaita. Du svertai ją sumažina nepabloginant paslaugos. Pirmasis – nemokėti samprotavimo modeliui už atsakymą į klausimą „kokios jūsų darbo valandos“: paieškos lentelė susieja sudėtingumo lygį su tinkamu modeliu, nuo ekonomiškiausio paprastiems klausimams iki pajėgiausio kritiniais atvejais, su numatytuoju variantu viskam, kas neklasifikuota. Antrasis išnaudoja pasikartojimą – klientų aptarnavime tie patys klausimai grįžta šimtus kartų per dieną, o talpykla, indeksuota pagal žinutės maišą (hash), grąžina atsakymą akimirksniu ir nemokamai. Šią talpyklą rezervuok klausimams, kurių atsakymas nepriklauso nei nuo vartotojo, nei nuo laiko: grąžinimo politika puikiai talpinama, o užsakymo būsena – niekada.
# Modelio strategija pagal sudėtingumą
def choose_model(complexity: str) -> str:
models = {
"simple": "gpt-5.6-terra", # Paprasti klausimai: pigu
"medium": "gpt-5.6-terra", # Dauguma atvejų
"complex": "gpt-5.6-terra", # Greitas samprotavimas
"critical": "gpt-5.6-sol", # Kritiniai atvejai: maksimali kokybė
}
return models.get(complexity, "gpt-5.6-terra")
# Talpykla dažniems atsakymams
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
Svarbiausi punktai
- Iš anksto sukonfigūruok savo agentus paleidimo metu ir pakartotinai naudok juos per užklausas
- SDK lygiagretumą tvarko natūraliai naudodamas
asyncio.gather() - Prižiūrėtojo šablonas koordinuoja specializuotus agentus per perdavimus (handoffs)
- „Map-reduce“ šablonas lygiagrečiai apdoroja didelės apimties duomenis
- Valdyk greičio apribojimus naudodamas semafoną ir eksponentinį delsą
- Optimizuok išlaidas pasirenkant modelius pagal sudėtingumą ir naudodamas talpyklą
Patikrink savo žinias
Prieš didindamas mastelį, patikrink savo žinias apie agentų architektūrą.
1. Kokie yra „Agents SDK“ statybiniai blokai?
Atsakymas: Agentas (vaidmuo ir jo instrukcijos), „Runner“ (vykdymo ciklas), Įrankis (galimybės) ir Apsaugos mechanizmas (įvesties/išvesties patikros) – bet kurio SDK agento anatomija.
2. Kam skirti apsaugos mechanizmai (Guardrails)?
Atsakymas: Patikrinti tai, kas patenka į agentą ir išeina iš jo: filtruoti už klausimų ribų esančius prašymus, valdyti išvestį prieš jai veikiant – saugumas deklaruojamas architektūroje, o ne tikimasi jo iš prompto.
3. Kas yra perdavimas (handoff)?
Atsakymas: Pokalbio perdavimas iš vieno agento kitam, labiau specializuotam: kelių agentų orkestracija, kur kiekvienas agentas daro tai, ką geriausiai moka, o kontekstas keliauja kartu.
4. Kodėl sekimas (tracing) gamyboje yra būtinas?
Atsakymas: Nes agentas sprendžia dinamiškai: be žingsnių, iškviestų įrankių ir sprendimų pėdsakų, derinimas ar vertinimas neįmanomas – sekimo vertinimas tiksliai įvertina šiuos vykdymus.
5. Kada reikėtų pereiti prie kelių agentų architektūros?
Atsakymas: Kai vienas agentas sukaupia per daug vaidmenų ir įrankių: tu specializuojiesi (triage, ekspertizė, vykdymas) ir orkestruoji per perdavimus – kiekvienas agentas vėl tampa paprastas ir lengvai testuojamas.
SDK, apsaugos mechanizmai, perdavimai, sekimas: pastoliai užbaigti – aukščiau pateiktas mastelinimas nurodo, kaip juos diegti nesilpninant.