Moderne KI-Modelle entwickeln sich über die reine Textgenerierung hinaus. Mit Funktionen wie Function Calling und Structured Outputs können Entwickler nun intelligentere und zuverlässigere Anwendungen erstellen. Bei Novita AI können Sie jetzt schnell prüfen, ob ein Modell diese Fähigkeiten unterstützt – direkt in der Konsole –, was die Integration schneller und effizienter macht.
Was ist Function Calling?
Function Calling ist eine Fähigkeit in der KI, insbesondere bei großen Sprachmodellen (LLMs), die es dem Modell ermöglicht, mit externen Funktionen, Tools oder APIs zu interagieren, um bestimmte Aufgaben über die reine Textgenerierung hinaus auszuführen. Anstatt nur Text zu produzieren, erkennt das Modell, wann eine bestimmte Funktion basierend auf der Benutzeraufforderung aufgerufen werden sollte, bestimmt die korrekte Funktion und gibt die notwendigen Parameter für diese Funktion an. Die eigentliche Ausführung der Funktion wird von einem externen System oder einer Anwendung übernommen, nicht vom Modell selbst.
https://www.youtube.com/watch?v=aqdWSYWC\_LI
Wie Function Calling funktioniert
Function Calling ermöglicht es KI-Modellen, während eines Gesprächs mit externen Tools, APIs oder internen Funktionen zu interagieren. Anstatt einfach nur Text zu generieren, kann das Modell erkennen, wann eine Funktion benötigt wird, den korrekten Funktionsaufruf mit strukturierten Argumenten generieren und ausführen, um Ergebnisse abzurufen. Dies überbrückt die Lücke zwischen natürlichem Sprachverständnis und realen Aktionen und ermöglicht es Modellen, Aufgaben wie das Abrufen von Echtzeitdaten, das Verwalten von Workflows oder das automatische Auslösen von Systemaktionen durchzuführen.
Welche Vorteile bietet Function Calling?
- Reale Interaktion: Modelle können Aktionen auslösen, nicht nur Informationen bereitstellen.
- Automatisierung: Optimieren Sie Prozesse wie Datenabruf, Buchungen, Formularübermittlungen und mehr.
- Strukturiertes Verständnis: Anstatt sich nur auf Textgenerierung zu verlassen, organisiert das Modell die Ausgabe in vordefinierten Formaten und reduziert so Fehler.
- Erweiterte Anwendungsfälle: Erstellen Sie dynamische Apps, Assistenten und Systeme, die zuverlässiger und effizienter sind.
- Entwickler-Effizienz: Wenn Sie von vornherein wissen, dass ein Modell Function Calling unterstützt, können Sie Integrationen schneller planen, ohne umfangreiche Änderungen vornehmen zu müssen.
Was sind Structured Outputs?
Structured Outputs bezeichnen die Fähigkeit großer Sprachmodelle (LLMs), Antworten zu generieren, die einem vordefinierten, spezifischen Format entsprechen, anstatt freien Text zu produzieren. Diese Ausgaben liegen typischerweise in maschinenlesbaren Formaten wie JSON, XML, ausgefüllten Vorlagen oder tabellarischen Daten vor, was das Parsen, Validieren und Integrieren in Softwaresysteme oder Workflows erleichtert.
Wie Structured Outputs erzeugt werden
- Prompting-Techniken: Das Modell wird durch sorgfältig formulierte Aufforderungen geleitet, um die Ausgabe im gewünschten Format zu erzeugen.
- Function Calling APIs: Robuster können Structured Outputs mithilfe von Function-Calling-Schnittstellen erzeugt werden, bei denen das Modell Argumente zurückgibt, die strikt dem Schema einer Funktion entsprechen – oft erzwungen durch Parameter wie
strict: true. - Finite State Machine (FSM)-Steuerung: Intern kann die Generierung so eingeschränkt werden, dass jedes erzeugte Token den Regeln des Ausgabeformats folgt, was Strukturfehler reduziert.
Anwendungsfälle und Vorteile
- Extrahieren strukturierter Daten aus unstrukturiertem Text, z. B. Ereignisdetails, Benutzerinformationen oder Abfrageparameter.
- Auslösen externer APIs oder Funktionen mit präzisen, vom Modell generierten Parametern.
- Erstellen komplexer mehrstufiger Workflows, die auf konsistentem und validiertem Datenaustausch basieren.
- Verbesserung der Zuverlässigkeit in Anwendungen wie Chatbots, Datenextraktion und Automatisierungssystemen durch Reduzierung von Mehrdeutigkeiten in Modellausgaben.
Function Calling und Structured Outputs im Vergleich
| Aspekt | 🛠️ Function Calling | 🗂️ Structured Outputs |
|---|---|---|
| Zweck | Eine externe Funktion auslösen | Strukturierte Informationen zurückgeben |
| Ausrichtung | Handlungsorientiert | Informationsorientiert |
| Ausgabe | Funktionsname + Argumente | Vordefinierte strukturierte Daten (z. B. JSON) |
| Beispiel | Wetter-API aufrufen, um Vorhersage zu erhalten | Wetterbericht im JSON-Format zurückgeben |
| Einsatzszenario | Wenn das Modell eine Aktion ausführen soll | Wenn saubere, parsbare Daten ohne Aktion benötigt werden |
So prüfen Sie Function Calling und Structured Outputs auf Novita AI
1: Bei Novita AI anmelden
Sobald Sie auf der Novita AI-Startseite sind, klicken Sie einfach oben rechts auf „Log In“ oder „Get Started“. Sie können sich bequem mit Google, GitHub, Hugging Face oder einfach Ihrer E-Mail anmelden – ganz wie Sie möchten!
In der Konsole auf „Model API“ klicken!
Nach der Anmeldung gelangen Sie zum Dashboard der Novita-Konsole. Klicken Sie oben auf „Model API“. In diesem Abschnitt erhalten Sie Zugriff auf die vollständige Liste der verfügbaren Modelle sowie detaillierte Informationen zu ihren Fähigkeiten – einschließlich, ob sie Function Calling und Structured Outputs unterstützen.
Wählen Sie Ihr Modell und prüfen Sie es!
Suchen Sie einfach das gewünschte Modell, klicken Sie darauf, und rechts wird ein Panel eingeblendet. Unter „Supported Capabilities“ sehen Sie sofort, ob Function Calling und Structured Outputs unterstützt werden.
So verwenden Sie Function Calling auf Novita AI
1. Client initialisieren
Zunächst müssen Sie den Client mit Ihrem Novita-API-Schlüssel initialisieren.
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Holen Sie sich den Novita AI API Key von: https://novita.ai/settings/key-management.
api_key="<YOUR Novita AI API Key>",
)
model = "meta-llama/llama-4-maverick-17b-128e-instruct-fp8"
- Die aufzurufende Funktion definieren
Definieren Sie als Nächstes die Python-Funktion, die das Modell aufrufen kann. In diesem Beispiel ist es eine Funktion zum Abrufen von Wetterinformationen.
# Beispiel einer Funktion zum Simulieren des Abrufens von Wetterdaten.
def get_weather(location):
"""Ruft das aktuelle Wetter für einen bestimmten Ort ab."""
print("Rufe get_weather-Funktion auf mit Ort: ", location)
# In einer echten Anwendung würde man hier eine externe Wetter-API aufrufen.
# Dies ist ein vereinfachtes Beispiel mit fest codierten Daten.
return json.dumps({"location": location, "temperature": "60 Grad Fahrenheit"})
2. 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.
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Wetter eines Ortes abrufen, der Benutzer sollte zuerst einen Ort angeben",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "Die Stadt und der Bundesstaat, z.B. San Francisco, CA",
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "Wie ist das Wetter in San Francisco?"
}
]
# Senden wir die Anfrage und geben die Antwort aus.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Bitte prüfen Sie, ob die Antwort Tool-Aufrufe enthält, wenn in Produktion.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
3. Ausgabe
{'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 erhalten
Der nächste Schritt besteht darin, den Funktionsaufruf zu verarbeiten, die Funktion get_weather auszuführen und das Ergebnis zurück an das Modell zu senden, um die endgültige Antwort für den Benutzer zu generieren.
# Stellen Sie sicher, dass tool_call aus dem vorherigen Schritt definiert ist
if tool_call:
# Erweitern Sie den Gesprächsverlauf um die Tool-Call-Nachricht des Assistenten
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)
# Führen Sie die Funktion aus und holen Sie die Antwort
function_response = get_weather(
location=function_args.get("location"))
# Fügen Sie die Funktionsantwort zu den Nachrichten hinzu
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Holen Sie sich die endgültige Antwort vom Modell, jetzt mit dem Funktionsergebnis
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Hinweis: tools-Parameter hier nicht angeben.
)
print(answer_response.choices[0].message)
5. Ausgabe
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
So verwenden Sie Structured Outputs auf Novita AI
1. Client initialisieren
Zunächst müssen Sie den Client mit Ihrem Novita-API-Schlüssel initialisieren.
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Holen Sie sich den Novita AI API Key von: https://novita.ai/settings/key-management.
api_key="<YOUR Novita AI API Key>",
)
# Gehen Sie zur [Modelle](https://novita.ai/models)-Seite, um die Modelle zu sehen, die `Structured Outputs` unterstützen.
model = "mistralai/mistral-7b-instruct"
2. JSON-Schema definieren
Dieses Beispiel erstellt ein Schema zum Extrahieren von Ausgabeninformationen aus der Benutzereingabe.
# System-Prompt für Ausgabenverfolgung definieren.
system_prompt = """Sie sind ein Assistent zur Ausgabenverfolgung.
Extrahieren Sie Ausgabeninformationen aus der Eingabe des Benutzers und formatieren Sie sie gemäß dem bereitgestellten Schema."""
# JSON-Schema für strukturierte Antwort definieren.
response_format = {
"type": "json_schema",
"json_schema": {
"name": "expense_tracking_schema",
"schema": {
"type": "object",
"properties": {
"expenses": {
"type": "array",
"items": {
"type": "object",
"properties": {
"description": {
"type": "string",
"description": "Beschreibung der Ausgabe"
},
"amount": {
"type": "number",
"description": "Ausgegebener Betrag in Dollar"
},
"date": {
"type": "string",
"description": "Wann die Ausgabe angefallen ist"
},
"category": {
"type": "string",
"description": "Kategorie der Ausgabe (z.B. Essen, Büro, Reisen)"
}
},
"required": [
"description",
"amount"
]
}
},
"total": {
"type": "number",
"description": "Gesamtbetrag aller Ausgaben"
}
},
"required": [
"expenses",
"total"
],
},
},
}
3. Chat-Completion-API aufrufen
Erstellen Sie nun die Chat-Completion-Anfrage an den Novita-Endpunkt.
Diese Anfrage enthält den Parameter response_format, der das im vorherigen Schritt definierte JSON-Schema definiert.
chat_completion = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_prompt,
},
{
"role": "user",
"content": """Ich habe letzten Freitag 120 Dollar für ein Abendessen in einem italienischen Restaurant mit meinen Kollegen ausgegeben.
Außerdem habe ich am Montag Büromaterial für 45 Dollar gekauft.""",
},
],
max_tokens=1024,
temperature=0.8,
stream=False,
response_format=response_format,
)
response_content = chat_completion.choices[0].message.content
# JSON parsen und hübsch ausgeben
try:
json_response = json.loads(response_content)
prettified_json = json.dumps(json_response, indent=2)
print(prettified_json)
except json.JSONDecodeError:
print("Konnte Antwort nicht als JSON parsen. Rohe Antwort:")
print(response_content)
4. Ausgabe:
{
"expenses": [
{
"date": "2023-03-17",
"description": "Abendessen im italienischen Restaurant",
"amount": 120,
"category": "Essen & Trinken"
},
{
"date": "2023-03-13",
"description": "Büromaterial",
"amount": 45,
"category": "Bürobedarf"
}
],
"total": 165
}
Function Calling und Structured Outputs erweitern die Möglichkeiten von KI-Modellen erheblich. Egal, ob Sie Workflows automatisieren, Echtzeitdaten abrufen oder strukturierte Informationen extrahieren möchten – mit Novita AI finden Sie ganz einfach Modelle, die Ihren Anforderungen entsprechen. Beginnen Sie noch heute mit dem Bau intelligenterer Anwendungen, indem Sie die Modelle in der Novita-Konsole erkunden!
Häufig gestellte Fragen
Was ist Function Calling in KI-Modellen?
Es ermöglicht Modellen, externe Tools oder APIs auszulösen, indem strukturierte Funktionsaufrufe basierend auf Benutzereingaben generiert werden.
Was sind Structured Outputs?
Structured Outputs bezeichnen Modellantworten in strengen, maschinenlesbaren Formaten wie JSON, ideal für eine einfache Integration.
Worin unterscheiden sich Function Calling und Structured Outputs?
Function Calling ist handlungsorientiert (z. B. Wetter abrufen), während Structured Outputs sich auf die Rückgabe sauberer, formatierter Daten konzentrieren.
Novita AI ist die All-in-One-Cloud-Plattform, die Ihre KI-Ambitionen beflügelt. Integrierte APIs, serverlos, GPU-Instanz – die kosteneffizienten Tools, die Sie brauchen. Infrastruktur überflüssig, starten Sie kostenlos und machen Sie Ihre KI-Vision zur Realität.
