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

Sejħiet Paralleli

Lezzjoni 6 / 14 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għodod Multipli f’Risposta Waħda
  2. Il-Parametru parallel_tool_calls
  3. Kif Timmaniġġja Sejħiet Paralleli
  4. Eżekuzzjoni Verament Paralleli fuq il-Klijent
  5. Id-diżattivazzjoni tas-Sejħiet Paralleli
  6. Sejħiet Paralleli b’Għodod Differenti
  7. Immaniġġjar tal-Iżbalji fil-Parallel
  8. Punti Ewlenin

Għodod Multipli f’Risposta Waħda

Waħda mill-aktar karatteristiċi qawwija tas-sejħiet tal-funzjonijiet ta’ Grok hija l-kapaċità li tirritorna sejħiet tal-għodod multipli f’risposta waħda. Minflok ma tagħmel vjaġġ ‘l hemm u ‘l hawn għal kull funzjoni, il-mudell jidentifika l-informazzjoni kollha li jeħtieġ u jiġġenera kull sejħa b’mod parallel.

Il-Parametru parallel_tool_calls

Is-sejħiet paralleli huma attivi b’mod default. Il-parametru parallel_tool_calls jikkontrolla dan l-imġiba:

# Attiv b'mod default (m'hemmx bżonn tispeċifika)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Dan huwa d-default
)

Meta utent jistaqsi, “X’inhu t-temp f’Pariġi u Ljon?”, il-mudell jirritorna żewġ tool_calls fl-istess risposta:

{
  "tool_calls": [
    {
      "id": "call_001",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Paris\"}"
      }
    },
    {
      "id": "call_002",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Lyon\"}"
      }
    }
  ]
}

Kif Timmaniġġja Sejħiet Paralleli

Il-kodiċi tiegħek irid jimmaniġġja array ta’ tool_calls, mhux wieħed biss:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Eżegwixxi l-funzjonijiet kollha
    tool_results = []
    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        result = execute_function(tool_call.function.name, args)
        tool_results.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })

    # Ibghat IR-RIZULTATI KOLLHA lura lill-mudell
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Ir-riżultati kollha
    ]

    final = client.chat.completions.create(
        model="grok-4.5",
        messages=messages,
        tools=tools
    )

Punt kritiku: trid tirritorna r-riżultati kollha tal-għodod, mhux biss l-ewwel wieħed. Kull riżultat huwa marbut mal-tool_call_id korrispondenti tiegħu.

Eżekuzzjoni Verament Paralleli fuq il-Klijent

Il-mudell jirritorna s-sejħiet b’mod parallel, iżda l-kodiċi tiegħek irid jeżegwixxihom b’mod parallel. F’Python, uża asyncio jew concurrent.futures:

import concurrent.futures

def execute_parallel(tool_calls):
    results = []
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = {}
        for tc in tool_calls:
            args = json.loads(tc.function.arguments)
            future = executor.submit(execute_function, tc.function.name, args)
            futures[future] = tc.id

        for future in concurrent.futures.as_completed(futures):
            call_id = futures[future]
            result = future.result()
            results.append({
                "role": "tool",
                "tool_call_id": call_id,
                "content": json.dumps(result)
            })
    return results

L-eżekuzzjoni parallela tnaqqas b’mod sinifikanti l-latency totali. Jekk kull sejħa API tieħu 200ms, żewġ sejħiet sekwenzjali = 400ms, iżda żewġ sejħiet paralleli = ~200ms.

Id-diżattivazzjoni tas-Sejħiet Paralleli

F’xi każijiet, tkun trid sejħiet sekwenzjali:

response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False
)

Iddiżattiva l-parallelità kull meta l-indipendenza tas-sejħiet ma tkunx garantita. L-aktar każ ovvju huwa d-dipendenza tad-data: jekk ir-riżultat ta’ għodda waħda jidħol fl-argumenti tal-għodda li jmiss—bħall-iftix ta’ ID ta’ klijent qabel ma tirritorna l-ordnijiet tiegħu—it-tħaddim tagħhom b’mod parallel se jikkawża żball fl-aħjar każ, u fl-agħar każ jipproduċi riżultat ħażin mingħajr ma jintwera. Il-loġika tan-negozju timponi l-istess restrizzjoni: il-ħolqien ta’ utent qabel ma tingħatah rwol mhuwiex negozjabbli, u biss il-modalità sekwenzjali tiggarantixxi dan. Żewġ raġunijiet oħra prattiċi jikkompletaw il-ħarsa ġenerali: API esterna soġġetta għal limiti ta’ talbiet konkorrenti ma tittrattax tajjeb żieda f’daqqa ta’ sejħiet paralleli, u waqt l-iżvilupp, il-modalità sekwenzjali tagħmel it-traċċar tas-sejħiet infinitament aktar leġibbli—sejħa waħda, riżultat wieħed, log wieħed, f’ordni.

Sejħiet Paralleli b’Għodod Differenti

Il-mudell jista’ jsejjaħ ukoll għodod differenti b’mod parallel:

# Talba: "Ibbukja mejda u għidli x'inhu t-temp il-lejla"
# Il-mudell jirritorna:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Dan huwa partikolarment utli għal assistenti versatili li jeħtieġu jiġbru informazzjoni minn sorsi differenti.

Immaniġġjar tal-Iżbalji fil-Parallel

Meta sejħa waħda tfalli iżda oħrajn jirnexxu, xorta waħda rritorna r-riżultati kollha. Il-mudell jimmaniġġja l-iżbalji individwali:

results = []
for tc in message.tool_calls:
    try:
        result = execute_function(tc.function.name, args)
        results.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps(result)
        })
    except Exception as e:
        results.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps({"error": str(e)})
        })

Punti Ewlenin

  • Is-sejħiet paralleli huma attivati b’mod default (parallel_tool_calls: true)
  • Il-mudell jirritorna tool_calls multipli f’risposta waħda
  • Trid tirritorna r-riżultati kollha, kull wieħed marbut mal-tool_call_id tiegħu
  • Implimenta eżekuzzjoni paralleli fuq in-naħa tal-klijent biex tnaqqas il-latency
  • Iddiżattiva l-parallelità meta jkun hemm dipendenzi bejn is-sejħiet
  • Immaniġġja l-iżbalji individwalment—timblukkax kollox għal falliment wieħed