Novita Kimi K2 API prend désormais en charge l’appel de fonctions !

Kimi K2 représente une nouvelle ère d’agents IA, alliant des performances de pointe dans des domaines spécialisés avec accessibilité et flexibilité open source. Avec ses 32 milliards de paramètres activés et 1 billion de paramètres totaux, Kimi K2 se distingue par ses forces spécialisées dans les STEM, le codage et l’utilisation d’outils.

Cet article explore comment l’appel de fonctions améliore les capacités agentiques de Kimi K2, ce qu’implique cette fonctionnalité et comment elle positionne Kimi K2 comme un leader dans l’avenir des agents IA.

Capacités d’agent de code de Kimi K2

1. Compétence en STEM et codage

   • Kimi K2 atteint des performances de pointe (SOTA) sur les benchmarks STEM et de codage, notamment LiveCodeBench et OJBench.
   • Il peut générer du code complexe, déboguer des problèmes et simuler des algorithmes complexes avec précision.

2. Expertise dans l’utilisation d’outils

   • Kimi K2 a été entraîné sur des scénarios d’utilisation d’outils multi‑tour dans des centaines de domaines.
   • Sa capacité à identifier quand un outil est nécessaire et à exécuter des workflows multi‑étapes en fait un assistant de codage très pratique.

3. Apprentissage par renforcement pour l’exécution de tâches

   • En exploitant l’auto‑évaluation basée sur des rubriques et l’apprentissage en ligne, Kimi K2 améliore continuellement son jugement et sa prise de décision.

De Kimi

Les capacités agentiques de Kimi K2 dépendent de l’appel de fonctions

Bien que les forces inhérentes de Kimi K2 en codage et utilisation d’outils soient impressionnantes, ses capacités agentiques reposent fortement sur l’appel de fonctions. Sans cette fonctionnalité, sa capacité à interagir avec des outils et systèmes externes serait sévèrement limitée.

Qu’est-ce que l’appel de fonctions ?

L’appel de fonctions est un mécanisme structuré qui permet aux grands modèles de langage (LLM) d’interagir avec des systèmes, outils ou API externes. Au lieu de simplement générer du texte, un LLM avec support d’appel de fonctions peut analyser les demandes des utilisateurs, identifier quand une action externe est nécessaire et générer des appels JSON structurés pour exécuter des fonctions spécifiques.

https://www.youtube.com/watch?v=KUEmEb71vzQ

Comment fonctionne l’appel de fonctions

1. Analyse de la demande : Le LLM interprète la requête de l’utilisateur et détermine si un appel de fonction est nécessaire.
2. Génération d’un appel JSON : Il génère un objet JSON structuré contenant le nom de la fonction et les paramètres nécessaires.
3. Exécution par des systèmes externes : Un système externe reçoit l’appel JSON, exécute la fonction et renvoie les résultats.
4. Génération de la réponse : Le LLM utilise les données renvoyées pour fournir une réponse finale à l’utilisateur.

Ce cycle peut se répéter pour des tâches multi‑étapes ou complexes, permettant au modèle d’agir comme un agent dynamique et interactif.

Pourquoi l’appel de fonctions est essentiel

• Transforme la connaissance en action : L’appel de fonctions permet à Kimi K2 de passer d’un « fournisseur de connaissances » à un « exécuteur de tâches ».
• Interactions réelles : Il permet à Kimi K2 d’interagir avec des API, bases de données et systèmes externes, automatisant efficacement des tâches comme la planification, la récupération de données et le contrôle IoT.
• Workflows multi‑étapes : Kimi K2 peut enchaîner plusieurs appels de fonctions pour exécuter des workflows complexes, comme récupérer des données, les traiter et stocker les résultats.

Appel de fonctions vs SDK

Caractéristique	Appel de fonctions	SDK
Définition	Un mécanisme structuré permettant aux LLM de déclencher des fonctions ou API externes.	Un ensemble d’outils qui simplifie l’interaction avec les API et systèmes externes.
Objectif	Permet l’exécution directe de tâches en générant des appels de fonction (ex. JSON).	Fournit des outils et bibliothèques préconstruits pour une intégration API plus facile.
Flexibilité	Hautement dynamique, permettant aux modèles d’interagir avec n’importe quelle fonction définie.	Limité aux fonctionnalités et points de terminaison supportés par le SDK.
Implémentation	Nécessite de définir manuellement les fonctions, schémas et de gérer les réponses.	Abstrait la logique API, offrant une expérience plug‑and‑play.
Cas d’usage	Idéal pour l’automatisation de tâches multi‑étapes et la prise de décision en temps réel.	Meilleur pour le développement rapide avec des workflows prédéfinis.
Effort développeur	Nécessite plus de configuration pour définir et gérer les appels de fonction.	Effort minimal ; simplifie l’utilisation de l’API avec des méthodes préconstruites.

