Comment Utiliser l'API Kimi K2.5

Les développeurs recherchent de plus en plus des API robustes capables de gérer des entrées multimodales complexes et de fournir des sorties intelligentes. L'API Kimi K2.5 se distingue comme un outil polyvalent de Moonshot AI, permettant aux applications de traiter du texte, des images et des vidéos avec des capacités de raisonnement avancées. Cette API vous permet de créer des solutions sophistiquées basées sur l'IA, allant du débogage visuel de code à l'orchestration d'essaims d'agents pour l'exécution de tâches en parallèle.

💡

Envie de suivre ? Téléchargez Apidog pour tester visuellement vos appels d'API Kimi K2.5. Apidog vous permet de configurer les requêtes, d'inspecter les réponses, de déboguer les problèmes d'authentification et de générer du code prêt pour la production, le tout sans écrire de code répétitif. C'est le moyen le plus rapide d'expérimenter les capacités de K2.5 avant de vous engager dans le code.

button

Qu'est-ce que Kimi K2.5 ?

Kimi K2.5 représente le modèle multimodal open-source le plus avancé de Moonshot AI, construit grâce à un pré-entraînement continu sur environ 15 billions de jetons visuels et textuels mixtes, au-dessus de l'architecture Kimi-K2-Base. Contrairement à son prédécesseur, K2.5 intègre de manière transparente la compréhension visuelle et linguistique avec des capacités agentiques avancées, ce qui le rend particulièrement puissant pour les développeurs qui créent des applications basées sur l'IA.

Le modèle introduit plusieurs fonctionnalités révolutionnaires qui le distinguent des autres API d'IA. Sa multimodalité native signifie qu'il a été pré-entraîné sur des jetons vision-langage dès le départ, plutôt que d'avoir des capacités de vision ajoutées après coup. Cette approche se traduit par des performances supérieures en matière de connaissance visuelle, de raisonnement intermodal et d'utilisation d'outils agentiques basés sur des entrées visuelles.

Pourquoi Kimi K2.5 est important pour les développeurs :

Disponibilité en open-source : Contrairement à de nombreux modèles de pointe, les poids de K2.5 sont disponibles publiquement sur Hugging Face
API compatible OpenAI : Remplacement direct nécessitant des modifications de code minimales
Rentable : Tarification compétitive à 0,60 $/M jetons d'entrée
Fenêtre contextuelle de 256K : Gère des documents et des conversations étendus
Capacité d'essaim d'agents : Décompose des tâches complexes en sous-tâches parallèles

Fonctionnalités et capacités clés

Intelligence multimodale native

K2.5 excelle dans la connaissance visuelle, le raisonnement intermodal et l'utilisation d'outils agentiques basés sur des entrées visuelles. Il ne s'agit pas seulement de reconnaissance d'images, mais d'une compréhension profonde du contexte visuel qui peut éclairer une prise de décision complexe.

Coder avec la vision

L'une des capacités remarquables de K2.5 est la génération de code à partir de spécifications visuelles. Pointez-le vers une maquette de conception d'interface utilisateur, et il peut produire du code frontal fonctionnel. Montrez-lui un flux de travail vidéo, et il peut orchestrer des outils pour le traitement des données visuelles. Cela le rend particulièrement précieux pour :

Convertir des designs Figma en composants React
Générer du HTML/CSS à partir de wireframes
Construire des pipelines de visualisation de données à partir d'exemples de graphiques
Automatiser les flux de travail de traitement d'images

Architecture d'essaim d'agents

K2.5 passe de la mise à l'échelle d'un agent unique à un schéma d'exécution coordonné et auto-dirigé, similaire à un essaim. Face à des tâches complexes, il peut :

Décomposer le problème en sous-tâches parallèles
Instancier dynamiquement des agents spécifiques à un domaine
Coordonner l'exécution entre plusieurs agents
Synthétiser les résultats en sorties cohérentes

Cette architecture permet à K2.5 de gérer des tâches qui submergeraient des systèmes à agent unique, telles que le refactoring de code complet, la génération de documentation multi-fichiers ou des pipelines d'analyse de données complexes.

Performances de référence

Démarrer avec l'API Kimi K2.5

Étape 1 : Créez votre compte Moonshot AI

Visitez platform.moonshot.ai et inscrivez-vous pour un compte. Le processus d'inscription est simple :

