Għodod Asinkroni u Paralleli
F'din il-paġna
Għodod Asinkroni u Paralleli
Fil-produzzjoni, l-għodod tiegħek isejħu API esterni, jistaqsu databases, jew iwettqu operazzjonijiet ta’ I/O. Dawn l-operazzjonijiet jieħdu ħin, u dak il-ħin jingħadda flimkien: aġent li jgħaqqad ħames sejħiet ta’ sekonda waħda jieħu ħames sekondi biex iwieġeb. Li tagħmel l-għodod asinkroni u tisfrutta l-parallelism nattiv tal-SDK huwa dak li jifred bejn demo u servizz li jista’ jintuża.
Għodod Asinkroni
Id-dekoratur @function_tool jappoġġja nattivament funzjonijiet async. L-ebda konfigurazzjoni meħtieġa: iddikjara async def, uża klijent HTTP asinkronu, u l-SDK jittratta l-bqija.
import httpx
from agents import function_tool
@function_tool
async def search_company(name: str) -> str:
"""Searches for company information via the 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"Company: {data['name']}, SIREN: {data['siren']}, Revenue: {data['revenue']}"
return f"No results for '{name}'"
@function_tool
async def verify_solvency(siren: str) -> str:
"""Verifies a company's solvency by its SIREN number."""
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"Solvency score: {data['score']}/100, risk: {data['risk_level']}"
Meta r-Runner jesegwixxi għodda asinkrona, ma jimblokkax il-loop tal-avvenimenti. F’server FastAPI, dan ifisser li talbiet oħra jkomplu jiġu pproċessati filwaqt li l-aġent tiegħek jistenna r-risposta mill-API ta’ Societe.com.
Parallelism Awtomatiku
Żewġ għodod asinkroni indipendenti jistgħu jiġu eżegwiti fl-istess ħin. Il-mudell jiddeċiedi dan, u l-istruzzjonijiet tiegħek jistgħu jinkoraġġixxu dan b’mod espliċitu.
from agents import Agent, Runner
agent = Agent(
name="B2B Analyst",
instructions="""You analyze companies for business decisions.
When asked to analyze a company, retrieve its information
AND verify its solvency at the same time.""",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
)
# The model will launch both tools in parallel
result = await Runner.run(
agent,
"Analyze the company Acme Corp (SIREN 123456789)"
)
Peress li s-SIREN huwa pprovdut fil-mistoqsija, iċ-ċekk tas-solvenza ma jistenniex it-tfittxija tal-kumpanija: l-SDK jesegwixxi ż-żewġ sejħiet simultanjament. Il-ħin totali huwa ugwali għat-tul tal-għodda l-aktar bil-mod, mhux is-somma taż-żewġ għodod.
Kontroll tal-Parallelism
Il-parallelism mhux dejjem mixtieq. Jekk l-għodod tiegħek jiktbu fl-istess rekord jew jekk l-ordni hija importanti għall-konsistenza tad-data, forża eżekuzzjoni sekwenzjali.
from agents import Agent
agent = Agent(
name="Cautious Agent",
instructions="Execute tools one by one to ensure data consistency.",
tools=[search_company, verify_solvency],
model="gpt-5.6-terra",
parallel_tool_calls=False, # Forces sequential execution
)
Il-parametru parallel_tool_calls=False jifforza lill-mudell isejjaħ għodda waħda biss kull darba. Inti tissakrafja l-latency għall-prevedibbiltà.
Mudell: Aggregazzjoni ta’ Riżultati Paralleli
Il-każ prattiku l-aktar komuni jinvolvi l-ġbir ta’ data minn sorsi multipli għall-istess entità. Hawnhekk, it-temp ta’ belt u l-aġenda kulturali tagħha m’għandhom x’jaqsmu xejn ma’ xulxin, iżda r-risposta teħtieġ it-tnejn.
import json
from agents import Agent, Runner, function_tool
@function_tool
async def get_weather(city: str) -> str:
"""Gets current weather for a city."""
# Simulation - in production: weather API call
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:
"""Gets upcoming events in a city."""
events = {
"Paris": ["Concert at Stade de France", "Exhibition at the Louvre"],
"Lyon": ["Festival of Lights", "Gastronomy Fair"],
"Marseille": ["Mediterranean Regatta"],
}
return json.dumps({
"city": city,
"events": events.get(city, [])
}, ensure_ascii=False)
agent = Agent(
name="Travel Agent",
instructions="""You are a travel agent. When asked
for recommendations for a city, retrieve weather AND events
simultaneously to provide complete advice.""",
tools=[get_weather, get_events],
model="gpt-5.6-terra",
)
# The model will call both tools in parallel for each city
result = await Runner.run(
agent,
"I want to visit Paris this weekend. What do you recommend?"
)
print(result.final_output)
Iż-żewġ għodod jirritornaw JSON, li jagħmilha aktar faċli għall-mudell biex jerġa’ jgħaqqad id-data. Innota l-formulazzjoni tal-istruzzjoni: il-”AND … simultaneously” tiġġenera s-sejħa parallela minflok katina bil-mod.
Timeouts u Reżiljenza
API li qatt ma tirrispondi timblokka l-aġent tiegħek bl-istess mod bħala għodda sinkrona. Illimita kull sejħa bil-mod b’timeout u qiegħed il-fallimenti f’messaġġi li jistgħu jinftiehmu.
import asyncio
from agents import function_tool
@function_tool
async def slow_api_call(query: str) -> str:
"""Calls an API that might be slow."""
try:
async with asyncio.timeout(5): # 5-second timeout
# Your API call here
await asyncio.sleep(0.1) # Simulation
return f"Result for '{query}'"
except asyncio.TimeoutError:
return "The API did not respond in time. Please try again."
Prestazzjoni: Impatt tal-Parallelism
Ejja npoġġu l-iskala f’perspettiva. Tliet għodod ta’ 500 ms eżegwiti sekwenzjalment jiswew 1500 ms; l-istess tliet għodod f’parallel jiswew madwar 500 ms—it-tul ta’ dik l-aktar bil-mod. Għal aġent li juża ħafna għodod, id-differenza tinnota immedjatament fil-prattika.
Punti Ewlenin
- Uża
asyncgħal għodod li jagħmlu sejħiet tan-network jew I/O - L-SDK jesegwixxi awtomatikament għodod indipendenti f’parallel
parallel_tool_calls=Falsejifforża eżekuzzjoni sekwenzjali meta meħtieġ- Żid timeouts b’
asyncio.timeout()għar-reżiljenza - Il-parallelism jista’ jaqsam il-latency bin-numru ta’ għodod