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

Sejħiet Paralleli ta' Funzjonijiet

Lezzjoni 8 / 14 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Meta l-mudell jeħtieġ biċċiet multipli ta’ informazzjoni f’daqqa
  2. Qari ta’ rispons b’sejħiet multipli
  3. Ir-ritorn ta’ kull riżultat lis-sejħa oriġinali tiegħu
  4. Mill-apparenza tal-paralleliżmu għall-paralleliżmu reali
  5. Ir-rikupru tal-kontroll b’parallel_tool_calls
  6. X’jibdel verament il-paralleliżmu
  7. Punti Ewlenin

Meta l-mudell jeħtieġ biċċiet multipli ta’ informazzjoni f’daqqa

S’issa, kull dawra fil-konversazzjoni rriżultat f’sejħa waħda biss ta’ funzjoni. Ħafna mistoqsijiet tad-dinja reali ma jaqgħux f’dan il-mudell. Ikkunsidra utent li jistaqsi, “X’inhu l-istatus u d-data tal-ħlas T1001?” Il-mudell jeħtieġ żewġ biċċiet ta’ informazzjoni li jinsabu f’żewġ funzjonijiet distinti: retrieve_payment_status u retrieve_payment_date. Jista’ jitlobhom wieħed wara l-ieħor, jistenna r-risposta tiegħek bejniethom. Madankollu, hawnhekk jiddetermina li l-ebda waħda ma tiddependi mill-oħra, allura jiġġenera tool_calls multipli f’reazzjoni waħda. Int tirċievi x-xogħol kollu f’daqqa, u tiddeċiedi kif tesegwixxih.

Qari ta’ rispons b’sejħiet multipli

L-implikazzjoni prattika hija sempliċi: message.tool_calls m’għadhiex lista b’oġġett wieħed. Trid tgħaddi minnha (iterate) minflok ma taqbad tool_calls[0], rifless komuni meta titgħallem is-sejħa tal-funzjonijiet minn eżempji ta’ funzjoni waħda.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Multiple tool_calls in the same response
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Possible output:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Innota li ż-żewġ sejħiet jużaw l-istess argument, T1001, iżda għandhom IDs differenti: call_abc123 u call_def456. Dawn l-IDs huma l-uniku mod kif il-mudell jaf liema riżultat jikkorrispondi ma’ liema talba.

Ir-ritorn ta’ kull riżultat lis-sejħa oriġinali tiegħu

Ir-regola hija stretta: trid tesegwixxi kull funzjoni u tirritorna kull riżultat f’messaġġ tool separat li jġorr l-tool_call_id korrispondenti. Jekk tinsa jew taqleb ID, il-mudell jista’ jattribwixxi d-data lill-qasam tal-istatus, jew jista’ jirrifjuta li jwieġeb.

message = response.choices[0].message
messages.append(message)

# Execute all requested functions
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Execute the function
    result = available_functions[function_name](**function_params)

    # Add the result with the correct tool_call_id
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Send all results back to the model
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."

Il-mudell imbagħad igħaqqad iż-żewġ frammenti f’sentenza waħda, daqslikieku l-informazzjoni ġiet minn sors wieħed. Dan huwa eżattament l-effett li trid mill-perspettiva tal-utent.

Mill-apparenza tal-paralleliżmu għall-paralleliżmu reali

Nuansa waħda spiss taħrab mill-qarrejja fl-ewwel qari: fil-linja for ta’ hawn fuq, il-funzjonijiet jesegwixxu wieħed wara l-ieħor. Il-mudell talab is-sejħiet tiegħu b’mod parallel, iżda l-kodiċi tiegħek jibqa’ sekwenzjali. Sakemm il-funzjonijiet tiegħek jaqraw DataFrame fil-memorja, dan ma jimpurtax. Madankollu, ladarba jikkonsultaw API esterna jew database, żewġ sejħiet ta’ 300 ms isiru 600 ms ta’ latenza perċepita, u l-benefiċċju tal-paralleliżmu jevapora. Jekk il-funzjonijiet tiegħek huma asinkroni, asyncio.gather يطلقhom flimkien u jistenna l-lott kollu.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Executes tool_calls in parallel and returns the results."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # If your functions are async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Execute all functions in parallel
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

Il-biċċa l-kbira tal-codebases eżistenti jesponu funzjonijiet sinkroni li ma tridx terġa’ tikteb bħala async biss għal dan. Thread pool jipproduċi l-istess effett mingħajr ma tmiss il-loġika tan-negozju tiegħek.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Executes tool_calls using a thread pool."""
    def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(execute_one, tool_calls))

    return results

Ir-rikupru tal-kontroll b’parallel_tool_calls

Il-paralleliżmu mhux dejjem mixtieq. Il-parametru parallel_tool_calls jħallik tippermetti jew tipprojbixxih. Meta jkun issettjat għal True (id-default), il-mudell jiddeċiedi jekk jagħmilx is-sejħiet tiegħu f’grupp. Meta jkun issettjat għal False, jista’ jipproduċi tool_call wieħed biss kull rispons.

# Allow parallel calls (default)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Model decides
)

# Force sequential calls
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Only one tool_call per response
)

Tliet sitwazzjonijiet jiġġustifikaw li tissettja dan għal False. L-ewwel hija meta l-ordni ta’ eżekuzzjoni tgħodd: il-fatturazzjoni qabel ma tiċċekkja l-istokk tagħti riżultat differenti milli r-reċiproku. It-tieni tinvolvi dipendenzi tad-data, fejn ir-riżultat ta’ funzjoni waħda huwa meħtieġ biex tissejjaħ li jmiss—pereżempju, issib kuntatt biex tikseb l-ID tiegħu qabel ma timmodifika r-rekord tiegħu. It-tielet sempliċiment tirrelata mal-ħtieġa ta’ kontroll aktar fin fuq il-fluss, tipikament waqt id-debugging, meta trid tosserva kull sejħa f’iżolament qabel ma tiftaħ il-bibien.

X’jibdel verament il-paralleliżmu

Il-gwadann mhux biss dwar it-threads; jikkonċerna primarjament in-numru ta’ vjaġġi ‘l quddiem u lura (round trips) lejn l-API, li jiddominaw il-latenza totali.

# Sequential (2 API calls to the model)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Parallel (only 1 additional API call)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

Fil-mudell sekwenzjali, il-mudell irid jikkompleta żewġ dawriet sħaħ ta’ raġunament qabel it-tweġiba finali. Fil-mudell parallel, talba waħda tirrikupra l-tool_calls kollha, u hija meħtieġa talba addizzjonali waħda biss għar-rispons. Għal mistoqsija li tinvolvi żewġ jew tliet funzjonijiet, dan spiss iffranka lill-utent diversi sekondi.

Punti Ewlenin

  • Il-mudell jista’ jiġġenera tool_calls multipli f’reazzjoni waħda
  • Kull riżultat irid jiġi rritornat bl-tool_call_id korrett
  • Għal funzjonijiet tan-netwerk, uża asyncio jew ThreadPoolExecutor għal eżekuzzjoni parallela vera
  • Il-parametru parallel_tool_calls jikkontrolla dan l-imġiba (True bħala default)
  • Il-mudell parallel inaqqas it-talbiet tal-API u jtejjeb il-latenza