Apelarea funcțiilor: Conectați IA la sistemele dumneavoastră
Pe această pagină
Apelarea funcțiilor: Conectați IA la sistemele dumneavoastră
Apelarea funcțiilor permite modelului să invoce funcții pe care le definiți dumneavoastră. Rețineți o singură regulă fundamentală, deoarece totul decurge din ea: modelul nu le execută. El vă indică ce funcție să apelați și cu ce argumente; codul dumneavoastră efectuează execuția și returnează rezultatul. Baza de date, credențialele și logica de afaceri nu părăsesc niciodată infrastructura dumneavoastră.
Fluxul complet, pas cu pas
Schimbul de date se desfășoară în patru etape:
- Declarați funcțiile disponibile împreună cu parametrii lor
- Modelul analizează cererea și decide să apeleze o funcție
- Codul dumneavoastră execută funcția și obține rezultatul
- Trimiteți rezultatul înapoi la model pentru a-i permite formularea răspunsului
Declarația necesită o atenție deosebită: description funcției și descrierea fiecărui parametru sunt singurele documente de care dispune modelul pentru a lua o decizie. Descrierile vagi duc la apeluri aproximative. De asemenea, observați cum se închide bucla: rezultatul este trimis înapoi împreună cu call_id pe care l-ați primit, care acționează ca o confirmare de primire și permite API-ului să asocieze răspunsul cu cererea.
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.
Permiterea modelului de a alege dintre mai multe instrumente
Valoarea reală apare atunci când expuneți un întreg catalog de capacități. În cazul unui asistent de e-commerce, ați declara căutarea de produse, verificarea stocului și plasarea comenzilor, lăsând apoi modelul să arbitreze. În fața întrebării „Este disponibil laptopul de gaming XPS?“, acesta nu va efectua o căutare, ci va interoga direct stocul: descrierile funcțiilor dumneavoastră, nu o regulă codificată rigid, au condus această alegere.
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"}
O singură cerere poate declanșa, de asemenea, mai multe apeluri simultan. Compararea vremii în două orașe produce două apeluri independente: codul dumneavoastră trebuie, prin urmare, să itereze prin response.output și să gestioneze toate elementele function_call, nu doar pe primul. Aceasta este, de asemenea, o oportunitate de a executa aceste apeluri în paralel și de a reduce latența la jumătate.
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)
Bucla agentului
O singură interacțiune dus-întors este rareori suficientă: rezultatul unei funcții conduce adesea modelul să apeleze alta. Prin urmare, încadrați schimbul într-o buclă care rulează atâta timp cât răspunsul conține apeluri de funcții și se oprește imediat ce nu mai conține – un semn că modelul și-a formulat răspunsul final. Aceasta este structura de bază a fiecărui agent și o veți întâlni sub diverse forme în toate framework-urile de agenți.
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)
O notă de prudență privind acest model: bucla while True nu are mecanisme de protecție. În producție, adăugați un contor maxim de iterații; în caz contrar, un model care solicită indefinit același instrument va epuiza bugetul dumneavoastră fără a concluziona vreodată.
Blocarea argumentelor cu modul strict
Modul strict aplică aceeași garanție parametrilor funcției pe care Structured Output o aplică răspunsurilor: argumentele respectă strict schema declarată. Pentru o funcție care creează un utilizator, acest lucru vă împiedică să primiți vârsta sub formă de șir de caractere sau un câmp suplimentar pe care codul dumneavoastră nu îl aștepta.
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
}
}]
Puncte cheie
- Apelarea funcțiilor conectează modelul la sistemele dumneavoastră fără a expune datele
- Modelul decide ce funcție să apeleze; codul dumneavoastră o execută
- Returnați rezultatul folosind
function_call_outputșicall_id - Modelul poate apela mai multe funcții în paralel
- Utilizați o buclă de agent pentru conversații multi-tur care implică funcții
- Activați
strict: Truepentru a garanta conformitatea argumentelor