Įrankiai asinchroniniam ir lygiagrečiam darbui
Šiame puslapyje
Įrankiai asinchroniniam ir lygiagrečiam darbui
Gamybinėje aplinkoje tavo įrankiai kviečia išorines API, užklausia duomenų bazes arba atlieka I/O operacijas. Šios operacijos trunka, o laikas kaupiasi: agentas, nuosekliai vykdydamas penkis vienos sekundės trukmės kvietimus, atsakymui sugaiš penkias sekundes. Būtent įrankių pavertimas asinchroniniais ir SDK natūralaus lygiagretumo išnaudojimas atskiria demonstracinį projektą nuo naudotinos paslaugos.
Asinchroniniai įrankiai
Dekoratorius @function_tool savaime palaiko async funkcijas. Jokių papildomų nustatymų nereikia: tiesiog deklaruok async def, naudok asinchroninį HTTP klientą, o SDK pasirūpins likusiu darbu.
import httpx
from agents import function_tool
@function_tool
async def search_company(name: str) -> str:
"""Ieško įmonės informacijos per 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"Įmonė: {data['name']}, SIREN: {data['siren']}, Pajamos: {data['revenue']}"
return f"Nėra rezultatų pagal užklausą '{name}'"
@function_tool
async def verify_solvency(siren: str) -> str:
"""Tikrina įmonės mokumą pagal jos SIREN numerį."""
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"Mokumo balas: {data['score']}/100, rizika: {data['risk_level']}"
Kai „Runner“ vykdo asinchroninį įrankį, jis neužblokuoja įvykių ciklo. FastAPI serveryje tai reiškia, kad kiti užklausos toliau apdorojamos, kol tavo agentas laukia atsakymo iš Societe.com API.
Automatinis lygiagretumas
Du nepriklausomi asinchroniniai įrankiai gali veikti vienu metu. Modelis pats priima tokį sprendimą, o tavo instrukcijose gali būti aiškiai paraginta tai daryti.
from agents import Agent, Runner
agent = Agent(
name="B2B Analitikas",
instructions="""Tu analizuoji įmones verslo sprendimams priimti.
Kai prašoma analizuoti įmonę, gauk jos informaciją
IR tuo pačiu metu patikrink jos mokumą.""",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
)
# Modelis paleis abu įrankius lygiagrečiai
result = await Runner.run(
agent,
"Išanalizuok įmonę Acme Corp (SIREN 123456789)"
)
Kadangi SIREN numeris pateikiamas jau užklausoje, mokumo tikrinimas nelaukia, kol bus baigta įmonės paieška: SDK abu kvietimus įvykdo vienu metu. Bendras laikas lygus lėčiausio įrankio trukmei, o ne abiejų trukmių sumai.
Lygiagretumo valdymas
Lygiagretumas ne visada pageidautinas. Jei tavo įrankiai rašo į tą patį įrašą arba jei duomenų nuoseklumui svarbi vykdymo eilė, priversk juos veikti nuosekliai.
from agents import Agent
agent = Agent(
name="Atsargus agentas",
instructions="Vykdyk įrankius vieną po kito, kad užtikrintum duomenų nuoseklumą.",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
parallel_tool_calls=False, # Priverčia vykdyti nuosekliai
)
Parametras parallel_tool_calls=False priverčia modelį vienu metu kviesti tik vieną įrankį. Taip mainais į nuspėjamumą aukoji greitį.
Šablonas: lygiagrečių rezultatų agregavimas
Dažniausias praktinis atvejis – duomenų rinkimas iš kelių šaltinių apie tą patį objektą. Pavyzdžiui, miesto orai ir kultūrinė programa tarpusavyje nesusiję, tačiau atsakyme reikia abiejų.
import json
from agents import Agent, Runner, function_tool
@function_tool
async def get_weather(city: str) -> str:
"""Gauna dabartinius miesto orus."""
# Simuliacija – gamyboje: orų API kvietimas
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:
"""Gauna artėjančius renginius mieste."""
events = {
"Paris": ["Koncertas Stade de France stadione", "Paroda Luvre"],
"Lyon": ["Šviesų festivalis", "Gastronomijos mugė"],
"Marseille": ["Viduržemio jūros regata"],
}
return json.dumps({
"city": city,
"events": events.get(city, [])
}, ensure_ascii=False)
agent = Agent(
name="Kelionių agentas",
instructions="""Tu esi kelionių agentas. Kai prašoma
pateikti rekomendacijas dėl miesto, gauk orus IR renginius
vienu metu, kad galėtum suteikti išsamų patarimą.""",
tools=[get_weather, get_events],
model="gpt-5.6-terra",
)
# Modelis kiekvienam miestui lygiagrečiai iškvies abu įrankius
result = await Runner.run(
agent,
"Šį savaitgalį noriu aplankyti Paryžių. Ką rekomenduoji?"
)
print(result.final_output)
Abu įrankiai grąžina JSON, todėl modeliui lengviau vėl sujungti duomenis. Atkreipk dėmesį į instrukcijos formuluotę: frazė „IR … vienu metu“ suaktyvina lygiagretų kvietimą, o ne tingų grandininį vykdymą.
Laiko limitai ir atsparumas klaidoms
API, kuris niekada neatsako, užblokuoja tavo agentą taip pat efektyviai kaip ir sinchroninis įrankis. Kiekvienam lėtam kvietimui nustatyk laiko limitą ir paversk gedimus suprantamais pranešimais.
import asyncio
from agents import function_tool
@function_tool
async def slow_api_call(query: str) -> str:
"""Kviečia API, kuris gali būti lėtas."""
try:
async with asyncio.timeout(5): # 5 sekundžių laiko limitas
# Tavo API kvietimas čia
await asyncio.sleep(0.1) # Simuliacija
return f"Rezultatas užklausai '{query}'"
except asyncio.TimeoutError:
return "API laiku neatsakė. Bandyk dar kartą."
Našumas: lygiagretumo poveikis
Pažvelkime į mastelį. Trys 500 ms trunkantys įrankiai, vykdomi nuosekliai, kainuoja 1500 ms; tie patys trys įrankiai, vykdomi lygiagrečiai, kainuoja apie 500 ms – tiek, kiek trunka lėčiausias iš jų. Agentui, naudojančiam daug įrankių, šis skirtumas praktiškai pastebimas iškart.
Svarbiausi punktai
- Naudok
asyncįrankiams, kurie atlieka tinklo arba I/O operacijas - SDK automatiškai lygiagrečiai vykdo nepriklausomus įrankius
parallel_tool_calls=Falseprireikus priverčia vykdyti nuosekliai- Atsparumui klaidoms naudok laiko limitus su
asyncio.timeout() - Lygiagretumas gali sumažinti delsą tiek kartų, kiek yra įrankių