Премини към основното съдържание
Български— Изберете език
Меню

Извиквания паралелно и последователно

Урок 3 от 20 Програмист
На тази страница
  1. Извиквания паралелно и последователно
  2. Паралелни извиквания
  3. Деактивиране на паралелни извиквания
  4. Последователни извиквания с цикъл
  5. Работен пример: Тръбопровод за обработка
  6. Хибриден шаблон: Първо паралелно, после последователно
  7. Ключови изводи

Извиквания паралелно и последователно

Моделът може да генерира множество извиквания на функции в един единствен отговор, правейки това автоматично, когато идентифицира независими нужди. Това не е просто козметична оптимизация: три извиквания от по две секунди, изпълнени едновременно, отнемат общо две секунди, но ако се изпълнят последователно (верижно), ще отнемат шест.

Истинският фокус на този урок не е как да се постигне паралелизъм – моделът се справя с това сам – а как да разпознаете случаите, в които не трябва да го правите. Две извиквания са независими, когато редът на изпълнение не влияе на резултата. Щом една операция чете данни, записани от друга, или даден параметър трябва да произлезе от предишно извикване, паралелизмът се превръща в трудно възпроизводим бъг.

Паралелни извиквания

Нищо не трябва да се активира: това е поведението по подразбиране. Запитване относно три града ще генерира три елемента function_call в един и същи отговор; Вие ги изпълнявате. Имайте предвид, че моделът разсъждава върху смисъла на функциите въз основа на Вашите описания – описанията движат решението, както почти във всичко в този курс.

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

Изпълнение на паралелни извиквания от страна на клиента

Получаването на три извиквания наведнъж е безполезно, ако Вашият код ги изпълнява едно след друго: губите цялата полза от страна на клиента. asyncio.gather е минимумът; добавете две предпазни мерки за продукционна среда – ограничение на конкурентността, за да не отваряте петдесет едновременни връзки към услуга, която поддържа само десет, и обработка на грешки за всяко извикване поотделно, така че изолиран неуспех да не срива останалите резултати.

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)

Деактивиране на паралелни извиквания

parallel_tool_calls=False принуждава модела да генерира само едно извикване на отговор. Използвайте тази настройка умишлено: тя разменя латентност за безопасност. Запазете я за функции, които записват, модифицират или задействат нещо външно.

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

Случаи на употреба за деактивиране на паралелизма:

  • Операции, които трябва да се изпълнят в конкретен ред
  • Функции със странични ефекти, които си пречат взаимно
  • Когато резултатът от едно извикване обуславя следващото

Последователни извиквания с цикъл

Последователното изпълнение не се контролира от параметър: то възниква от цикъла. Вие изпълнявате извикването, изпращате обратно резултата и моделът решава следващата стъпка въз основа на току-що наученото. Това е точно това, което отличава динамичната верига от твърдия план – ако стъпка 2 разкрие, че стъпка 3 е ненужна, моделът няма да я извика.

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"

Работен пример: Тръбопровод за обработка

Типичен случай, при който последователното изпълнение е задължително, защото всяка стъпка консумира това, което предишната е произвела:

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
)

Хибриден шаблон: Първо паралелно, после последователно

На практика повечето реални работни потоци следват този смесен шаблон: фаза на събиране, където всичко може да се изпълнява едновременно, последвана от фаза на обработка, която спазва зависимостите. Не е необходимо да кодирате нищо специално за това – това е естественото следствие от цикъла, стига описанията Ви да правят зависимостите ясни.

# 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

Този шаблон изглежда естествен: моделът автоматично паралелизира, когато извикванията са независими, след което ги верижно свързва последователно, когато се появи зависимост.

Ключови изводи

  • Моделът автоматично паралелизира независимите извиквания
  • Използвайте asyncio.gather, за да изпълнявате паралелни извиквания от страна на клиента
  • Деактивирайте с parallel_tool_calls=False, когато редът има значение
  • Внедрете цикъл за работни потоци с няколко стъпки
  • Описанията на функциите насочват модела относно зависимостите между стъпките