`;
});
clearInterval(interval);
}
attempts++;
if (attempts >= maxAttempts) {
clearInterval(interval);
}
}, 200);
return ;
}
};
`Function Calling` ermöglicht es KI-Modellen, mit externen Tools und APIs zu interagieren, sodass sie bestimmte Aktionen ausführen und auf Echtzeitinformationen zugreifen können. Diese Fähigkeit erweitert die Funktionalität von KI-Modellen über die einfache Textgenerierung hinaus und ermöglicht dynamischere und praktischere Anwendungen.
## Unterstützte Modelle
Die folgenden Modelle unterstützen `Function Calling`:
## Schnellstartanleitung
Diese Anleitung zeigt, wie Sie Function Calling verwenden, um aktuelle Wetterinformationen für einen vom Benutzer angegebenen Standort abzurufen. Wir gehen ein vollständiges Python-Codebeispiel durch.
Das spezifische API-Format von Function Calling finden Sie in der API-Referenz [Create Chat Completion](/docs/de/api-reference/model-apis-llm-create-chat-completion).
### 1. Client initialisieren
Zunächst müssen Sie den Client mit Ihrem Novita-API-Schlüssel initialisieren.
```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. Die aufzurufende Funktion definieren
Definieren Sie als Nächstes die Python-Funktion, die das Modell aufrufen kann. In diesem Beispiel handelt es sich um eine Funktion zum Abrufen von Wetterinformationen.
```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. API-Anfrage mit Tools und Benutzernachricht erstellen
Erstellen Sie nun die API-Anfrage an den Novita-Endpunkt. Diese Anfrage enthält den Parameter `tools`, der die Funktionen definiert, die das Modell verwenden kann, sowie die Nachricht des Benutzers.
```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())
```
**Ausgabe:**
```js theme={"system"}
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
```
### 4. Mit dem Ergebnis des Funktionsaufrufs antworten und die endgültige Antwort abrufen
Im nächsten Schritt wird der Funktionsaufruf verarbeitet, die Funktion `get_weather` ausgeführt und das Ergebnis an das Modell zurückgesendet, damit es die endgültige Antwort an den Benutzer generieren kann.
```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)
```
**Ausgabe:**
```
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)
```
### Der vollständige Code
```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)
```