Kimi K2 repräsentiert eine neue Ära der KI-Agenten und vereint modernste Leistung in spezialisierten Bereichen mit Erschwinglichkeit und Open-Source-Flexibilität. Mit 32 Milliarden aktivierten Parametern und insgesamt 1 Billion Parametern zeichnet sich Kimi K2 durch seine spezialisierten Stärken in MINT, Programmierung und Tool-Nutzung aus.
Dieser Artikel untersucht, wie Function Calling die agentischen Fähigkeiten von Kimi K2 verbessert, was diese Funktion beinhaltet und wie sie Kimi K2 als führend in der Zukunft der KI-Agenten positioniert.
Kimi K2’s Code-Agent-Fähigkeiten
-
Kompetenz in MINT und Programmierung
- Kimi K2 erzielt Spitzenleistungen (State-of-the-Art, SOTA) in MINT- und Programmier-Benchmarks, darunter LiveCodeBench und OJBench.
- Es kann komplexen Code generieren, Fehler debuggen und anspruchsvolle Algorithmen präzise simulieren.
-
Expertise in der Tool-Nutzung
- Kimi K2 wurde auf mehrstufige Tool-Nutzungsszenarien in Hunderten von Bereichen trainiert.
- Die Fähigkeit zu erkennen, wann ein Tool benötigt wird, und mehrstufige Arbeitsabläufe auszuführen, macht es zu einem äußerst praktischen Programmierassistenten.
-
Verstärkungslernen für Aufgabenausführung
- Durch den Einsatz von rubrikbasierten Selbstbewertungen und On-Policy-Lernen verbessert Kimi K2 kontinuierlich seine Urteils- und Entscheidungsfähigkeit.
Von Kimi
Kimi K2’s Agent-Fähigkeiten hängen von Function Calling ab
Obwohl die inhärenten Stärken von Kimi K2 in der Programmierung und Tool-Nutzung beeindruckend sind, sind seine agentischen Fähigkeiten stark auf Function Calling angewiesen. Ohne diese Funktion wäre seine Fähigkeit, mit externen Tools und Systemen zu interagieren, stark eingeschränkt.
Was ist Function Calling?
Function Calling ist ein strukturierter Mechanismus, der es großen Sprachmodellen (LLMs) ermöglicht, mit externen Systemen, Tools oder APIs zu interagieren. Anstatt nur Text zu generieren, kann ein LLM mit Function-Calling-Unterstützung Benutzereingaben analysieren, erkennen, wann eine externe Aktion erforderlich ist, und strukturierte JSON-Aufrufe generieren, um bestimmte Funktionen auszuführen.
https://www.youtube.com/watch?v=KUEmEb71vzQ
Wie Function Calling funktioniert
- Analyse der Eingabe: Das LLM interpretiert die Anfrage des Benutzers und bestimmt, ob ein Funktionsaufruf erforderlich ist.
- Generierung von JSON-Aufrufen: Es erzeugt ein strukturiertes JSON-Objekt mit dem Funktionsnamen und den erforderlichen Parametern.
- Ausführung durch externe Systeme: Ein externes System empfängt den JSON-Aufruf, führt die Funktion aus und gibt die Ergebnisse zurück.
- Generierung der Antwort: Das LLM verwendet die zurückgegebenen Daten, um eine endgültige Antwort an den Benutzer zu liefern.
Dieser Zyklus kann sich bei mehrstufigen oder komplexen Aufgaben wiederholen und ermöglicht es dem Modell, als dynamischer und interaktiver Agent zu agieren.
Warum Function Calling unerlässlich ist
- Verwandelt Wissen in Handeln: Function Calling ermöglicht es Kimi K2, sich von einem „Wissensanbieter“ zu einem „Aufgabenausführer“ zu entwickeln.
- Interaktionen mit der realen Welt: Es befähigt Kimi K2, mit APIs, Datenbanken und externen Systemen zu interagieren und Aufgaben wie Terminplanung, Datenabruf und IoT-Steuerung effektiv zu automatisieren.
- Mehrstufige Arbeitsabläufe: Kimi K2 kann mehrere Funktionsaufrufe verketten, um komplexe Arbeitsabläufe auszuführen, wie z.B. Daten abrufen, verarbeiten und Ergebnisse speichern.
Function Calling vs. SDK
| Feature | Function Calling | SDK |
|---|---|---|
| Definition | Ein strukturierter Mechanismus für LLMs, um externe Funktionen oder APIs auszulösen. | Ein Toolkit, das die Interaktion mit APIs und externen Systemen vereinfacht. |
| Zweck | Ermöglicht die direkte Ausführung von Aufgaben durch die Generierung von Funktionsaufrufen (z. B. JSON). | Bietet vorgefertigte Tools und Bibliotheken für eine einfachere API-Integration. |
| Flexibilität | Hochdynamisch, sodass Modelle mit jeder definierten Funktion interagieren können. | Begrenzt auf die vom SDK unterstützten Features und Endpunkte. |
| Implementierung | Erfordert das manuelle Definieren von Funktionen, Schemata und die Verarbeitung von Antworten. | Abstrahiert die API-Logik und bietet ein Plug-and-Play-Erlebnis. |
| Anwendungsfall | Ideal für die Automatisierung mehrstufiger Aufgaben und Echtzeit-Entscheidungsfindung. | Am besten geeignet für schnelle Entwicklung mit vordefinierten Arbeitsabläufen. |
| Entwickleraufwand | Erfordert mehr Einrichtung, um Funktionsaufrufe zu definieren und zu verwalten. | Minimaler Aufwand; vereinfacht die API-Nutzung mit vorgefertigten Methoden. |
Was kann Kimi K2 + Function Calling erreichen?
Die Kombination der Stärken von Kimi K2 und den Function-Calling-Fähigkeiten eröffnet eine breite Palette realer Anwendungen:
1. Ausführung realer Aufgaben
- Automatisierung: Automatisieren Sie wiederkehrende Aufgaben wie Terminbuchungen, das Absenden von Formularen oder das Erstellen von Berichten.
- IoT-Steuerung: Interagieren Sie mit IoT-Geräten, um Aktionen wie das Einstellen der Raumtemperatur oder das Umschalten von Lichtern durchzuführen.
2. Zugriff auf Echtzeitdaten
- Dynamische Aktualisierungen: Rufen Sie Echtzeitdaten (z. B. Wetter, Aktienkurse) über API-Aufrufe ab.
- Verbesserte Antworten: Integrieren Sie Echtzeitinformationen in Antworten, um Genauigkeit und Relevanz zu verbessern.
3. Fortgeschrittene multimodale Anwendungen
- Bild- und Videoverarbeitung: Lösen Sie externe Tools für Aufgaben wie Bildbearbeitung oder Videobearbeitung aus.
- Formatübergreifende Integration: Verarbeiten Sie Eingaben aus Text, Bildern und Audio, um komplexe Aufgaben auszuführen.
4. Komplexe Arbeitsabläufe und Pipelines
- Verketten Sie mehrere Funktionsaufrufe, um Datenpipelines auszuführen, wie z. B.:
- Daten abrufen → Analysieren → Ergebnisse speichern.
- Ermöglichen Sie eine nahtlose Integration mit Datenbanken und Analysetools für fortgeschrittene Arbeitsabläufe.
5. Entwicklerfreundliche Lösungen
- Benutzerdefinierte APIs: Entwickler können Kimi K2 für die Interaktion mit proprietären APIs und Tools optimieren.
- Skalierbare Integrationen: Fügen Sie einfach neue Funktionen hinzu, um die Fähigkeiten ohne größere Infrastrukturänderungen zu erweitern.
Eine Demo, die Kimi K2 mit Function Calling zeigt
Mein Gesamtbudget beträgt 10.000 $, das alle Ausgaben inklusive Transport, Unterkunft und Tickets abdecken sollte. Bitte erstellen Sie eine detaillierte Budgetaufteilung für die gesamte Reise. Meine wichtigsten Bewertungskriterien sind: Bequemlichkeit des Transports, Verfügbarkeit von Tickets und die Qualität der lokalen Sehenswürdigkeiten.
Bitte beziehen Sie sich auf mein oben genanntes Gesamtbudget.
Zusätzlich zu meinem oben genannten Gesamtbudget suche ich eine Unterkunft, die ein authentisches lokales Erlebnis bietet, weshalb ich Airbnb bevorzuge.
Überprüfen Sie meine Google Mail und erstellen Sie Einträge in meinem Google Kalender.
Novita Kimi K2 API unterstützt Function Calling
Diese Anleitung zeigt, wie Sie mit Function Calling aktuelle Wetterinformationen für den vom Benutzer angegebenen Standort abrufen. Wir gehen ein vollständiges Python-Codebeispiel durch.
Das spezifische API-Format für Function Calling finden Sie in der Dokumentation!
- Client initialisieren
Zuerst 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 = "moonshotai/kimi-k2-instruct"
- Definieren der aufzurufenden Funktion
Als Nächstes definieren Sie die Python-Funktion, die das Modell aufrufen kann. In diesem Beispiel ist es eine Funktion zum Abrufen von Wetterinformationen.
# Beispiel-Funktion zum Simulieren des Abrufs von Wetterdaten.
def get_weather(location):
"""Ruft das aktuelle Wetter für einen bestimmten Standort ab."""
print("Rufe get_weather-Funktion auf mit Standort: ", location)
# In einer echten Anwendung würden Sie hier eine externe Wetter-API aufrufen.
# Dies ist ein vereinfachtes Beispiel mit fest codierten Daten.
return json.dumps({"location": location, "temperature": "60 Grad Fahrenheit"})
- 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 Standorts abrufen. Der Benutzer sollte zuerst einen Standort 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 in der Produktion, ob die Antwort tool_calls enthält.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
- Ausgabe
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
- 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 an das Modell zurückzusenden, um die endgültige Antwort für den Benutzer zu generieren.
# Stellen Sie sicher, dass tool_call aus dem vorherigen Schritt definiert wurde.
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 erhalten 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: Fügen Sie hier keinen tools-Parameter hinzu.
)
print(answer_response.choices[0].message)
- Ausgabe
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
Novita AI bietet jetzt Kompatibilität mit dem Anthropic SDK
Die Kombination von Kimi K2 und Claude Code ist schnell zu einem heißen Thema in der KI-Community geworden und bietet beispiellose Agent-Fähigkeiten für reale Anwendungen. Um diese Integration noch nahtloser zu gestalten, bietet Novita AI jetzt Kompatibilität mit dem Anthropic SDK, sodass Sie die Leistungsfähigkeit von Kimi K2 mühelos über die vertraute Claude Code-Schnittstelle nutzen können.
Weitere Informationen finden Sie in dieser Dokumentation!
1. Installieren Sie das Anthropic SDK
pip install anthropic
2. Initialisieren Sie den Client
Die Anthropic SDKs sind darauf ausgelegt, den API-Schlüssel und die Basis-URL aus den Umgebungsvariablen ANTHROPIC_API_KEY und ANTHROPIC_BASE_URL zu beziehen. Sie können die Parameter auch bei der Initialisierung des Anthropic-Clients übergeben.
Sie können Ihre API-Schlüssel auf der Einstellungsseite einsehen und verwalten.
- Verwenden von Umgebungsvariablen
export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<YOUR_NOVITA_API_KEY>"
- Parameter bei der Initialisierung des Anthropic-Clients setzen
import anthropic
client = anthropic.Anthropic(
base_url="https://api.novita.ai/anthropic",
api_key="<YOUR_NOVITA_API_KEY>"
)
3. Rufen Sie die API auf
import anthropic
# Initialisieren Sie den Client. Wenn Sie bereits `ANTHROPIC_BASE_URL` und `ANTHROPIC_API_KEY`
# in den Umgebungsvariablen gesetzt haben, können Sie die Parameter `api_key` und `base_url` weglassen.
client = anthropic.Anthropic(
base_url="https://api.novita.ai/anthropic",
api_key="<YOUR_NOVITA_API_KEY>"
)
message = client.messages.create(
model="moonshotai/kimi-k2-instruct",
max_tokens=1000,
temperature=1,
system="Sie sind ein Weltklasse-Dichter. Antworten Sie nur mit kurzen Gedichten.",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Warum ist das Meer salzig?"
}
]
}
]
)
print(message.content)
Kimi K2’s Unterstützung für Function Calling hebt es von einem leistungsstarken LLM zu einem KI-Agenten der nächsten Generation, der in der Lage ist, mit der realen Welt zu interagieren und Aufgaben auszuführen. In Kombination mit seiner Dominanz in MINT und Programmierung positioniert diese Funktion Kimi K2 als kosteneffiziente, spezialisierte Lösung für die Entwicklung praktischer und dynamischer KI-Systeme.
Durch die Überbrückung der Kluft zwischen Wissen und Handeln verbessert Kimi K2 nicht nur die Benutzererfahrung, sondern demokratisiert auch den Zugang zu fortschrittlichen KI-Fähigkeiten. Sein Open-Source-Charakter und seine Erschwinglichkeit machen es zu einer disruptiven Kraft in der KI-Landschaft und ebnen den Weg für weitreichende Innovation und Adoption.
Häufig gestellte Fragen
Was ist Function Calling im Kontext von LLMs?
Function Calling ist eine Technik, die es großen Sprachmodellen ermöglicht, zu erkennen, wann eine bestimmte Aufgabe eine externe Funktion oder ein Tool erfordert, und strukturierte Daten zur Ausführung dieser Funktion zu generieren.
Was sind die Hauptvorteile der Verwendung von Function Calling?
Zu den wichtigsten Vorteilen gehören eine höhere Effizienz bei der Verarbeitung von Aufgaben, eine größere Flexibilität für Entwickler, um Funktionen einfach zu aktualisieren, Skalierbarkeit für das Hinzufügen neuer Funktionen ohne umfangreiche Änderungen und personalisierte Benutzerinteraktionen.
Kann Kimi K2 proprietäre Modelle wie GPT-4 oder Claude ersetzen?
Kimi K2 zielt nicht darauf ab, Allzweckmodelle zu ersetzen. Stattdessen konzentriert es sich darauf, ein Spezialist-Agent mit Stärken in MINT, Programmierung und Tool-Nutzung zu sein, ergänzt durch seine Function-Calling-Fähigkeiten.
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. Verzichten Sie auf Infrastruktur, starten Sie kostenlos und machen Sie Ihre KI-Vision zur Realität.