Que peut accomplir Kimi K2 avec l’appel de fonctions ?

La combinaison des forces de Kimi K2 et des capacités d’appel de fonctions ouvre un large éventail d’applications réelles :

1. Exécution de tâches réelles

• Automatisation : Automatisez des tâches répétitives telles que la réservation de rendez‑vous, la soumission de formulaires ou la génération de rapports.
• Contrôle IoT : Interagissez avec des appareils IoT pour effectuer des actions comme ajuster la température ambiante ou allumer/éteindre les lumières.

2. Accès aux données en temps réel

• Mises à jour dynamiques : Récupérez des données en temps réel (ex. météo, cours de la bourse) via des appels API.
• Réponses enrichies : Intégrez des informations en temps réel dans les réponses, améliorant ainsi leur précision et pertinence.

3. Applications multimodales avancées

• Traitement d’images et de vidéos : Déclenchez des outils externes pour des tâches comme l’édition d’images ou le montage vidéo.
• Intégration multi‑format : Traitez des entrées provenant de texte, d’images et d’audio pour effectuer des tâches complexes.

4. Workflows et pipelines complexes

• Enchaînez plusieurs appels de fonctions pour exécuter des pipelines de données, comme :
  • Récupération de données → Analyse → Stockage des résultats.
• Permettez une intégration transparente avec des bases de données et des outils d’analyse pour des workflows avancés.

5. Solutions conviviales pour les développeurs

• API personnalisées : Les développeurs peuvent affiner Kimi K2 pour interagir avec des API et outils propriétaires.
• Intégrations évolutives : Ajoutez facilement de nouvelles fonctions pour étendre les capacités sans modifications majeures de l’infrastructure.

Une démo montrant Kimi K2 avec l’appel de fonctions

1. Mon budget total est de 10 000 $, qui doit couvrir toutes les dépenses, y compris le transport, l’hébergement et les billets. Veuillez fournir une répartition budgétaire détaillée pour l’ensemble du voyage. Mes principaux critères d’évaluation sont : la commodité du transport, la disponibilité des billets et la qualité des attractions locales.

2. Veuillez vous référer à mon budget total mentionné ci‑dessus.

3. En plus de mon budget total spécifié ci‑dessus, je recherche un hébergement offrant une expérience locale authentique, c’est pourquoi j’ai une préférence pour Airbnb.

4. Vérifiez ma messagerie Google et créez des entrées dans mon Google Calendar.

Novita Kimi K2 API prend en charge l’appel de fonctions

Ce guide montre comment utiliser l’appel de fonctions pour récupérer les informations météorologiques actuelles pour un lieu spécifié par l’utilisateur. Nous allons parcourir un exemple de code Python complet.

Pour le format spécifique de l’API d’appel de fonctions, veuillez consulter la documentation !

Essayez Kimi K2 maintenant !

• Initialiser le client

Tout d’abord, vous devez initialiser le client avec votre clé API Novita.

from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    # Obtenez la clé API Novita AI depuis : https://novita.ai/settings/key-management.
    api_key="<YOUR Novita AI API Key>",
)

model = "moonshotai/kimi-k2-instruct"

• 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 pour obtenir des informations météorologiques.

# Exemple de fonction pour simuler la récupération de données météo.
def get_weather(location):
    """Récupère la météo actuelle pour un lieu donné."""
    print("Appel de la fonction get_weather avec le lieu : ", location)
    # Dans une application réelle, vous feriez appel à une API météo externe ici.
    # Ceci est un exemple simplifié renvoyant des données codées en dur.
    return json.dumps({"location": location, "temperature": "60 degrés Fahrenheit"})

• Construire la requête API avec les outils et le message utilisateur

Maintenant, créez la requête API vers le point de terminaison Novita. Cette requête inclut le paramètre tools, définissant les fonctions que le modèle peut utiliser, et le message de l’utilisateur.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtenir la météo d'un lieu. L'utilisateur doit d'abord fournir un lieu.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "La ville et l'état, ex. San Francisco, CA",
                    }
                },
                "required": ["location"]
            },
        }
    },
]

messages = [
    {
        "role": "user",
        "content": "Quel temps fait-il à San Francisco ?"
    }
]

# Envoyons la requête et affichons la réponse.
response = client.chat.completions.create(
    model=model,
    messages=messages,
    tools=tools,
)

# Vérifiez si la réponse contient des appels d'outils si en production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())

• Sortie

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

• 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 et renvoyer le résultat au modèle pour générer la réponse finale à l’utilisateur.

