Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Parallelle kald

Lektion 6 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Flere værktøjer i ét svar
  2. Parameteren parallel_tool_calls
  3. Håndtering af parallelle kald
  4. Ægte parallel eksekvering på klienten
  5. Deaktivering af parallelle kald
  6. Parallelle kald med forskellige værktøjer
  7. Fejlhåndtering i parallelle kald
  8. Vigtige pointer

Flere værktøjer i ét svar

En af de mest kraftfulde funktioner ved Grok-funktionskald er evnen til at returnere flere værktøjskald i ét enkelt svar. I stedet for at foretage en tur-retur for hver funktion, identificerer modellen al den information, den har brug for, og genererer hvert kald parallelt.

Parameteren parallel_tool_calls

Parallelle kald er aktiveret som standard. Parameteren parallel_tool_calls styrer denne adfærd:

# Aktiveret som standard (behøver ikke at blive specificeret)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Dette er standardværdien
)

Når en bruger spørger: „Hvad er vejret i Paris og Lyon?”, returnerer modellen to tool_calls i samme svar:

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

Håndtering af parallelle kald

Din kode skal håndtere et array af tool_calls, ikke bare ét:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Udfør alle funktioner
    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)
        })

    # Send ALLE resultater tilbage til modellen
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Alle resultater
    ]

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

Vigtigt punkt: Du skal returnere alle værktøjsresultater, ikke kun det første. Hvert resultat er knyttet til dets tilsvarende tool_call_id.

Ægte parallel eksekvering på klienten

Modellen returnerer kald parallelt, men din kode skal eksekvere dem parallelt. I Python bruger du asyncio eller 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

Parallel eksekvering reducerer den samlede ventetid markant. Hvis hvert API-kald tager 200 ms, vil to sekventielle kald tage 400 ms, mens to parallelle kald tager ~200 ms.

Deaktivering af parallelle kald

I nogle tilfælde vil du have sekventielle kald:

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

Deaktiver parallelitet, når uafhængigheden mellem kald ikke er garanteret. Det mest åbenlyse tilfælde er dataafhængighed: Hvis resultatet fra ét værktøj indgår i argumenterne til det næste værktøj – f.eks. opslag af et kunde-ID før hentning af deres ordrer – vil kørsel i parallel i bedste fald forårsage en fejl og i værste fald producere et stille fejlagtigt resultat. Forretningslogisk rækkefølge pålægger den samme begrænsning: Oprettelse af en bruger før tildeling af en rolle er ikke-forhandlingsbar, og kun sekventiel tilstand garanterer dette. To mere praktiske årsager fuldender billedet: Et eksternt API underlagt grænser for samtidige anmodninger vil ikke håndtere en byge af parallelle kald godt, og under udvikling gør sekventiel tilstand sporing af kald uendeligt mere læsbar – ét kald, ét resultat, én log, i rækkefølge.

Parallelle kald med forskellige værktøjer

Modellen kan også kalde forskellige værktøjer parallelt:

# Anmodning: "Book et bord og fortæl mig vejret i aften"
# Modellen returnerer:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Dette er særligt nyttigt for alsidige assistenter, der har brug for at indsamle information fra forskellige kilder.

Fejlhåndtering i parallelle kald

Når ét kald fejler, men andre lykkes, skal du stadig returnere alle resultater. Modellen håndterer individuelle fejl:

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

Vigtige pointer

  • Parallelle kald er aktiveret som standard (parallel_tool_calls: true)
  • Modellen returnerer flere tool_calls i ét enkelt svar
  • Du skal returnere alle resultater, hver knyttet til sin tool_call_id
  • Implementer klient-side parallel eksekvering for at reducere ventetid
  • Deaktiver parallelitet, når der er afhængigheder mellem kald
  • Håndter fejl individuelt – bloker ikke alt for en enkelt fejl