Cliquez sur "S'inscrire" ou "Enregistrer"
Fournissez votre e-mail et créez un mot de passe
Vérifiez votre adresse e-mail
Remplissez les informations de profil requises

Étape 2 : Générez votre clé API

Une fois connecté :

Naviguez vers la section Clés API dans votre tableau de bord
Cliquez sur "Créer une nouvelle clé API"
Donnez à votre clé un nom descriptif (par exemple, "kimi-k2-5-development")
Copiez et stockez en toute sécurité votre clé API, vous ne la reverrez plus

Conseil de sécurité : Ne jamais valider les clés API dans le contrôle de version. Utilisez des variables d'environnement ou un gestionnaire de secrets.

Étape 3 : Configurez votre environnement

Pour Python :

pip install --upgrade 'openai>=1.0'

Pour Node.js :

npm install openai@latest

Étape 4 : Configurez votre clé API

Définissez votre clé API comme variable d'environnement :

macOS/Linux :

export MOONSHOT_API_KEY="your-api-key-here"

Windows (PowerShell) :

[System.Environment]::SetEnvironmentVariable("MOONSHOT_API_KEY", "your-api-key-here", "User")

Windows (Invite de commandes) :

setx MOONSHOT_API_KEY "your-api-key-here"

Exemples de code Python

Achèvement de chat de base

Voici un exemple simple pour démarrer avec Kimi K2.5 :

import os
from openai import OpenAI

# Initialize the client with Moonshot AI endpoint
client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Create a chat completion
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are Kimi, an AI assistant developed by Moonshot AI. You are helpful, harmless, and honest."
        },
        {
            "role": "user",
            "content": "Explain the concept of mixture-of-experts architecture in neural networks."
        }
    ],
    temperature=0.6,
    max_tokens=2048,
)

print(response.choices[0].message.content)

Diffusion des réponses

Pour les applications en temps réel, utilisez la diffusion pour afficher les réponses au fur et à mesure qu'elles sont générées :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Stream the response
stream = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "Write a Python function to implement binary search."}
    ],
    stream=True,
    temperature=0.3,
)

# Process the stream
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Conversation multi-tours

Maintenez le contexte à travers plusieurs échanges :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

conversation_history = [
    {"role": "system", "content": "You are a helpful coding assistant."}
]

def chat(user_message):
    conversation_history.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=conversation_history,
        temperature=0.6,
    )

    assistant_message = response.choices[0].message.content
    conversation_history.append({"role": "assistant", "content": assistant_message})

    return assistant_message

# Example conversation
print(chat("How do I create a REST API in Python?"))
print(chat("Can you show me how to add authentication to that?"))
print(chat("What about rate limiting?"))

Implémentation asynchrone

Pour les applications hautes performances, utilisez async/await :

import os
import asyncio
from openai import AsyncOpenAI

async def main():
    client = AsyncOpenAI(
        api_key=os.environ.get("MOONSHOT_API_KEY"),
        base_url="https://api.moonshot.ai/v1",
    )

    # Run multiple requests concurrently
    tasks = [
        client.chat.completions.create(
            model="kimi-k2.5-preview",
            messages=[{"role": "user", "content": f"What is {topic}?"}],
        )
        for topic in ["REST API", "GraphQL", "gRPC"]
    ]

    responses = await asyncio.gather(*tasks)

    for response in responses:
        print(response.choices[0].message.content[:200])
        print("-" * 50)

asyncio.run(main())

Exemples JavaScript/Node.js

Achèvement de chat de base

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: 'https://api.moonshot.ai/v1',
});

async function chat(userMessage) {
  const response = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [
      {
        role: 'system',
        content: 'You are Kimi, a helpful AI assistant.',
      },
      {
        role: 'user',
        content: userMessage,
      },
    ],
    temperature: 0.6,
  });

  return response.choices[0].message.content;
}

// Usage
const answer = await chat('How do I implement a binary search tree in JavaScript?');
console.log(answer);

Diffusion avec Node.js

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: process.env.MOONSHOT_API_KEY,
  baseURL: 'https://api.moonshot.ai/v1',
});

async function streamChat(userMessage) {
  const stream = await client.chat.completions.create({
    model: 'kimi-k2.5-preview',
    messages: [{ role: 'user', content: userMessage }],
    stream: true,
  });

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content;
    if (content) {
      process.stdout.write(content);
    }
  }
}

await streamChat('Explain microservices architecture');

