Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Mērogošana un vairāku aģentu arhitektūras

Nodarbība 25 no 25 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērogošana un vairāku aģentu arhitektūras
  2. Ražošanas arhitektūra
  3. Vairāku aģentu modeļi
  4. Ātruma ierobežojumu pārvaldība
  5. Izmaksu optimizācija lielos apjomos
  6. Galvenās atziņas
  7. Pārbaudi savas zināšanas

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.