Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Kvietimai lygiagrečiai ir nuosekliai

Paskaita 3 iš 20 Kūrėjas
Šiame puslapyje
  1. Kvietimai lygiagrečiai ir nuosekliai
  2. Lygiagretūs kvietimai
  3. Lygiagrečių kvietimų išjungimas
  4. Nuoseklūs kvietimai naudojant ciklą
  5. Pavyzdys: apdorojimo grandinė
  6. Hibridinis šablonas: pirma lygiagrečiai, paskui nuosekliai
  7. Svarbiausi punktai

Kvietimai lygiagrečiai ir nuosekliai

Modelis viename atsakyme gali pateikti kelis funkcijų kvietimus ir tai daro automatiškai, kai nustato nepriklausomus poreikius. Tai ne tik kosmetinis optimizavimas: trys dviejų sekundžių trukmės kvietimai, įvykdyti kartu, užtrunka iš viso dvi sekundes, o vykdomi nuosekliai grandine – šešias.

Šios pamokos esmė ne tai, kaip lygiagretinti – modelis tai tvarko pats – o kaip atpažinti atvejus, kada to daryti negalima. Du kvietimai yra nepriklausomi, kai vykdymo eiliškumas neturi įtakos rezultatui. Kai tik viena operacija skaito tai, ką rašo kita, arba parametras turi būti gautas iš ankstesnio kvietimo, lygiagretumas tampa sunkiai atkuriamu klaidos šaltiniu.

Lygiagretūs kvietimai

Nieko nereikia įjungti: tai yra numatytoji elgsena. Užklausa apie tris miestus tame pačiame atsakyme sugeneruos tris function_call elementus; tau tereikia juos įvykdyti. Atkreipk dėmesį, kad modelis samprotauja apie funkcijų prasmę remdamasis tavo pateiktais aprašymais – būtent aprašymai lemia sprendimą, kaip ir beveik visur šiame kurse.

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

Lygiagrečių kvietimų vykdymas kliento pusėje

Gauti tris kvietimus vienu metu yra beprasmiška, jei tavo kodas juos vykdo vieną po kito: taip prarandi visą naudą kliento pusėje. asyncio.gather yra minimumas; gamybinei aplinkai pridėk dvi atsargumo priemones – lygiagretumo ribą, kad neatidarytum penkiasdešimties simultaninių ryšių su tarnyba, palaikančia tik dešimt, ir kiekvieno kvietimo klaidų apdorojimą, kad pavienis gedimas nenugriautų kitų rezultatų.

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)

Lygiagrečių kvietimų išjungimas

parallel_tool_calls=False priverčia modelį kiekviename atsakyme pateikti tik vieną kvietimą. Naudok šį nustatymą sąmoningai: tai mainai tarp delsos ir saugumo. Palik jį funkcijoms, kurios rašo, modifikuoja arba suaktyvina ką nors išorėje.

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

Atvejai, kada verta išjungti lygiagretumą:

  • Operacijos, kurios turi būti vykdomos griežta eilės tvarka
  • Funkcijos su šalutiniais poveikiais, kurie trukdo viena kitai
  • Kai vieno kvietimo rezultatas lemia kitą

Nuoseklūs kvietimai naudojant ciklą

Nuoseklus vykdymas valdomas ne parametru: jis išplaukia iš ciklo. Įvykdai kvietimą, grąžini rezultatą, o modelis, remdamasis tuo, ką ką tik sužinojo, nusprendžia, ką daryti toliau. Būtent tai skiria dinaminę grandinę nuo standaus plano – jei antras žingsnis atskleidžia, kad trečias nereikalingas, modelis jo nekvies.

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"

Pavyzdys: apdorojimo grandinė

Tipinis atvejis, kai nuoseklus vykdymas yra privalomas, nes kiekvienas žingsnis sunaudoja tai, ką sukūrė ankstesnis:

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
)

Hibridinis šablonas: pirma lygiagrečiai, paskui nuosekliai

Praktiškai dauguma realių darbo eigų laikosi šio mišraus šablono: duomenų rinkimo fazė, kai viskas gali vykti simultaniškai, o po jos – apdorojimo fazė, gerbianti priklausomybes. Tau nereikia rašyti jokio specialaus kodo – tai natūrali ciklo pasekmė, jei tavo aprašymuose aiškiai įvardytos priklausomybės.

# 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

Šis šablonas atrodo natūralus: modelis automatiškai lygiagretina kvietimus, kai jie nepriklausomi, o atsiradus priklausomybei – juos grandina nuosekliai.

Svarbiausi punktai

  • Modelis automatiškai lygiagretina nepriklausomus kvietimus
  • Lygiagrečiams kvietimams kliento pusėje vykdyti naudok asyncio.gather
  • Išjunk naudodamas parallel_tool_calls=False, kai svarbi eiliškumas
  • Daugiažingsnėms darbo eigoms įgyvendink ciklą
  • Funkcijų aprašymai nukreipia modelį dėl priklausomybių tarp žingsnių