Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Opkald parallelt og sekventielt

Lektion 3 af 20 Udvikler
På denne side
  1. Opkald parallelt og sekventielt
  2. Parallelle kald
  3. Deaktiver parallelle kald
  4. Sekventielle kald med en løkke
  5. Gennemarbejdet eksempel: Behandlingspipeline
  6. Hybridd mønster: Først parallelt, derefter sekventielt
  7. Vigtige pointer

Opkald parallelt og sekventielt

Modellen kan udstede flere funktionskald i ét enkelt svar og gør det automatisk, når den identificerer uafhængige behov. Dette er ikke blot kosmetisk optimering: Tre opkald på to sekunder, der køres sammen, tager samlet to sekunder, men kædes de sekventielt, tager de seks.

Fokus i denne lektion er ikke hvordan man paralleliserer – det håndterer modellen selv – men hvordan man genkender tilfælde, hvor du ikke bør gøre det. To kald er uafhængige, når eksekveringsrækkefølgen ikke påvirker resultatet. Så snart én operation læser det, en anden skriver, eller en parameter skal komme fra et tidligere kald, bliver parallelisme en svær at reproducere fejl.

Parallelle kald

Intet behøver at blive aktiveret: Dette er standardadfærden. En forespørgsel om tre byer producerer tre function_call-elementer i samme svar; du eksekverer dem. Bemærk, at modellen ræsonnerer ud fra betydningen af funktionerne baseret på dine beskrivelser – beskrivelserne styrer beslutningen, ligesom i næsten alt andet i dette kursus.

from openai import OpenAI
import json
import asyncio

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "get_meteo",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "get_taux_change",
        "description": "Get exchange rate between two currencies",
        "parameters": {
            "type": "object",
            "properties": {
                "source": {"type": "string"},
                "cible": {"type": "string"}
            },
            "required": ["source", "cible"],
            "additionalProperties": False
        },
        "strict": True
    }
]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather in Paris and Berlin, "
          "and what is the EUR/USD exchange rate?",
    tools=tools
)

# The model emits 3 calls in parallel
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3

Eksekver parallelle kald på klientsiden

Det nytter ikke noget at modtage tre kald på én gang, hvis din kode eksekverer dem ét efter ét: Så mister du hele gevinsten på klientsiden. asyncio.gather er minimum; til produktion skal du tilføje to forholdsregler: en grænse for samtidighed, så du ikke åbner halvtreds samtidige forbindelser til en tjeneste, der kun understøtter ti, og fejlhåndtering pr. kald, så en isoleret fejl ikke vælter de andre resultater.

async def executer_fonction(name: str, arguments: str) -> dict:
    args = json.loads(arguments)
    if name == "get_meteo":
        return await api_meteo(args["ville"])
    elif name == "get_taux_change":
        return await api_change(args["source"], args["cible"])

async def traiter_appels_paralleles(appels):
    taches = [
        executer_fonction(appel.name, appel.arguments)
        for appel in appels
    ]
    resultats = await asyncio.gather(*taches)

    return [
        {
            "type": "function_call_output",
            "call_id": appel.call_id,
            "output": json.dumps(resultat)
        }
        for appel, resultat in zip(appels, resultats)
    ]

# Execute
resultats = asyncio.run(traiter_appels_paralleles(appels))

# Send back to the model
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)
print(response_finale.output_text)

Deaktiver parallelle kald

parallel_tool_calls=False tvinger modellen til kun at udstede ét kald pr. svar. Brug denne indstilling bevidst: Det bytter ventetid ud mod sikkerhed. Reserver det til funktioner, der skriver, ændrer eller udløser noget eksternt.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Process these three orders",
    tools=tools,
    parallel_tool_calls=False  # One call per response
)

Anvendelsestilfælde for deaktivering af parallelisme:

  • Operationer, der skal eksekveres i en bestemt rækkefølge
  • Funktioner med bivirkninger, der forstyrrer hinanden
  • Når resultatet af ét kald betinger det næste

Sekventielle kald med en løkke

Sekventiel eksekvering styres ikke af en parameter: Den opstår af løkken. Du eksekverer kaldet, sender resultatet tilbage, og modellen beslutter næste skridt baseret på det, den lige har lært. Det er præcis det, der adskiller en dynamisk kæde fra en stiv plan – hvis trin 2 afslører, at trin 3 er unødvendigt, vil modellen ikke kalde det.

def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
    """Complete loop for sequential function calling."""
    messages_input = prompt
    tour = 0

    while tour < max_tours:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=messages_input,
            tools=tools,
            parallel_tool_calls=False
        )

        # Check for function calls
        appels = [i for i in response.output if i.type == "function_call"]

        if not appels:
            # Model is done, responding with text
            return response.output_text

        # Execute each call
        resultats = []
        for appel in appels:
            resultat = executer_fonction_sync(appel.name, appel.arguments)
            resultats.append({
                "type": "function_call_output",
                "call_id": appel.call_id,
                "output": json.dumps(resultat)
            })

        # Prepare next turn
        messages_input = response.output + resultats
        tour += 1

    return "Turn limit reached"

Gennemarbejdet eksempel: Behandlingspipeline

Et typisk tilfælde, hvor sekventiel eksekvering er obligatorisk, fordi hvert trin forbruger det, det foregående har produceret:

tools_pipeline = [
    {
        "type": "function",
        "name": "valider_commande",
        "description": "Verify order validity (stock, price, customer)",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"}
            },
            "required": ["commande_id"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "calculer_livraison",
        "description": "Calculate shipping fees and delays. "
                       "Requires a validated order.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "mode": {"type": "string", "enum": ["standard", "express"]}
            },
            "required": ["commande_id", "mode"],
            "additionalProperties": False
        },
        "strict": True
    },
    {
        "type": "function",
        "name": "confirmer_commande",
        "description": "Confirm the order and trigger payment. "
                       "Requires prior validation and shipping calculation.",
        "parameters": {
            "type": "object",
            "properties": {
                "commande_id": {"type": "string"},
                "livraison_id": {"type": "string"}
            },
            "required": ["commande_id", "livraison_id"],
            "additionalProperties": False
        },
        "strict": True
    }
]

# The model will naturally call in this order:
# 1. valider_commande
# 2. calculer_livraison (using step 1 result)
# 3. confirmer_commande (using results from steps 1 and 2)
resultat = boucle_function_calling(
    "Process order CMD-42567 with express shipping",
    tools_pipeline
)

Hybridd mønster: Først parallelt, derefter sekventielt

I praksis følger de fleste virkelige arbejdsgange dette blandede mønster: En indsamlingsfase, hvor alt kan køre samtidigt, efterfulgt af en behandlingsfase, der respekterer afhængigheder. Du behøver ikke kode noget specielt til dette – det er den naturlige konsekvens af løkken, forudsat at dine beskrivelser gør afhængighederne klare.

# Turn 1: Parallel data collection
# The model calls get_client AND get_stock in parallel

# Turn 2: Sequential decision based on results
# The model calls valider_commande with collected info

# Turn 3: Final action
# The model calls confirmer_commande

Dette mønster føles naturligt: Modellen paralleliserer automatisk, når kald er uafhængige, og kæder derefter sekventielt, når en afhængighed opstår.

Vigtige pointer

  • Modellen paralleliserer automatisk uafhængige kald
  • Brug asyncio.gather til at eksekvere parallelle kald på klientsiden
  • Deaktiver med parallel_tool_calls=False, når rækkefølgen betyder noget
  • Implementer en løkke til arbejdsgange med flere trin
  • Funktionsbeskrivelser guider modellen omkring afhængigheder mellem trin