Function Calling: Połącz AI ze swoimi systemami
Na tej stronie
Function Calling: Połącz AI ze swoimi systemami
Function calling pozwala modelowi wywoływać funkcje, które sam zdefiniujesz. Zapamiętaj jedną kluczową zasadę, bo wszystko inne wynika właśnie z niej: model nie wykonuje tych funkcji. Informuje cię jedynie, którą funkcję należy wywołać i z jakimi argumentami; to twój kod przeprowadza egzekucję i zwraca wynik. Twoja baza danych, poświadczenia i logika biznesowa nigdy nie opuszczają twojej infrastruktury.
Pełny przepływ krok po kroku
Wymiana informacji odbywa się w czterech etapach:
- Deklarujesz dostępne funkcje wraz z ich parametrami
- Model analizuje żądanie i decyduje o wywołaniu funkcji
- Twój kod wykonuje funkcję i uzyskuje wynik
- Wysyłasz wynik z powrotem do modelu, aby mógł sformułować odpowiedź
Deklaracja wymaga szczególnej uwagi: opis funkcji (description) oraz opisy każdego parametru to jedyna dokumentacja, na podstawie której model podejmuje decyzję. Niejasne opisy prowadzą do przybliżonych wywołań. Zwróć też uwagę na sposób domykania pętli – wynik wraca z użyciem call_id, które otrzymałeś; działa ono jak potwierdzenie i pozwala API dopasować odpowiedź do żądania.
from openai import OpenAI
import json
client = OpenAI()
# Krok 1: Deklaracja dostępnych funkcji
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"]
}
}]
# Krok 2: Model decyduje o wywołaniu funkcji
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather like in Marseille?",
tools=tools
)
# Krok 3: Wykonanie funkcji
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)
# Twoja rzeczywista implementacja
resultat_meteo = {"temperature": 22, "condition": "sunny"}
# Krok 4: Wysłanie wyniku z powrotem do modelu
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}")
# Wynik:
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.
Pozwól modelowi wybierać spośród wielu narzędzi
Prawdziwa wartość ujawnia się, gdy udostępnisz cały katalog możliwości. W asystencie e-commerce zadeklarowałbyś wyszukiwanie produktów, weryfikację stanów magazynowych i składanie zamówień, pozostawiając modelowi rolę arbitra. W obliczu pytania „Czy laptop gamingowy XPS jest dostępny?“ nie uruchomi on wyszukiwania, lecz odpyta bezpośrednio stan magazynowy: to opisy twoich funkcji, a nie sztywna reguła zakodowana na sztywno, kierowały tym wyborem.
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"]
}
}
]
# Model automatycznie wybiera właściwą funkcję
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}")
# Wynik: Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}
Jedno żądanie może również uruchomić wiele wywołań jednocześnie. Porównanie pogody w dwóch miastach generuje dwa niezależne wywołania: twój kod musi zatem iterować po response.output i obsłużyć wszystkie elementy function_call, a nie tylko pierwszy. To także okazja, by wykonać te wywołania równolegle i skrócić czas odpowiedzi o połowę.
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"]
}
}]
)
# Model wykonuje dwa wywołania równolegle
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']})")
# Wynik:
# Number of calls: 2
# - get_meteo(Paris)
# - get_meteo(Lyon)
Pętla agenta
Jedna wymiana rzadko wystarcza: wynik jednej funkcji często skłania model do wywołania kolejnej. Dlatego opakowujesz wymianę w pętlę, która działa tak długo, jak długo odpowiedź zawiera wywołania funkcji, i kończy się, gdy ich brak – co oznacza, że model sformułował już ostateczną odpowiedź. To szkielet każdego agenta; spotkasz go pod różnymi postaciami we wszystkich frameworkach agentowych.
def executer_fonction(nom: str, arguments: str) -> str:
"""Execute a function and return the result."""
args = json.loads(arguments)
if nom == "get_meteo":
# Symulacja — zastąp swoim rzeczywistym 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
)
# Sprawdzenie wywołań funkcji
function_calls = [i for i in response.output if i.type == "function_call"]
if not function_calls:
# Brak wywołań funkcji = odpowiedź końcowa
return response.output_text
# Wykonanie każdej funkcji i dodanie wyników
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
})
# Użycie
reponse = agent_loop("What's the weather like in Paris?", tools)
print(reponse)
Ostrzeżenie dotyczące tego wzorca: pętla while True nie ma żadnych zabezpieczeń. W środowisku produkcyjnym dodaj licznik maksymalnej liczby iteracji; w przeciwnym razie model, który w nieskończoność będzie żądał tego samego narzędzia, wypali twój budżet, nigdy nie dochodząc do wniosku.
Zablokuj argumenty dzięki trybowi ścisłemu
Tryb ścisły (strict mode) zapewnia dla parametrów funkcji taką samą gwarancję, jaką Structured Output daje dla odpowiedzi: argumenty ściśle adherują do zadeklarowanego schematu. W przypadku funkcji tworzącej użytkownika zapobiega to sytuacjom, w których otrzymujesz wiek jako ciąg znaków lub dodatkowe pole, którego twój kod nie oczekiwał.
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
}
}]
Kluczowe wnioski
- Function calling łączy model z twoimi systemami bez ujawniania twoich danych
- Model decyduje, którą funkcję wywołać; twój kod ją wykonuje
- Zwracaj wynik, używając
function_call_outputicall_id - Model może wywoływać wiele funkcji równolegle
- Używaj pętli agenta do rozmów wieloetapowych z udziałem funkcji
- Włącz
strict: True, aby zagwarantować zgodność argumentów