Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Mastelis ir kelių agentų architektūros

Paskaita 25 iš 25 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Mastelis ir kelių agentų architektūros
  2. Gamybos architektūra
  3. Kelių agentų šablonai
  4. Greičio apribojimų valdymas
  5. Išlaidų optimizavimas dideliu mastu
  6. Svarbiausi punktai
  7. Patikrink savo žinias

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.