Orodja za asinhrono in vzporedno izvajanje
Na tej strani
Orodja za asinhrono in vzporedno izvajanje
V produkcijskem okolju tvoja orodja kličejo zunanje API-je, poizvedujejo po bazah podatkov ali izvajajo operacije vhoda/izhoda (I/O). Te operacije trajajo, čas pa se sešteva: agent, ki zaporedno izvede pet klicev po eno sekundo, potrebuje pet sekund za odgovor. Prav asinhronost orodij in izkoriščanje samodejnega vzporednega izvajanja v SDK-ju ločita demonstracijski projekt od uporabne storitve.
Asinhrona orodja
Dekorator @function_tool samodejno podpira funkcije async. Ni potrebna nobena dodatna konfiguracija: deklariraj async def, uporabi asinhronega HTTP odjemalca in SDK bo poskrbel za ostalo.
import httpx
from agents import function_tool
@function_tool
async def search_company(name: str) -> str:
"""Poišče informacije o podjetju prek API-ja Societe.com."""
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"Podjetje: {data['name']}, SIREN: {data['siren']}, Prihodek: {data['revenue']}"
return f"Ni rezultatov za '{name}'"
@function_tool
async def verify_solvency(siren: str) -> str:
"""Preveri bonitetno sposobnost podjetja na podlagi številke SIREN."""
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"Bonitetna ocena: {data['score']}/100, tveganje: {data['risk_level']}"
Ko Runner izvede asinhrono orodje, ne blokira zanke dogodkov (event loop). To v strežniku FastAPI pomeni, da se drugi zahtevki obdelujejo naprej, medtem ko tvoj agent čaka na odgovor API-ja Societe.com.
Samodejno vzporedno izvajanje
Dve neodvisni asinhroni orodji se lahko izvedeta hkrati. O tem odloča model, tvoja navodila pa ga lahko k temu izrecno spodbudijo.
from agents import Agent, Runner
agent = Agent(
name="B2B Analitik",
instructions="""Analiziraš podjetja za poslovne odločitve.
Ko te prosijo za analizo podjetja, pridobi njegove informacije
IN hkrati preveri njegovo bonitetno sposobnost.""",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
)
# Model bo zagnal obe orodji vzporedno
result = await Runner.run(
agent,
"Analiziraj podjetje Acme Corp (SIREN 123456789)"
)
Ker je številka SIREN podana že v poizvedbi, preverjanje bonitete ne čaka na iskanje podjetja: SDK izvede oba klica hkrati. Skupni čas je enak trajanju najpočasnejšega orodja, ne vsoti obeh.
Nadzor vzporednosti
Vzporedno izvajanje ni vedno zaželeno. Če tvoja orodja pišejo v isti zapis ali če je za skladnost podatkov pomemben vrstni red, vsili zaporedno izvajanje.
from agents import Agent
agent = Agent(
name="Previdni agent",
instructions="Izvedi orodja eno za drugim, da zagotoviš skladnost podatkov.",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
parallel_tool_calls=False, # Vsili zaporedno izvajanje
)
Parameter parallel_tool_calls=False prisili model, da kliče le eno orodje naenkrat. Zamenjaš latenco za predvidljivost.
Vzorec: Združevanje vzporednih rezultatov
Najpogostejši praktični primer je zbiranje podatkov iz več virov za isto entiteto. Tukaj vreme in kulturni dogodki v mestu nimata nič skupnega, vendar odgovor potrebuje oboje.
import json
from agents import Agent, Runner, function_tool
@function_tool
async def get_weather(city: str) -> str:
"""Pridobi trenutno vreme za mesto."""
# Simulacija - v produkciji: klic API-ja za vreme
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:
"""Pridobi prihajajoče dogodke v mestu."""
events = {
"Paris": ["Koncert na Stade de France", "Razstava v Louvru"],
"Lyon": ["Festival luči", "Sejem gastronomije"],
"Marseille": ["Sredozemska regata"],
}
return json.dumps({
"city": city,
"events": events.get(city, [])
}, ensure_ascii=False)
agent = Agent(
name="Potovalni agent",
instructions="""Si potovalni agent. Ko te prosijo
za priporočila za mesto, hkrati pridobi vreme IN dogodke,
da zagotoviš popoln nasvet.""",
tools=[get_weather, get_events],
model="gpt-5.6-terra",
)
# Model bo za vsako mesto poklical obe orodji vzporedno
result = await Runner.run(
agent,
"Ta vikend želim obiskati Pariz. Kaj priporočaš?"
)
print(result.final_output)
Obe orodji vrneta JSON, kar modelu olajša ponovno združevanje podatkov. Bodi pozoren na formulacijo navodil: fraza “IN … hkrati” sproži vzporedni klic namesto lenega zaporedja.
Časovne omejitve in odpornost
API, ki nikoli ne odgovori, blokira tvojega agenta prav tako zanesljivo kot sinhrono orodje. Vsak počasen klic omeji s časovno omejitvijo (timeout) in napake pretvori v razumljiva sporočila.
import asyncio
from agents import function_tool
@function_tool
async def slow_api_call(query: str) -> str:
"""Kliče API, ki je lahko počasen."""
try:
async with asyncio.timeout(5): # Časovna omejitev 5 sekund
# Tvoj klic API-ja tukaj
await asyncio.sleep(0.1) # Simulacija
return f"Rezultat za '{query}'"
except asyncio.TimeoutError:
return "API ni odgovoril pravočasno. Poskusi znova."
Uspešnost: Vpliv vzporednosti
Poglejmo si razmerja v praksi. Tri orodja, ki trajajo po 500 ms in se izvedejo zaporedno, stanejo 1500 ms; ista tri orodja, izvedena vzporedno, stanejo približno 500 ms – toliko, kolikor traja najpočasnejše. Pri agentu, ki uporablja veliko orodij, je ta razlika v praksi takoj opazna.
Ključne ugotovitve
- Za orodja, ki opravljajo omrežne ali I/O klice, uporabi
async. - SDK samodejno izvaja neodvisna orodja vzporedno.
parallel_tool_calls=Falsepo potrebi vsili zaporedno izvajanje.- Za odpornost dodaj časovne omejitve z
asyncio.timeout(). - Vzporednost lahko zmanjša latenco za faktor števila orodij.