Asünkroonsed ja paralleelsed tööriistad
Sellel lehel
Asünkroonsed ja paralleelsed tööriistad
Tootmiskeskkonnas kutsuvad sinu tööriistad väliseid API-sid, päringuid andmebaasidest või teevad sisend/väljund (I/O) toiminguid. Need toimingud võtavad aega ja see aeg liitub: agent, mis aheldab viis ühesekundilist kõnet, vajab vastamiseks viis sekundit. Tööriistade asünkroonseks muutmine ja SDK loomuliku paralleelsuse ärakasutamine on see, mis eristab demo-versiooni kasutatavast teenusest.
Asünkroonsed tööriistad
Dekoraator @function_tool toetab loomupäraselt async funktsioone. Konfiguratsiooni pole vaja: deklareeri async def, kasuta asünkroonset HTTP-klienti ja SDK hoolitseb ülejäänu eest.
import httpx
from agents import function_tool
@function_tool
async def search_company(name: str) -> str:
"""Otsib ettevõtte teavet Societe.com API kaudu."""
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"Ettevõte: {data['name']}, SIREN: {data['siren']}, Käive: {data['revenue']}"
return f"Tulemusi '{name}' jaoks ei leitud"
@function_tool
async def verify_solvency(siren: str) -> str:
"""Kontrollib ettevõtte maksevõimet selle SIREN-numbri põhjal."""
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"Maksevõime skoor: {data['score']}/100, risk: {data['risk_level']}"
Kui Runner käivitab asünkroonse tööriista, ei blokeeri see sündmuste tsüklit. FastAPI serveris tähendab see, et teised päringud töötlevad edasi, samal ajal kui sinu agent ootab Societe.com API vastust.
Automaatne paralleelsus
Kaks sõltumatut asünkroonset tööriista saavad käivituda samaaegselt. Mudel otsustab selle ja sinu juhised saavad seda sõnaselgelt soodustada.
from agents import Agent, Runner
agent = Agent(
name="B2B Analüütik",
instructions="""Sa analüüsid ettevõtteid äriotsuste tegemiseks.
Kui palutakse ettevõtet analüüsida, too välja selle teave
JA kontrolli selle maksevõimet samaaegselt.""",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
)
# Mudel käivitab mõlemad tööriistad paralleelselt
result = await Runner.run(
agent,
"Analüüsi ettevõtet Acme Corp (SIREN 123456789)"
)
Kuna SIREN on päringus juba olemas, ei oota maksevõime kontroll ettevõtte otsingu lõppu: SDK käivitab mõlemad kõned samaaegselt. Kogu aeg võrdub aeglaseima tööriista kestusega, mitte mõlema summaga.
Paralleelsuse juhtimine
Paralleelsus pole alati soovitav. Kui sinu tööriistad kirjutavad samale kirjele või kui andmete järjepidevuse huvides on oluline järjekord, sunni järjestikust täitmist.
from agents import Agent
agent = Agent(
name="Ettevaatlik agent",
instructions="Käivita tööriistad ükshaaval, et tagada andmete järjepidevus.",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
parallel_tool_calls=False, # Sunnib järjestikust täitmist
)
Parameeter parallel_tool_calls=False sunnib mudelit kutsuma korraga ainult ühte tööriista. Sa vahetad latentsuse ennustatavuse vastu.
Muster: Paralleelsete tulemuste agregeerimine
Kõige levinum praktiline juhtum hõlmab andmete kogumist mitmest allikast sama üksuse kohta. Siin pole linna ilm ja kultuuriprogramm omavahel seotud, kuid vastus vajab mõlemat.
import json
from agents import Agent, Runner, function_tool
@function_tool
async def get_weather(city: str) -> str:
"""Toob linna praeguse ilma."""
# Simulatsioon – tootmises: ilma API kõne
weather_data = {
"Paris": {"temp": 22, "conditions": "sunny"},
"Lyon": {"temp": 19, "conditions": "cloudy"},
"Marseille": {"temp": 26, "conditions": "sunny"},
}
data = weather_data.get(city, {"temp": 0, "conditions": "unknown"})
return json.dumps({"city": city, **data}, ensure_ascii=False)
@function_tool
async def get_events(city: str) -> str:
"""Toob linna eelseisvad üritused."""
events = {
"Paris": ["Kontsert Stade de France'il", "Näitus Louvre'is"],
"Lyon": ["Valguste festival", "Gastronoomiamess"],
"Marseille": ["Vahemere regatt"],
}
return json.dumps({
"city": city,
"events": events.get(city, [])
}, ensure_ascii=False)
agent = Agent(
name="Reisiagent",
instructions="""Sa oled reisiagent. Kui palutakse
linna kohta soovitusi, too välja ilm JA üritused
samaaegselt, et pakkuda terviklikku nõu.""",
tools=[get_weather, get_events],
model="gpt-5.6-terra",
)
# Mudel kutsub mõlemad tööriistad iga linna jaoks paralleelselt
result = await Runner.run(
agent,
"Soovin sel nädalavahetusel Pariisi külastada. Mida soovitad?"
)
print(result.final_output)
Mõlemad tööriistad tagastavad JSON-i, mis muudab mudelile andmete uuesti kombineerimise lihtsamaks. Pane tähele juhiste sõnastust: „JA … samaaegselt“ käivitab paralleelse kõne, mitte laiska ahelat.
Aegumised ja vastupidavus
API, mis kunagi ei vasta, blokeerib sinu agenti sama kindlalt kui sünkroonne tööriist. Piira iga aeglast kõnet aegumisega ja muuda tõrked arusaadavateks sõnumiteks.
import asyncio
from agents import function_tool
@function_tool
async def slow_api_call(query: str) -> str:
"""Kutsub API-d, mis võib olla aeglane."""
try:
async with asyncio.timeout(5): # 5-sekundiline aegumine
# Sinu API kõne siia
await asyncio.sleep(0.1) # Simulatsioon
return f"Tulemus päringule '{query}'"
except asyncio.TimeoutError:
return "API ei vastanud õigeaegselt. Palun proovi uuesti."
Jõudlus: Paralleelsuse mõju
Vaata skaalat perspektiivi. Kolm 500 ms kestvat tööriista, mis käivitatakse järjest, maksavad 1500 ms; samad kolm tööriista paralleelselt maksavad umbes 500 ms – aeglaseima kestuse. Agendi jaoks, mis kasutab palju tööriistu, on erinevus praktikas koheselt märgatav.
Peamised punktid
- Kasuta
asynctööriistade puhul, mis teevad võrgu- või I/O-kõnesid - SDK käivitab sõltumatud tööriistad automaatselt paralleelselt
parallel_tool_calls=Falsesunnib vajadusel järjestikust täitmist- Lisa vastupidavuse huvides aegumised kasutades
asyncio.timeout() - Paralleelsus võib vähendada latentsust tööriistade arvu võrra