# Assurez-vous que tool_call est défini à partir de l'étape précédente
if tool_call:
    # Étendre l'historique de conversation avec le message d'appel d'outil de l'assistant
    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)
        # Exécuter la fonction et obtenir la réponse
        function_response = get_weather(
            location=function_args.get("location"))
        # Ajouter la réponse de fonction aux messages
        messages.append(
            {
                "tool_call_id": tool_call.id,
                "role": "tool",
                "content": function_response,
            }
        )

    # Obtenir la réponse finale du modèle, maintenant avec le résultat de la fonction
    answer_response = client.chat.completions.create(
        model=model,
        messages=messages,
        # Note : Ne pas inclure le paramètre tools ici.
    )
    print(answer_response.choices[0].message)

• Sortie

{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}

Novita AI offre désormais une compatibilité avec le SDK Anthropic

La combinaison de Kimi K2 et de Claude Code est rapidement devenue un sujet brûlant dans la communauté IA, offrant des capacités agentiques inégalées pour des applications réelles. Pour rendre cette intégration encore plus fluide, Novita AI propose désormais une compatibilité avec le SDK Anthropic, vous permettant d’exploiter sans effort la puissance de Kimi K2 via l’interface familière de Claude Code.

Vous pouvez consulter cette documentation pour plus de détails !

1. Installer le SDK Anthropic

pip install anthropic

2. Initialiser le client

Les SDK Anthropic sont conçus pour récupérer la clé API et l’URL de base depuis les variables d’environnement : ANTHROPIC_API_KEY et ANTHROPIC_BASE_URL. Vous pouvez également fournir les paramètres au client Anthropic lors de son initialisation.

Vous pouvez voir et gérer vos clés API sur la page des paramètres.

• Utilisation des variables d’environnement

export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<VOTRE_CLÉ_API_NOVITA>"

• Définir les paramètres lors de l’initialisation du client Anthropic

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<VOTRE_CLÉ_API_NOVITA>"
)

3. Appeler l’API

import anthropic

# Initialiser le client. Si vous avez déjà défini `ANTHROPIC_BASE_URL` et `ANTHROPIC_API_KEY`
# dans les variables d’environnement, vous pouvez omettre les paramètres `api_key` et `base_url`.
client = anthropic.Anthropic(
    base_url="https://api.novita.ai/anthropic",
    api_key="<VOTRE_CLÉ_API_NOVITA>"
)

message = client.messages.create(
    model="moonshotai/kimi-k2-instruct",
    max_tokens=1000,
    temperature=1,
    system="Vous êtes un poète de classe mondiale. Répondez uniquement avec des poèmes courts.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Pourquoi l’océan est-il salé ?"
                }
            ]
        }
    ]
)

print(message.content)

Le support de l’appel de fonctions par Kimi K2 l’élève d’un LLM performant à un agent IA de nouvelle génération capable d’interactions réelles et d’exécution de tâches. Associé à sa domination dans les STEM et le codage, cette fonctionnalité positionne Kimi K2 comme une solution spécialisée, économique et pratique pour développer des systèmes IA dynamiques et utiles.

En comblant le fossé entre connaissance et action, Kimi K2 améliore non seulement l’expérience utilisateur mais démocratise également l’accès à des capacités IA avancées. Sa nature open source et son accessibilité en font une force de disruption dans le paysage de l’IA, ouvrant la voie à une large innovation et adoption.

Foire aux questions

Qu’est-ce que l’appel de fonctions dans le contexte des LLM ?

L’appel de fonctions est une technique qui permet aux grands modèles de langage de reconnaître quand une tâche spécifique nécessite une fonction ou un outil externe, et de générer des données structurées pour exécuter cette fonction.

Quels sont les principaux avantages de l’utilisation de l’appel de fonctions ?

Les principaux avantages incluent une efficacité accrue dans le traitement des tâches, une flexibilité renforcée pour les développeurs afin de mettre à jour facilement les fonctions, une évolutivité pour ajouter de nouvelles fonctionnalités sans modifications majeures, et des interactions utilisateur personnalisées.

Kimi K2 peut-il remplacer des modèles propriétaires comme GPT-4 ou Claude ?

Kimi K2 ne vise pas à remplacer les modèles généralistes. Il se concentre plutôt à être un agent spécialiste avec des forces dans les STEM, le codage et l’utilisation d’outils, complétées par ses capacités d’appel de fonctions.

Novita AI est la plateforme cloud tout-en-un qui propulse vos ambitions IA. API intégrées, serverless, instances GPU — les outils économiques dont vous avez besoin. Éliminez l’infrastructure, commencez gratuitement et faites de votre vision IA une réalité.

Lecture recommandée

• Un guide pour accéder à DeepSeek V3 : localement et via API
• DeepSeek V3 vs R1 : entraînement par étapes vs cycles SFT-RL itératifs
• Exécuter DeepSeek V3 localement : un guide pour développeurs