Извикване на функции: Свържете ИИ с вашите системи
На тази страница
Извикване на функции: Свържете ИИ с вашите системи
Извикването на функции позволява на модела да активира функции, които Вие дефинирате. Запомнете едно основно правило, защото всичко останало произтича от него: моделът не ги изпълнява. Той Ви казва коя функция да извикате и с какви аргументи; Вашият код извършва изпълнението и връща резултата. Вашата база данни, удостоверителни данни и бизнес логика никога не напускат Вашата инфраструктура.
Пълният поток, стъпка по стъпка
Обменът протича в четири етапа:
- Вие декларирате наличните функции заедно с техните параметри
- Моделът анализира заявката и решава да извика функция
- Вашият код изпълнява функцията и получава резултата
- Вие изпращате резултата обратно на модела, за да може той да формулира своя отговор
Декларацията заслужава специално внимание: description на функцията и описанието на всеки параметър са единствената документация, с която моделът разполага, за да вземе решение. Неясните описания водят до приблизителни извиквания. Обърнете внимание и как се затваря цикълът – резултатът се връща с call_id, който сте получили; той действа като потвърждение и позволява на API да съпостави отговора със заявката.
from openai import OpenAI
import json
client = OpenAI()
# Step 1: Declare available functions
tools = [{
"type": "function",
"name": "get_meteo",
"description": "Get the current weather for a city",
"parameters": {
"type": "object",
"properties": {
"ville": {
"type": "string",
"description": "The name of the city"
},
"unite": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "Temperature unit"
}
},
"required": ["ville"]
}
}]
# Step 2: The model decides to call the function
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather like in Marseille?",
tools=tools
)
# Step 3: Execute the function
for item in response.output:
if item.type == "function_call":
print(f"Function: {item.name}")
print(f"Arguments: {item.arguments}")
args = json.loads(item.arguments)
# Your actual implementation
resultat_meteo = {"temperature": 22, "condition": "sunny"}
# Step 4: Send the result back to the model
final = client.responses.create(
model="gpt-5.6-terra",
input=[
{"role": "user", "content": "What's the weather like in Marseille?"},
{
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(resultat_meteo)
}
],
tools=tools
)
print(f"Response: {final.output_text}")
# Result:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.
Позволяване на модела да избира между множество инструменти
Истинската стойност се проявява, когато изложите цял каталог от възможности. В един асистент за електронна търговия бихте декларирали търсене на продукти, проверка на наличностите и подаване на поръчки, след което оставяте модела да арбитражира. Изправен пред въпроса „Дали лаптопът за игри XPS е наличен?“, той няма да стартира търсене, а ще провери директно наличностите: описанията на Вашите функции, а не твърдо кодирано правило, са движещата сила на този избор.
tools = [
{
"type": "function",
"name": "rechercher_produit",
"description": "Search for a product in the catalog",
"parameters": {
"type": "object",
"properties": {
"requête": {"type": "string", "description": "Search terms"},
"categorie": {"type": "string", "description": "Category (optional)"}
},
"required": ["requête"]
}
},
{
"type": "function",
"name": "verifier_stock",
"description": "Check product availability",
"parameters": {
"type": "object",
"properties": {
"produit_id": {"type": "string", "description": "Product ID"}
},
"required": ["produit_id"]
}
},
{
"type": "function",
"name": "passer_commande",
"description": "Place an order for a product",
"parameters": {
"type": "object",
"properties": {
"produit_id": {"type": "string"},
"quantite": {"type": "integer", "description": "Number of units"}
},
"required": ["produit_id", "quantite"]
}
}
]
# The model automatically chooses the right function
response = client.responses.create(
model="gpt-5.6-terra",
input="Is the XPS gaming laptop available?",
tools=tools
)
for item in response.output:
if item.type == "function_call":
print(f"Function chosen: {item.name}")
print(f"Arguments: {item.arguments}")
# Result: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}
Една единствена заявка може също да задейства множество извиквания едновременно. Сравняването на времето в два града генерира две независими извиквания: следователно Вашият код трябва да итерира през response.output и да обработи всички елементи function_call, а не само първия. Това също така е възможност да изпълните тези извиквания паралелно и да намалите латентността наполовина.
response = client.responses.create(
model="gpt-5.6-terra",
input="Compare the weather between Paris and Lyon.",
tools=[{
"type": "function",
"name": "get_meteo",
"description": "Get the weather for a city",
"parameters": {
"type": "object",
"properties": {
"ville": {"type": "string"}
},
"required": ["ville"]
}
}]
)
# The model makes two calls in parallel
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Number of calls: {len(function_calls)}")
for call in function_calls:
args = json.loads(call.arguments)
print(f" - get_meteo({args['ville']})")
# Result:
# Number of calls: 2
# - get_meteo(Paris)
# - get_meteo(Lyon)
Цикълът на агента
Един единствен обмен рядко е достатъчен: резултатът от една функция често кара модела да извика друга. Затова обвивате обмена в цикъл, който се изпълнява, докато отговорът съдържа извиквания на функции, и спира веднага щом такива липсват – знак, че моделът е формулирал окончателния си отговор. Това е скелетът на всеки агент и ще го срещнете в различни форми във всички рамки за работа с агенти.
def executer_fonction(nom: str, arguments: str) -> str:
"""Execute a function and return the result."""
args = json.loads(arguments)
if nom == "get_meteo":
# Simulation — replace with your real API
return json.dumps({"temp": 18, "condition": "cloudy"})
elif nom == "get_heure":
return json.dumps({"heure": "14:30", "timezone": "CET"})
return json.dumps({"error": "Unknown function"})
def agent_loop(question: str, tools: list) -> str:
"""Agent loop: call functions until the final response."""
input_messages = [{"role": "user", "content": question}]
while True:
response = client.responses.create(
model="gpt-5.6-terra",
input=input_messages,
tools=tools
)
# Check for function calls
function_calls = [i for i in response.output if i.type == "function_call"]
if not function_calls:
# No function calls = final response
return response.output_text
# Execute each function and add results
for call in function_calls:
resultat = executer_fonction(call.name, call.arguments)
input_messages.append({
"type": "function_call_output",
"call_id": call.call_id,
"output": resultat
})
# Usage
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)
Една дума на предупреждение относно този шаблон: цикълът while True няма предпазни механизми. В производствена среда добавете брояч за максимален брой итерации; в противен случай модел, който безкрайно иска един и същи инструмент, ще изчерпи бюджета Ви, без никога да стигне до заключение.
Заключване на аргументите със стриктен режим
Стриктният режим прилага същата гаранция за параметрите на функциите, каквато Структурираният изход прилага за отговорите: аргументите стриктно се придържат към декларираната схема. За функция, която създава потребител, това предотвратява получаването на възраст като низ или на допълнително поле, което кодът Ви не е очаквал.
tools = [{
"type": "function",
"name": "creer_utilisateur",
"description": "Create a new user",
"strict": True,
"parameters": {
"type": "object",
"properties": {
"nom": {"type": "string"},
"email": {"type": "string"},
"age": {"type": "integer"}
},
"required": ["nom", "email", "age"],
"additionalProperties": False
}
}]
Ключови изводи
- Извикването на функции свързва модела с Вашите системи, без да излага Вашите данни
- Моделът решава коя функция да извика; Вашият код я изпълнява
- Върнете резултата, използвайки
function_call_outputиcall_id - Моделът може да извика множество функции паралелно
- Използвайте цикъл на агента за многократни разговори, включващи функции
- Активирайте
strict: True, за да гарантирате съответствието на аргументите