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

Apeluri paralele și secvențiale

Lecția 3 din 20 Dezvoltator
Pe această pagină
  1. Apeluri paralele și secvențiale
  2. Apeluri paralele
  3. Dezactivarea apelurilor paralele
  4. Apeluri secvențiale cu o buclă
  5. Exemplu lucrat: Pipeline de procesare
  6. Model hibrid: Paralel, apoi secvențial
  7. Puncte cheie

Apeluri paralele și secvențiale

Modelul poate emite mai multe apeluri de funcții într-un singur răspuns, făcând acest lucru automat ori de câte ori identifică nevoi independente. Aceasta nu este doar o optimizare cosmetică: trei apeluri de câte două secunde executate împreună durează în total două secunde, dar executate secvențial (în lanț) durează șase.

Adevăratul focus al acestei lecții nu este modul de paralelizare — modelul se ocupă de asta — ci cum să recunoașteți cazurile în care nu trebuie să o faceți. Două apeluri sunt independente atunci când ordinea de execuție nu afectează rezultatul. De îndată ce o operațiune citește ceea ce alta scrie, sau un parametru trebuie să provină dintr-un apel anterior, paralelismul devine o eroare greu de reprodus.

Apeluri paralele

Nu este necesară nicio activare: acesta este comportamentul implicit. O interogare despre trei orașe produce trei elemente function_call în același răspuns; dumneavoastră le executați. Rețineți că modelul raționează asupra sensului funcțiilor pe baza descrierilor dumneavoastră — descrierile conduc decizia, ca în aproape totul în acest curs.

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

Executarea apelurilor paralele pe partea clientului

Recepționarea a trei apeluri simultan este inutilă dacă codul dumneavoastră le execută unul după altul: pierdeți tot câștigul pe partea clientului. asyncio.gather este minimul necesar; adăugați două precauții pentru producție — o limită de concurență, pentru a nu deschide cincizeci de conexiuni simultane către un serviciu care suportă doar zece, și gestionarea erorilor per apel, astfel încât o defecțiune izolată să nu ducă la pierderea celorlalte rezultate.

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)

Dezactivarea apelurilor paralele

parallel_tool_calls=False forțează modelul să emită un singur apel per răspuns. Utilizați această setare în mod deliberat: faceți schimb de latență pentru siguranță. Rezervați-o pentru funcțiile care scriu, modifică sau declanșează ceva extern.

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

Cazuri de utilizare pentru dezactivarea paralelismului:

  • Operațiuni care trebuie executate într-o ordine specifică
  • Funcții cu efecte secundare care interferează între ele
  • Când rezultatul unui apel condiționează următorul

Apeluri secvențiale cu o buclă

Execuția secvențială nu este controlată de un parametru: ea emerge din buclă. Dumneavoastră executați apelul, trimiteți înapoi rezultatul, iar modelul decide următorul pas pe baza a ceea ce tocmai a învățat. Acesta este exact lucrul care distinge un lanț dinamic de un plan rigid — dacă pasul 2 relevă faptul că pasul 3 este inutil, modelul nu îl va apela.

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"

Exemplu lucrat: Pipeline de procesare

Un caz tipic în care execuția secvențială este obligatorie, deoarece fiecare pas consumă ceea ce a produs cel anterior:

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
)

Model hibrid: Paralel, apoi secvențial

În practică, majoritatea fluxurilor de lucru din lumea reală urmează acest model mixt: o fază de colectare în care totul poate rula simultan, urmată de o fază de procesare care respectă dependențele. Nu trebuie să codificați nimic special pentru aceasta — este consecința naturală a buclei, cu condiția ca descrierile dumneavoastră să facă dependențele clare.

# 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

Acest model pare natural: modelul paralelizează automat atunci când apelurile sunt independente, apoi le înlănțuie secvențial când apare o dependență.

Puncte cheie

  • Modelul paralelizează automat apelurile independente
  • Utilizați asyncio.gather pentru a executa apeluri paralele pe partea clientului
  • Dezactivați cu parallel_tool_calls=False atunci când ordinea contează
  • Implementați o buclă pentru fluxurile de lucru în mai mulți pași
  • Descrierile funcțiilor ghidează modelul privind dependențele dintre pași