`;
});
clearInterval(interval);
}
attempts++;
if (attempts >= maxAttempts) {
clearInterval(interval);
}
}, 200);
return ;
}
};
`Function Calling` permet aux modèles d’IA d’interagir avec des outils et des API externes, leur permettant d’effectuer des actions spécifiques et d’accéder à des informations en temps réel. Cette fonctionnalité étend les capacités des modèles d’IA au-delà de la simple génération de texte, ouvrant la voie à des applications plus dynamiques et pratiques.
## Modèles pris en charge
Les modèles suivants prennent en charge `Function Calling` :
## Guide de démarrage rapide
Ce guide montre comment utiliser l’appel de fonctions pour récupérer les informations météorologiques actuelles d’un emplacement spécifié par l’utilisateur. Nous allons parcourir un exemple complet de code Python.
Pour le format d’API spécifique de l’appel de fonctions, veuillez consulter la référence API [Create Chat Completion](/docs/fr/api-reference/model-apis-llm-create-chat-completion).
### 1. Initialiser le client
Tout d’abord, vous devez initialiser le client avec votre clé API Novita.
```python theme={"system"}
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/openai",
# Get the Novita AI API Key from: https://novita.ai/settings/key-management.
api_key="",
)
model = "deepseek/deepseek_v3"
```
### 2. Définir la fonction à appeler
Ensuite, définissez la fonction Python que le modèle peut appeler. Dans cet exemple, il s’agit d’une fonction permettant d’obtenir des informations météorologiques.
```python theme={"system"}
# Example function to simulate fetching weather data.
def get_weather(location):
"""Retrieves the current weather for a given location."""
print("Calling get_weather function with location: ", location)
# In a real application, you would call an external weather API here.
# This is a simplified example returning hardcoded data.
return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})
```
### 3. Construire la requête API avec les outils et le message utilisateur
Créez maintenant la requête API vers le point de terminaison Novita. Cette requête inclut le paramètre `tools`, qui définit les fonctions que le modèle peut utiliser, ainsi que le message de l’utilisateur.
```python theme={"system"}
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather of an location, the user shoud supply a location first",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA",
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "What is the weather in San Francisco?"
}
]
# Let's send the request and print the response.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Please check if the response contains tool calls if in production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
```
**Sortie :**
```js theme={"system"}
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
```
### 4. Répondre avec le résultat de l’appel de fonction et obtenir la réponse finale
L’étape suivante consiste à traiter l’appel de fonction, à exécuter la fonction `get_weather`, puis à renvoyer le résultat au modèle afin de générer la réponse finale à l’utilisateur.
```python theme={"system"}
# Ensure tool_call is defined from the previous step
if tool_call:
# Extend conversation history with the assistant's tool call message
messages.append(response.choices[0].message)
function_name = tool_call.function.name
if function_name == "get_weather":
function_args = json.loads(tool_call.function.arguments)
# Execute the function and get the response
function_response = get_weather(
location=function_args.get("location"))
# Append the function response to the messages
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Get the final response from the model, now with the function result
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Note: Do not include tools parameter here.
)
print(answer_response.choices[0].message)
```
**Sortie :**
```
ChatCompletionMessage(content="The weather in San Francisco, CA is currently **60 degrees Fahrenheit**. For more detailed information, such as specific conditions (e.g., sunny, cloudy, rainy), you might want to check a local weather app or website. Let me know if you'd like help with anything else!", refusal=None, role='assistant', function_call=None, tool_calls=None)
```
### Le code complet
```python theme={"system"}
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/openai",
# Get the Novita AI API Key from: https://novita.ai/settings/key-management.
api_key="",
)
model = "deepseek/deepseek_v3"
# Example function to simulate fetching weather data.
def get_weather(location):
"""Retrieves the current weather for a given location."""
print("Calling get_weather function with location: ", location)
# In a real application, you would call an external weather API here.
# This is a simplified example returning hardcoded data.
return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather of an location, the user shoud supply a location first",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA",
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "What is the weather in San Francisco?"
}
]
# Let's send the request and print the response.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Please check if the response contains tool calls if in production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
# Ensure tool_call is defined from the previous step
if tool_call:
# Extend conversation history with the assistant's tool call message
messages.append(response.choices[0].message)
function_name = tool_call.function.name
if function_name == "get_weather":
function_args = json.loads(tool_call.function.arguments)
# Execute the function and get the response
function_response = get_weather(
location=function_args.get("location"))
# Append the function response to the messages
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Get the final response from the model, now with the function result
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Note: Do not include tools parameter here
)
print(answer_response.choices[0].message)
```