Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Għodod Asinkroni u Paralleli

Lezzjoni 8 / 25 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għodod Asinkroni u Paralleli
  2. Għodod Asinkroni
  3. Parallelism Awtomatiku
  4. Kontroll tal-Parallelism
  5. Mudell: Aggregazzjoni ta’ Riżultati Paralleli
  6. Timeouts u Reżiljenza
  7. Prestazzjoni: Impatt tal-Parallelism
  8. Punti Ewlenin

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 async għ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=False jifforż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