Rīki asinhronai un paralēlai darbībai
Šajā lapā
Rīki asinhronai un paralēlai darbībai
Produkcijas vidē tavi rīki izsauc ārējās API, veic vaicājumus datubāzēm vai veic I/O operācijas. Šīs darbības prasa laiku, un tas summējas: aģents, kas secīgi veic piecus vienu sekundi ilgu izsaukumus, atbildi sniedz pēc piecām sekundēm. Tieši rīku padarīšana par asinhroniem un SDK natīvās paralēlisma spēju izmantošana atšķir demonstrācijas projektu no lietojama servisa.
Asinhronie rīki
Dekoratīvs @function_tool natīvi atbalsta async funkcijas. Nav nepieciešama nekāda konfigurācija: vienkārši deklarē async def, izmanto asinhronu HTTP klientu, un SDK pārējais nokārto pats.
import httpx
from agents import function_tool
@function_tool
async def search_company(name: str) -> str:
"""Meklē uzņēmuma informāciju, izmantojot 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"Uzņēmums: {data['name']}, SIREN: {data['siren']}, Apgrozījums: {data['revenue']}"
return f"Nav rezultātu priekš '{name}'"
@function_tool
async def verify_solvency(siren: str) -> str:
"""Pārbauda uzņēmuma maksātspēju pēc tā SIREN numura."""
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"Maksātspējas vērtējums: {data['score']}/100, risks: {data['risk_level']}"
Kad Runner izpilda asinhronu rīku, tas nebloķē notikumu cilpu (event loop). FastAPI serverī tas nozīmē, ka citi pieprasījumi tiek apstrādāti tālāk, kamēr tavs aģents gaida atbildi no Societe.com API.
Automātiskais paralēlisms
Divi neatkarīgi asinhroni rīki var darboties vienlaicīgi. To izlemj modelis, un tavas instrukcijas var to tieši veicināt.
from agents import Agent, Runner
agent = Agent(
name="B2B Analītiķis",
instructions="""Tu analizē uzņēmumus biznesa lēmumu pieņemšanai.
Kad tiek lūgts analizēt uzņēmumu, iegūsti tā informāciju
UN vienlaicīgi pārbaudi tā maksātspēju.""",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
)
# Modelis palaidīs abus rīkus paralēli
result = await Runner.run(
agent,
"Analizē uzņēmumu Acme Corp (SIREN 123456789)"
)
Tā kā SIREN numurs ir norādīts vaicājumā, maksātspējas pārbaude negaida uz uzņēmuma meklēšanas pabeigšanu: SDK izpilda abus izsaukumus vienlaicīgi. Kopējais laiks ir vienāds ar lēnākā rīka ilgumu, nevis abu summa.
Paralēlisma kontrole
Paralēlisms ne vienmēr ir vēlams. Ja tavi rīki raksta vienā ierakstā vai ja datu konsekvences nodrošināšanai ir svarīga secība, piespied secīgu izpildi.
from agents import Agent
agent = Agent(
name="Piesardzīgs aģents",
instructions="Izpildi rīkus vienu pēc otra, lai nodrošinātu datu konsekvenci.",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
parallel_tool_calls=False, # Piespiedu secīga izpilde
)
Parametrs parallel_tool_calls=False piespiež modeli izsaukt tikai vienu rīku vienlaicīgi. Tu apmaini latentumu pret paredzamību.
Paradums: Paralēlu rezultātu apkopošana
Visbiežāk sastopamais praktiskais gadījums ir datu vākšana no vairākiem avotiem par vienu un to pašu entītiju. Šeit pilsētas laika apstākļiem un kultūras pasākumu kalendāram nav nekāda sakara vienam ar otru, taču atbildei ir nepieciešami abi.
import json
from agents import Agent, Runner, function_tool
@function_tool
async def get_weather(city: str) -> str:
"""Iegūst aktuālos laika apstākļus pilsētā."""
# Simulācija - produkcijā: laika apstākļu API izsaukums
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:
"""Iegūst gaidāmos pasākumus pilsētā."""
events = {
"Paris": ["Koncerts Stade de France", "Izstāde Luvrā"],
"Lyon": ["Gaismas festivāls", "Gastronomijas gadatirgus"],
"Marseille": ["Vidusjūras regate"],
}
return json.dumps({
"city": city,
"events": events.get(city, [])
}, ensure_ascii=False)
agent = Agent(
name="Ceļojumu aģents",
instructions="""Tu esi ceļojumu aģents. Kad tiek lūgti
ieteikumi konkrētai pilsētai, iegūsti laika apstākļus UN pasākumus
vienlaicīgi, lai sniegtu pilnīgu konsultāciju.""",
tools=[get_weather, get_events],
model="gpt-5.6-terra",
)
# Modelis izsauks abus rīkus paralēli katrai pilsētai
result = await Runner.run(
agent,
"Es vēlos šajā nedēļas nogalē apmeklēt Parīzi. Ko tu ieteiktu?"
)
print(result.final_output)
Abi rīki atgriež JSON, kas atvieglo modelim datu atkārtotu apvienošanu. Pievērs uzmanību instrukciju formulējumam: frāze “UN … vienlaicīgi” izraisa paralēlu izsaukumu, nevis gausu ķēdi.
Noildzes un noturība
API, kas nekad neatbild, bloķē tavu aģentu tikpat droši kā sinhrons rīks. Katru lēno izsaukumu ierobežo ar noildi (timeout) un pārvērt kļūmes saprotamos ziņojumos.
import asyncio
from agents import function_tool
@function_tool
async def slow_api_call(query: str) -> str:
"""Izsauc API, kas var būt lēns."""
try:
async with asyncio.timeout(5): # 5 sekunžu noilde
# Tavs API izsaukums šeit
await asyncio.sleep(0.1) # Simulācija
return f"Rezultāts priekš '{query}'"
except asyncio.TimeoutError:
return "API neatbildēja laikā. Lūdzu, mēģini vēlreiz."
Veiktspēja: Paralēlisma ietekme
Aplūkosim mērogu. Trīs rīki, kas katrs ilgst 500 ms, izpildīti secīgi, aizņem 1500 ms; tie paši trīs rīki, izpildīti paralēli, aizņem aptuveni 500 ms – tik ilgi, cik ilgst lēnākais no tiem. Aģentam, kas izmanto daudzus rīkus, šī atšķirība praksē ir acumirklī pamanāma.
Galvenās atziņas
- Izmanto
asyncrīkiem, kas veic tīkla vai I/O izsaukumus - SDK automātiski izpilda neatkarīgus rīkus paralēli
parallel_tool_calls=Falsepiespiedu kārtā nodrošina secīgu izpildi, kad tas ir nepieciešams- Pievieno noildzes, izmantojot
asyncio.timeout(), lai nodrošinātu noturību - Paralēlisms var samazināt latentumu tik reižu, cik daudz rīku tiek izmantoti