Utilisation de l'API Fetch (Fonctions de navigateur/Edge)

async function callKimiAPI(prompt) {
  const response = await fetch('https://api.moonshot.ai/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.MOONSHOT_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'kimi-k2.5-preview',
      messages: [{ role: 'user', content: prompt }],
      temperature: 0.6,
    }),
  });

  const data = await response.json();
  return data.choices[0].message.content;
}

// Usage
const result = await callKimiAPI('What are the best practices for API design?');
console.log(result);

Tester l'API Kimi K2.5 avec Apidog

Tester efficacement les API d'IA nécessite de comprendre les structures de requête/réponse, de gérer la diffusion en continu, de gérer l'authentification et de déboguer les problèmes. Apidog offre une solution complète pour le développement d'API qui facilite l'utilisation de Kimi K2.5.

Configuration de Kimi K2.5 dans Apidog

Étape 1 : Créez un nouveau projet

Ouvrez Apidog et créez un nouveau projet nommé "Intégration Kimi K2.5"
Cela organise tous vos points de terminaison liés à Kimi en un seul endroit

Étape 2 : Configurez les variables d'environnement

Naviguez vers les paramètres d'environnement
Ajoutez une nouvelle variable d'environnement :

Nom : MOONSHOT_API_KEY
Valeur : Votre clé API
Marquez comme "Sensible" pour masquer la valeur

Étape 3 : Créez le point de terminaison d'achèvement de chat

Ajoutez une nouvelle requête POST
URL : https://api.moonshot.ai/v1/chat/completions
En-têtes :

Authorization : Bearer {{MOONSHOT_API_KEY}}
Content-Type : application/json

Étape 4 : Configurez le corps de la requête

{
  "model": "kimi-k2.5-preview",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful AI assistant."
    },
    {
      "role": "user",
      "content": "Hello, how can you help me today?"
    }
  ],
  "temperature": 0.6,
  "max_tokens": 2048,
  "stream": false
}

Débogage avec Apidog

L'interface visuelle d'Apidog vous aide à :

Inspecter la structure de la réponse : Voir la réponse JSON complète avec la coloration syntaxique
Mesurer la latence : Suivre les temps de réponse pour l'optimisation des performances
Afficher les en-têtes : Déboguer les problèmes d'authentification et de limite de débit
Enregistrer les cas de test : Créer des collections de requêtes réutilisables pour les tests de régression
Générer du code : Exporter du code fonctionnel en Python, JavaScript, cURL, et plus encore

Création de tests automatisés

Avec l'exécuteur de tests d'Apidog, vous pouvez vérifier votre intégration Kimi K2.5 :

// Post-response test script in Apidog
pm.test("Response status is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Response contains choices", function () {
    const response = pm.response.json();
    pm.expect(response.choices).to.be.an('array');
    pm.expect(response.choices.length).to.be.greaterThan(0);
});

pm.test("Response content is not empty", function () {
    const response = pm.response.json();
    pm.expect(response.choices[0].message.content).to.not.be.empty;
});

Appel d'outils et capacités d'agent

L'une des fonctionnalités les plus puissantes de Kimi K2.5 est sa capacité à appeler des outils externes. Cela permet de construire des agents IA sophistiqués capables d'interagir avec des systèmes externes.

Définition des outils

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

# Define available tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and country, e.g., 'London, UK'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Temperature unit"
                    }
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_database",
            "description": "Search a database for information",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Search query"
                    },
                    "limit": {
                        "type": "integer",
                        "description": "Maximum number of results"
                    }
                },
                "required": ["query"]
            }
        }
    }
]

# Make a request with tools
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {"role": "user", "content": "What's the weather like in Tokyo?"}
    ],
    tools=tools,
    tool_choice="auto",
)

