Asynchrone und parallele Werkzeuge
Auf dieser Seite
Asynchrone und parallele Werkzeuge
In der Produktion rufen Ihre Werkzeuge externe APIs auf, abfragen Datenbanken oder führen I/O-Operationen durch. Diese Vorgänge benötigen Zeit, und diese Zeit summiert sich: Ein Agent, der fünf einsekündige Aufrufe hintereinander ausführt, benötigt fünf Sekunden für eine Antwort. Das Asynchronisieren von Werkzeugen und die Nutzung der nativen Parallelität des SDKs trennen eine Demo von einem einsetzbaren Service.
Asynchrone Werkzeuge
Der @function_tool-Dekorator unterstützt asynchrone Funktionen nativ. Es ist keine Konfiguration erforderlich: Definieren Sie async def, verwenden Sie einen asynchronen HTTP-Client, und das SDK übernimmt den Rest.
import httpx
from agents import function_tool
@function_tool
async def search_company(name: str) -> str:
"""Sucht Unternehmensinformationen über die Societe.com-API."""
async with httpx.AsyncClient() as client:
response = await client.get(
"https://api.societe.com/v1/search",
params={"q": name},
timeout=10,
)
if response.status_code == 200:
data = response.json()
return f"Unternehmen: {data['name']}, SIREN: {data['siren']}, Umsatz: {data['revenue']}"
return f"Keine Ergebnisse für '{name}'"
@function_tool
async def verify_solvency(siren: str) -> str:
"""Überprüft die Solvenz eines Unternehmens anhand seiner SIREN-Nummer."""
async with httpx.AsyncClient() as client:
response = await client.get(
f"https://api.credit-scoring.com/v1/{siren}",
timeout=10,
)
data = response.json()
return f"Solvenz-Score: {data['score']}/100, Risiko: {data['risk_level']}"
Wenn der Runner ein asynchrones Werkzeug ausführt, blockiert dies den Event-Loop nicht. In einem FastAPI-Server bedeutet dies, dass andere Anfragen weiterverarbeitet werden, während Ihr Agent auf die Antwort der Societe.com-API wartet.
Automatische Parallelität
Zwei unabhängige asynchrone Werkzeuge können gleichzeitig ausgeführt werden. Das Modell entscheidet dies, und Ihre Anweisungen können dies explizit fördern.
from agents import Agent, Runner
agent = Agent(
name="B2B Analyst",
instructions="""Sie analysieren Unternehmen für geschäftliche Entscheidungen.
Wenn nach einer Analyse eines Unternehmens gefragt wird,
rufen Sie dessen Informationen AB UND prüfen Sie gleichzeitig
dessen Solvenz.""",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
)
# Das Modell startet beide Werkzeuge parallel
result = await Runner.run(
agent,
"Analysieren Sie das Unternehmen Acme Corp (SIREN 123456789)"
)
Da die SIREN-Nummer in der Abfrage bereitgestellt wird, wartet die Solvenzprüfung nicht auf die Unternehmenssuche: Das SDK führt beide Aufrufe gleichzeitig aus. Die Gesamtzeit entspricht der Dauer des langsamsten Werkzeugs, nicht der Summe beider.
Kontrolle der Parallelität
Parallelität ist nicht immer wünschenswert. Wenn Ihre Werkzeuge dieselbe Datenschrift überschreiben oder wenn die Reihenfolge für die Datenkonsistenz wichtig ist, erzwingen Sie die sequenzielle Ausführung.
from agents import Agent
agent = Agent(
name="Vorsichtiger Agent",
instructions="Führen Sie Werkzeuge nacheinander aus, um die Datenkonsistenz zu gewährleisten.",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
parallel_tool_calls=False, # Erzwingt sequenzielle Ausführung
)
Der Parameter parallel_tool_calls=False zwingt das Modell, nur ein Werkzeug nach dem anderen aufzurufen. Sie opfern Latenz gegen Vorhersagbarkeit.
Muster: Aggregation paralleler Ergebnisse
Der häufigste praktische Fall umfasst das Sammeln von Daten aus mehreren Quellen für dieselbe Entität. Hier haben das Wetter einer Stadt und das kulturelle Programm nichts miteinander zu tun, aber die Antwort benötigt beides.
import json
from agents import Agent, Runner, function_tool
@function_tool
async def get_weather(city: str) -> str:
"""Holt das aktuelle Wetter für eine Stadt."""
# Simulation - in der Produktion: Wetter-API-Aufruf
weather_data = {
"Paris": {"temp": 22, "conditions": "sonnig"},
"Lyon": {"temp": 19, "conditions": "bewölkt"},
"Marseille": {"temp": 26, "conditions": "sonnig"},
}
data = weather_data.get(city, {"temp": 0, "conditions": "unbekannt"})
return json.dumps({"city": city, **data}, ensure_ascii=False)
@function_tool
async def get_events(city: str) -> str:
"""Holt bevorstehende Veranstaltungen in einer Stadt."""
events = {
"Paris": ["Konzert im Stade de France", "Ausstellung im Louvre"],
"Lyon": ["Festival der Lichter", "Gastronomiemesse"],
"Marseille": ["Mittelmeer-Regatta"],
}
return json.dumps({
"city": city,
"events": events.get(city, [])
}, ensure_ascii=False)
agent = Agent(
name="Reiseagent",
instructions="""Sie sind ein Reiseagent. Wenn nach Empfehlungen
für eine Stadt gefragt wird, rufen Sie Wetter UND Veranstaltungen
gleichzeitig auf, um vollständige Beratung zu geben.""",
tools=[get_weather, get_events],
model="gpt-5.6-terra",
)
# Das Modell ruft beide Werkzeuge für jede Stadt parallel auf
result = await Runner.run(
agent,
"Ich möchte dieses Wochenende nach Paris reisen. Was empfehlen Sie?"
)
print(result.final_output)
Beide Werkzeuge geben JSON zurück, was es für das Modell einfacher macht, die Daten neu zu kombinieren. Beachten Sie die Formulierung der Anweisung: Der Ausdruck “UND … gleichzeitig” löst den parallelen Aufruf aus, anstatt eine träge Kette zu bilden.
Timeouts und Resilienz
Eine API, die niemals antwortet, blockiert Ihren Agenten genauso sicher wie ein synchrones Werkzeug. Begrenzen Sie jeden langsamen Aufruf mit einem Timeout und verwandeln Sie Fehler in verständliche Nachrichten.
import asyncio
from agents import function_tool
@function_tool
async def slow_api_call(query: str) -> str:
"""Ruft eine API auf, die langsam sein könnte."""
try:
async with asyncio.timeout(5): # 5-Sekunden-Timeout
# Ihr API-Aufruf hier
await asyncio.sleep(0.1) # Simulation
return f"Ergebnis für '{query}'"
except asyncio.TimeoutError:
return "Die API hat nicht rechtzeitig geantwortet. Bitte versuchen Sie es erneut."
Leistung: Auswirkung der Parallelität
Lassen Sie uns die Größenordnung ins Verhältnis setzen. Drei Werkzeuge mit jeweils 500 ms, die sequenziell ausgeführt werden, kosten 1500 ms; dieselben drei Werkzeuge in Parallelität kosten etwa 500 ms – die Dauer des langsamsten Werkzeugs. Für einen Agenten, der viele Werkzeuge verwendet, ist der Unterschied in der Praxis sofort spürbar.
Kernaussagen
- Verwenden Sie
asyncfür Werkzeuge, die Netzwerk- oder I/O-Aufrufe tätigen - Das SDK führt unabhängige Werkzeuge automatisch parallel aus
parallel_tool_calls=Falseerzwingt sequenzielle Ausführung, wenn nötig- Fügen Sie Timeouts mit
asyncio.timeout()für Resilienz hinzu - Parallelität kann die Latenz durch die Anzahl der Werkzeuge teilen