Skalierung und Multi-Agenten-Architekturen
Auf dieser Seite
Skalierung und Multi-Agenten-Architekturen
Ihr Agent arbeitet für 10 Benutzer. Wie bringen Sie ihn auf 10.000? Die Herausforderungen ändern sich: Es geht nicht mehr nur um fehlende Anweisungen, sondern um Anbieter-Rate-Limits, Server-Speicher und Ihre monatliche Rechnung. In dieser letzten Lektion erfahren Sie, wie Sie Ihre Agenten skalieren, hochperformante Multi-Agenten-Architekturen entwerfen und Produktionsbeschränkungen im großen Maßstab verwalten.
Produktionsarchitektur
Der Agenten-Backend mit FastAPI
Die erste strukturelle Entscheidung betrifft den Lebenszyklus des Agenten. Das Erstellen eines Agent für jede Anfrage verschwendet Zeit und streut die Konfiguration; FastAPIs lifespan ermöglicht es, diese einmal beim Start zu initialisieren und sie in einem Registry zu halten, die nach Typ indiziert ist. Die Route liest den angeforderten Typ, lehnt diesen sauber ab, falls er nicht existiert, und streamt die Antwort: run_streamed sendet Deltas, während die Generierung fortschreitet, sodass der Text sofort auf dem Bildschirm erscheint, anstatt den Nutzer acht Sekunden lang auf einen Ladebalken starren zu lassen.
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 von vorab konfigurierten Agenten
agents_registry = {}
@asynccontextmanager
async def lifespan(app: FastAPI):
# Initialisierung der Agenten beim 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")
Verwaltung der Parallelverarbeitung
Das Teilen von Agent-Objekten über alle Anfragen hinweg ist sicher, da jede Anfrage einen unabhängigen Runner erstellt: Der Agent hält die Konfiguration, der Runner den Ausführungsstatus. Die SDK-Verarbeitung der Parallelverarbeitung erfolgt nativ, und die Verarbeitung einer Nachrichtenserie bedeutet das Stapeln von Koroutinen in asyncio.gather. Der entscheidende Detailpunkt ist hier return_exceptions=True: Ohne dieses Flag würde eine einzelne fehlgeschlagene Anfrage den gesamten Batch stornieren. Mit diesem Flag erhalten Sie Fehler als Werte, können diese ihren ursprünglichen Nachrichten zuordnen und die 99 gültigen Ergebnisse verarbeiten.
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]):
"""Process multiple requests in parallel."""
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
Multi-Agenten-Muster
Supervisor-Muster
Ab einer bestimmten Größe wird ein einzelner Agent mit 15 Tools unvorhersehbar: Seine Anweisungen schwellen an, seine Entscheidungen verschlechtern sich. Das Supervisor-Muster teilt die Arbeit unter spezialisierte Agenten auf – Recherche, Analyse, Schreiben – und überträgt die Routing-Entscheidungen einem dedizierten Agenten via Handoff. Jeder Spezialist behält kurze Anweisungen und ein Modell bei, das für seine Aufgabe geeignet ist: Die Analyse erbt ein Reasoning-Modell, während der Supervisor, der nur einen Empfänger auswählt, auf einem schnellen Modell läuft, da seine Entscheidung nur von wenigen Wörtern abhängt.
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", # Fast for routing
)
Pipeline-Muster
Wenn die Sequenz im Voraus bekannt ist, ist es eine unnötige Ausgabe, einem Modell die Kette entscheiden zu lassen. Das Pipeline-Muster verdrahtet die Schritte in Ihrem Code: Sammeln, Analysieren, Schreiben. Eine Wettbewerbsanalyse beginnt daher mit zwei gleichzeitig gestarteten Sammlungen – das Web und das CRM müssen nicht aufeinander warten – und überträgt alles an die Analyse, deren Ausgabe das Schreiben speist. Sie erhalten einen reproduzierbaren Workflow, der Schritt für Schritt nachvollziehbar ist, dessen Gesamtdauer die des langsamsten Sammelns plus den beiden folgenden Schritten entspricht.
async def competitive_analysis_pipeline(company: str):
# Schritt 1: Parallele Datensammlung
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}"""
# Schritt 2: Analyse
analysis = await Runner.run(analysis_agent, f"Analyze this data: {data}")
# Schritt 3: Bericht
report = await Runner.run(
writing_agent,
f"Write a competitive analysis report: {analysis.final_output}"
)
return report.final_output
Map-Reduce-Muster
Das dritte Muster adressiert ein Volumenproblem statt einer Komplexitätsproblematik. Zwei tausend Kundenverbalisierungen passen nicht in eine einzelne Anfrage und können nicht in angemessener Zeit sequentiell analysiert werden. Die MAP-Phase klassifiziert jedes Feedback parallel mit einem schnellen Modell und einem typisierten Output; die REDUCE-Phase aggregiert diese Klassifikationen, die weit kompakter sind als die Originaltexte, und überträgt die Synthese einem leistungsfähigeren Modell. Die Kosten kollabieren im Vergleich zur vollständigen Analyse, da der Großteil des Volumens vom günstigsten Modell verarbeitet wird.
async def analyze_feedbacks(feedbacks: list[str]):
# MAP: Analyse jedes Feedbacks parallel
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: Synthese der Ergebnisse
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
Verwaltung von Rate-Limits
Das Starten von zwei tausend gleichzeitigen Aufrufen macht sie nicht schneller fertig: Der Anbieter lehnt Sie ab und Sie verlieren den Batch. Ein Semaphore begrenzt die Anzahl der parallelen Ausführungen, und der Manager unten fügt einen exponentiellen Backoff hinzu, der bei einem Limit-Fehler auf 60 Sekunden begrenzt ist. Der Fehlerzähler wird sofort zurückgesetzt, sobald ein Aufruf erfolgreich ist, wodurch eine langfristige Strafe für den Dienst durch ein vorübergehendes Ereignis vermieden wird.
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)
Kostenoptimierung im großen Maßstab
Dann gibt es die Rechnung. Zwei Hebel reduzieren sie, ohne den Service zu verschlechtern. Der erste besteht darin, kein Reasoning-Modell dafür zu bezahlen, auf „was sind Ihre Öffnungszeiten” zu antworten: Eine Lookup-Tabelle ordnet das Komplexitätsniveau dem passenden Modell zu, vom wirtschaftlichsten für einfache Fragen bis hin zum leistungsfähigsten für kritische Fälle, mit einem Standardwert für alles, was nicht klassifiziert ist. Der zweite nutzt Wiederholungen aus – im Kundensupport werden die gleichen Fragen hunderte Male am Tag gestellt, und ein Cache, der auf einem Nachricht-Hash indiziert ist, liefert die Antwort sofort und kostenlos zurück. Reservieren Sie diesen Cache für Fragen, deren Antwort weder vom Nutzer noch von der Zeit abhängt: Eine Rückgabepolitik wird gut gecacht, der Status einer Bestellung niemals.
# Modellstrategie nach Komplexität
def choose_model(complexity: str) -> str:
models = {
"simple": "gpt-5.6-terra", # Einfache Fragen: günstig
"medium": "gpt-5.6-terra", # Die meisten Fälle
"complex": "gpt-5.6-terra", # Schnelles Reasoning
"critical": "gpt-5.6-sol", # Kritische Fälle: maximale Qualität
}
return models.get(complexity, "gpt-5.6-terra")
# Cache für häufige Antworten
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
Kernaussagen
- Konfigurieren Sie Ihre Agenten beim Start vorab und nutzen Sie sie über Anfragen hinweg
- Die SDK-Verarbeitung der Parallelverarbeitung erfolgt nativ via
asyncio.gather() - Das Supervisor-Muster koordiniert spezialisierte Agenten via Handoffs
- Das Map-Reduce-Muster parallelisiert die Verarbeitung großer Volumina
- Verwalten Sie Rate-Limits mit einem Semaphore und exponentiellem Backoff
- Optimieren Sie Kosten durch Modellauswahl nach Komplexität und Caching
Testen Sie Ihr Wissen
Bevor Sie hochskalieren, überprüfen Sie Ihr Wissen zur Agentenarchitektur.
1. Was sind die Bausteine des Agents SDK?
Antwort: Agent (die Rolle und seine Anweisungen), Runner (der Ausführungslauf), Tool (die Fähigkeiten) und Guardrail (Eingabe-/Ausgabevalidierungen) – die Anatomie eines jeden SDK-Agenten.
2. Wozu dienen Guardrails?
Antwort: Um zu validieren, was in den Agenten ein- und ausgeht: Filtern Sie Anfragen außerhalb des Geltungsbereichs, steuern Sie Ausgaben, bevor sie wirken – Sicherheit, die in der Architektur deklariert ist, nicht, die man vom Prompt hofft.
3. Was ist ein Handoff?
Antwort: Die Übertragung eines Gesprächs von einem Agenten zu einem anderen, spezialisierten Agenten: Multi-Agenten-Orchestrierung, bei der jeder Agent das tut, wofür er am besten geeignet ist, wobei der Kontext folgt.
4. Warum ist Tracing in der Produktion unverzichtbar?
Antwort: Weil ein Agent dynamisch entscheidet: Ohne Spuren der Schritte, der aufgerufenen Tools und der Entscheidungen ist das Debuggen oder die Evaluation unmöglich – Trace-Grading bewertet diese Ausführungen präzise.
5. Wann sollten Sie zu einer Multi-Agenten-Architektur wechseln?
Antwort: Wenn ein einzelner Agent zu viele Rollen und Tools akkumuliert: Sie spezialisieren (Triage, Expertise, Ausführung) und orchestrieren via Handoffs – jeder Agent wird wieder einfach und testbar.
SDK, Guardrails, Handoffs, Tracing: Das Gerüst ist vollständig – die Skalierung oben sagt Ihnen, wie Sie es deployen, ohne es zu schwächen.