# Handle tool calls
if response.choices[0].message.tool_calls:
    for tool_call in response.choices[0].message.tool_calls:
        print(f"Tool: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

Exécution des appels d'outils

import json

def execute_tool_call(tool_call):
    """Execute a tool call and return the result."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "get_weather":
        # Simulate weather API call
        return json.dumps({
            "location": args["location"],
            "temperature": 22,
            "unit": args.get("unit", "celsius"),
            "condition": "sunny"
        })
    elif name == "search_database":
        # Simulate database search
        return json.dumps({
            "results": [
                {"id": 1, "title": "Result 1"},
                {"id": 2, "title": "Result 2"}
            ]
        })

    return json.dumps({"error": "Unknown tool"})

# Complete the conversation with tool results
messages = [
    {"role": "user", "content": "What's the weather in Tokyo?"}
]

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=messages,
    tools=tools,
)

if response.choices[0].message.tool_calls:
    # Add assistant message with tool calls
    messages.append(response.choices[0].message)

    # Execute each tool and add results
    for tool_call in response.choices[0].message.tool_calls:
        result = execute_tool_call(tool_call)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    # Get final response
    final_response = client.chat.completions.create(
        model="kimi-k2.5-preview",
        messages=messages,
        tools=tools,
    )

    print(final_response.choices[0].message.content)

Fonctionnalités de vision et multimodales

Les capacités multimodales natives de K2.5 permettent de traiter des images en même temps que du texte :

import os
import base64
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

def encode_image(image_path):
    """Encode image to base64."""
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

# Analyze an image
image_base64 = encode_image("screenshot.png")

response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Analyze this UI design and suggest improvements."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_base64}"
                    }
                }
            ]
        }
    ],
    max_tokens=2048,
)

print(response.choices[0].message.content)

Génération de code à partir d'une entrée visuelle

# Generate code from a wireframe
response = client.chat.completions.create(
    model="kimi-k2.5-preview",
    messages=[
        {
            "role": "system",
            "content": "You are an expert frontend developer. Generate clean, production-ready code."
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Convert this wireframe into a React component with Tailwind CSS styling."
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{encode_image('wireframe.png')}"
                    }
                }
            ]
        }
    ],
    temperature=0.3,
)

print(response.choices[0].message.content)

Tarification et limites de débit

Points clés :

Le niveau gratuit comprend 1,5 million de jetons par jour
Le niveau 1+ a des jetons quotidiens illimités
La mise en cache des jetons est automatique sans configuration nécessaire
La recherche Web coûte 0,005 $ supplémentaires par appel

Bonnes pratiques et astuces

Optimiser l'utilisation des jetons

# Use system prompts efficiently
system_prompt = """You are a concise technical assistant.
Rules: 1) Be brief 2) Use code blocks 3) Skip pleasantries"""

# Enable caching for repeated contexts
# Moonshot automatically caches similar prompts

Paramètres de température

0.0-0.3 : Génération de code, réponses factuelles
0.4-0.6 : Créativité et précision équilibrées
0.7-1.0 : Écriture créative, brainstorming

Gestion des erreurs

from openai import OpenAI, APIError, RateLimitError

client = OpenAI(
    api_key=os.environ.get("MOONSHOT_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

def safe_chat(message, retries=3):
    for attempt in range(retries):
        try:
            response = client.chat.completions.create(
                model="kimi-k2.5-preview",
                messages=[{"role": "user", "content": message}],
            )
            return response.choices[0].message.content
        except RateLimitError:
            if attempt < retries - 1:
                time.sleep(2 ** attempt)  # Exponential backoff
            else:
                raise
        except APIError as e:
            print(f"API Error: {e}")
            raise

result = safe_chat("Hello, Kimi!")

Dépannage des problèmes courants

Erreurs d'authentification

Problème : Erreur 401 Unauthorized

Solutions :

Vérifiez que votre clé API est correcte
Vérifiez que la clé n'a pas expiré
Assurez-vous que le format de l'en-tête Authorization est correct : Bearer VOTRE_CLÉ

Limitation de débit

Problème : 429 Trop de requêtes

Solutions :

Implémentez un backoff exponentiel
Mettez à niveau votre niveau en ajoutant des fonds
Surveillez les en-têtes X-RateLimit-Remaining

Limite de longueur du contexte dépassée

Problème : La requête dépasse la limite de 256K jetons

Solutions :

Résumez les longues conversations
Utilisez une approche de fenêtre glissante
Divisez en plusieurs requêtes

Problèmes de délai d'attente

Problème : Les requêtes expirent

Solutions :

Utilisez la diffusion en continu pour les réponses longues
Augmentez les paramètres de délai d'attente du client
Divisez les invites complexes en tâches plus petites

Prêt à construire avec Kimi K2.5 ? Téléchargez Apidog pour rationaliser votre flux de travail de développement d'API avec des tests visuels, une documentation automatique et des fonctionnalités de collaboration d'équipe qui rendent l'intégration des API d'IA plus rapide et plus fiable.

button