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

Архитектура на извикването на функции в Responses API

Урок 1 от 20 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Архитектура на извикването на функции в Responses API
  2. Основният принцип
  3. Анатомия на отговора
  4. Пълният цикъл
  5. Основни разлики спрямо Chat Completions
  6. Кога моделът извиква функция?
  7. Ключови изводи

Обновено на 2 ноември 2026 г. въз основа на документацията на OpenAI: инструментът Code Interpreter вече изисква параметър container (добавен към всички примери), текстовите части за вход използват типа input_text, а уеб търсенето използва инструмента web_search (web_search_preview вече е остарял инструмент без филтри за домейни). Генерираните файлове се извличат чрез функциите fichiers_generes и telecharger от Урок 10. Източници: Code Interpreter · Web search.

Архитектура на извикването на функции в Responses API

Извикването на функции е основният механизъм, който позволява на моделите на OpenAI да взаимодействат с външния свят. В Responses API този механизъм е преконструиран, за да бъде по-надежден, по-предсказуем и нативно интегриран с вградени инструменти като Web Search и Code Interpreter.

Основният принцип

Моделът никога не извършва нищо директно. Той генерира структурирани намерения, които Вашият код прихваща и изпълнява. Изказано по този начин, това може да звучи като техническо ограничение; в действителност обаче това е проектното решение, което прави всичко останало възможно.

Помислете за алтернативата. Ако моделът изпълняваше действия сам, щяхте да трябва да му предадете удостоверителните данни за базата данни, API ключовете и правата за запис – и нямаше да имате точка, в която да проверите каквото и да е. При разделянето на отговорностите всяко намерение преминава през Вашия код: Вие валидирате аргументите, налагате бизнес правилата и отказвате изпълнение, ако е необходимо. Моделът предлага, Вашият код разпорежда, и именно тази граница Ви позволява да внедрите извикването на функции в продукционна среда, без да губите контрол.

from openai import OpenAI

client = OpenAI()

# Деклариране на персонализиран инструмент
tools = [{
    "type": "function",
    "name": "rechercher_client",
    "description": "Search for a client in the CRM by name or email",
    "parameters": {
        "type": "object",
        "properties": {
            "terme": {
                "type": "string",
                "description": "Client name, email, or ID"
            },
            "champ": {
                "type": "string",
                "enum": ["nom", "email", "id"],
                "description": "Field to search in"
            }
        },
        "required": ["terme"]
    }
}]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Find the client Jean Dupont",
    tools=tools
)

Анатомия на отговора

Един отговор не съдържа или текст, или извиквания на инструменти: output е хетерогенен списък, който може да смесва и двете. Навикът, който трябва да изградите от първия ред код, е да итерирате през този списък, вместо да четете output[0] – модел, който обяснява разсъжденията си преди да извика функция, произвежда точно този случай, и код, който чете първия елемент, ще се срути в деня, в който започне да добавя коментари.

for item in response.output:
    if item.type == "function_call":
        print(f"Call ID  : {item.call_id}")
        print(f"Function : {item.name}")
        print(f"Args     : {item.arguments}")

call_id е от съществено значение: той свързва извикването с неговия резултат, когато изпращате отговора обратно към модела. При едно единствено извикване едва ли ще забележите това; при три паралелни извиквания обаче това е единственото нещо, което Ви предпазва от приписването на времето в Лион на заявката за Марсилия. Винаги връщайте резултата с получения call_id, никога с ID, който реконструирате от Ваша страна.

Пълният цикъл

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

import json

# 1. Първо извикване с декларирани инструменти
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the balance for client [email protected]?",
    tools=tools
)

# 2. Откриване и изпълнение на извиквания на функции
resultats = []
for item in response.output:
    if item.type == "function_call":
        if item.name == "rechercher_client":
            args = json.loads(item.arguments)
            resultat = votre_crm.rechercher(args["terme"])
            resultats.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(resultat)
            })

# 3. Изпращане на резултатите обратно към модела
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)

# 4. Моделът формулира своя естествен отговор
print(response_finale.output_text)

Основни разлики спрямо Chat Completions

Responses API носи няколко архитектурни подобрения.

Нативно управление на вградени инструменти

Вградените инструменти се декларират точно като Вашите функции, но те се изпълняват от страната на OpenAI. Практическият резултат е приятен: не пишете никакъв цикъл за тях. Моделът извиква, получава резултата и продължава, всичко в един единствен кръг на комуникация. Описаният по-горе цикъл се отнася само за Вашите функции – тези, които се изпълняват на Вашата машина.

# Смесване на вградени и персонализирани инструменти
tools = [
    {"type": "web_search"},
    {"type": "code_interpreter", "container": {"type": "auto"}},
    {
        "type": "function",
        "name": "ma_fonction",
        "description": "My custom function",
        "parameters": {"type": "object", "properties": {}}
    }
]

Стабилни идентификатори на извикванията

Всяко извикване на функция получава уникален call_id, който Ви позволява точно да проследите кой резултат на кое извикване съответства, дори при паралелни извиквания.

Опростен поток

Няма нужда ръчно да управлявате ролите assistant и tool в съобщенията. Полето input директно приема конкатениране на предишни изходи с резултати от функции.

Кога моделът извиква функция?

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

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

# Позволете на модела да реши
tool_choice = "auto"

# Принудете извикване на конкретна функция
tool_choice = {"type": "function", "name": "rechercher_client"}

# Забранете всички извиквания на функции
tool_choice = "none"

# Изисквайте поне едно извикване, без да уточнявате кое
tool_choice = "required"

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

  • Извикването на функции е протокол за намерения, а не протокол за изпълнение
  • Цикълът извикване-изпълнение-връщане е основният шаблон
  • Вградените и персонализираните инструменти съществуват заедно в един и същи масив tools
  • call_id осигурява проследимост за всяко извикване
  • tool_choice Ви позволява фино да контролирате поведението на модела