Salt la conținutul principal
Română— Alege o limbă
Meniu

Apeluri paralele

Lecția 6 din 14 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Mai multe instrumente într-un singur răspuns
  2. Parametrul parallel_tool_calls
  3. Gestionarea apelurilor paralele
  4. Executarea cu adevărat paralelă la nivelul clientului
  5. Dezactivarea apelurilor paralele
  6. Apeluri paralele cu instrumente diferite
  7. Gestionarea erorilor în paralel
  8. Puncte cheie

Mai multe instrumente într-un singur răspuns

Una dintre cele mai puternice funcționalități ale apelurilor de funcții Grok este capacitatea de a returna mai multe apeluri de instrumente într-un singur răspuns. În loc să efectuați o dus-întors pentru fiecare funcție, modelul identifică toate informațiile necesare și generează fiecare apel în paralel.

Parametrul parallel_tool_calls

Apelurile paralele sunt activate implicit. Parametrul parallel_tool_calls controlează acest comportament:

# Activat implicit (nu este nevoie să specificați)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Aceasta este valoarea implicită
)

Când un utilizator întreabă: „Ce vreme este la Paris și Lyon?“, modelul returnează două tool_calls în același răspuns:

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

Gestionarea apelurilor paralele

Codul dumneavoastră trebuie să gestioneze un tablou de tool_calls, nu doar unul singur:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Executați toate funcțiile
    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)
        })

    # Trimiteți TOATE rezultatele înapoi modelului
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Toate rezultatele
    ]

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

Punct critic: trebuie să returnați toate rezultatele instrumentelor, nu doar pe primul. Fiecare rezultat este legat de tool_call_id corespunzător.

Executarea cu adevărat paralelă la nivelul clientului

Modelul returnează apelurile în paralel, dar codul dumneavoastră trebuie să le execute în paralel. În Python, utilizați asyncio sau 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

Executarea paralelă reduce semnificativ latența totală. Dacă fiecare apel API durează 200 ms, două apeluri secvențiale înseamnă 400 ms, dar două apeluri paralele înseamnă aproximativ 200 ms.

Dezactivarea apelurilor paralele

În anumite cazuri, veți dori apeluri secvențiale:

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

Dezactivați paralelismul ori de câte ori independența apelurilor nu este garantată. Cel mai evident caz este dependența de date: dacă rezultatul unui instrument servește drept argument pentru următorul instrument – de exemplu, căutarea unui ID de client înainte de a prelua comenzile acestuia – executarea lor în paralel va provoca, în cel mai bun caz, o eroare și, în cel mai rău caz, va genera un rezultat incorect fără a semnala nicio problemă. Ordinea logicii de afaceri impune aceeași constrângere: crearea unui utilizator înainte de a-i atribui un rol este obligatorie, iar doar modul secvențial garantează acest lucru. Două motive practice completează imaginea: un API extern supus unor limite de cereri concurente nu va gestiona bine o explozie de apeluri paralele, iar în timpul dezvoltării, modul secvențial face urmărirea apelurilor infinit mai lizibilă – un apel, un rezultat, un jurnal, în ordine.

Apeluri paralele cu instrumente diferite

Modelul poate apela, de asemenea, instrumente diferite în paralel:

# Cerere: „Rezervă o masă și spune-mi vremea pentru diseară“
# Modelul returnează:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Acest lucru este deosebit de util pentru asistenții versatili care trebuie să colecteze informații din surse diferite.

Gestionarea erorilor în paralel

Când un apel eșuează, dar altele reușesc, returnați totuși toate rezultatele. Modelul gestionează erorile individuale:

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)})
        })

Puncte cheie

  • Apelurile paralele sunt activate implicit (parallel_tool_calls: true)
  • Modelul returnează mai multe tool_calls într-un singur răspuns
  • Trebuie să returnați toate rezultatele, fiecare fiind legat de tool_call_id său
  • Implementați executarea paralelă la nivelul clientului pentru a reduce latența
  • Dezactivați paralelismul atunci când există dependențe între apeluri
  • Gestionați erorile individual – nu blocați totul din cauza unei singure erori