Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Skalning och fleragentarkitekturer

Lektion 25 av 25 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Skalning och fleragentarkitekturer
  2. Produktionsarkitektur
  3. Mönster för flera agenter
  4. Hantering av hastighetsbegränsningar
  5. Kostnadsoptimering i stor skala
  6. Viktiga punkter
  7. Testa dina kunskaper

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.