Guide de l'API Kimi K2 Thinking : Construire des agents multi-étapes sans perdre l'état de raisonnement

En résumé

• Utilisez kimi-k2-thinking quand vous voulez un modèle dédié à la réflexion permanente pour les agents multi-étapes.
• Utilisez kimi-k2.5 quand vous voulez une valeur par défaut plus flexible pouvant activer ou désactiver la réflexion.
• Conservez reasoning_content dans le contexte, définissez max_tokens à au moins 16000, maintenez temperature à 1.0, et préférez le streaming.
• La documentation vérifiée de Moonshot prend clairement en charge les appels d'outils multi-étapes, mais elle ne publie pas de quota public stable de "300 étapes" sur les pages utilisées pour cette réécriture — votre application doit donc imposer ses propres limites de boucle.

Ce que confirment réellement les docs actuelles de Moonshot

Par quel modèle Kimi commencer ?

Le détail d'implémentation que la plupart des guides manquent

C'est important parce qu'un agent multi-étapes n'est pas une seule requête. C'est une boucle :

1. Le modèle raisonne.
2. Le modèle appelle un outil.
3. Votre application exécute l'outil.
4. Le modèle raisonne à nouveau en utilisant le résultat précédent de l'outil.

Boucle d'agent multi-étapes minimale

Cet exemple est intentionnellement petit. L'objectif est de montrer le flux de contrôle qui compte pour les modèles de réflexion de Kimi.

import json
import os
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_docs",
            "description": "Search internal product documentation",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    }
]

messages = [
    {"role": "system", "content": "You are a careful research agent."},
    {"role": "user", "content": "Find the API limits for our billing service and summarize the risks."},
]

for _ in range(8):
    completion = client.chat.completions.create(
        model="kimi-k2-thinking",
        messages=messages,
        tools=tools,
        tool_choice="auto",
        temperature=1.0,
        max_tokens=16000,
    )

    message = completion.choices[0].message

    # Preserve the assistant turn exactly, including reasoning_content when present.
    messages.append(message.model_dump(exclude_none=True))

    if not message.tool_calls:
        print(message.content)
        break

    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)

        if tool_call.function.name == "search_docs":
            result = {"matches": ["rate_limit=500 rpm", "burst_limit=1000 rpm"]}
        else:
            result = {"error": "unknown tool"}

        messages.append(
            {
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": tool_call.function.name,
                "content": json.dumps(result),
            }
        )

Quatre règles qui comptent plus que le marketing des modèles

Deux autres remarques de production valent la peine d'être ajoutées :

• Traitez la longueur de la boucle comme votre politique. La documentation vérifiée indique que Kimi supporte un raisonnement approfondi sur plusieurs appels d'outils, mais elle n'expose pas de quota d'étapes public universel stable qui devrait être codé en dur dans un article de blog.
• Validez les arguments des outils avant d'exécuter des effets secondaires. C'est un guide d'implémentation, pas une garantie de Moonshot, mais c'est la différence entre un agent utile et une boucle de tentatives coûteuse.

Utiliser Kimi K2 Thinking via EvoLink

La façon la plus simple d'accéder à Kimi K2 Thinking sans configurer directement les identifiants Moonshot est de passer par la passerelle compatible OpenAI d'EvoLink.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.evolink.ai/v1",
    api_key="YOUR_EVOLINK_API_KEY",
)

completion = client.chat.completions.create(
    model="kimi-k2-thinking",
    messages=[{"role": "user", "content": "Analyze the tradeoffs of event sourcing vs CRUD."}],
    temperature=1.0,
    max_tokens=16000,
)

Alternative : intégration OpenClaw

Si votre environnement d'exécution est OpenClaw plutôt qu'une API directe ou une passerelle EvoLink, la documentation du fournisseur Moonshot d'OpenClaw liste actuellement :

• moonshot/kimi-k2.5
• moonshot/kimi-k2-thinking
• moonshot/kimi-k2-thinking-turbo

Le raccourci d'intégration documenté est :

openclaw onboard --auth-choice moonshot-api-key
openclaw models list
openclaw models set moonshot/kimi-k2-thinking
openclaw models status

OpenClaw documente également le contrôle binaire natif de la réflexion pour Moonshot :

• /think off désactive la réflexion Moonshot
• tout niveau de réflexion autre que off correspond à thinking.type=enabled

C'est utile si vous souhaitez une passerelle unique capable de basculer entre une passe non-réflexive moins coûteuse et une passe de raisonnement approfondi.

Un cadre décisionnel plus sûr

FAQ

Kimi K2 Thinking est-il le même que Kimi K2.5 ?

Qu'est-ce qui fait échouer la plupart des agents Kimi multi-étapes ?

reasoning_content compte-t-il dans les tokens ?

Devrais-je désactiver la réflexion pour chaque tâche simple ?

Puis-je utiliser Kimi K2 Thinking via EvoLink ?

Puis-je utiliser Kimi K2 Thinking dans OpenClaw ?

Où devrais-je publier les chiffres de tarification ?

Depuis les pages de tarification en direct de Moonshot, et non depuis des tableaux de comparaison tiers ou des articles de comparaison plus anciens. Cette réécriture évite intentionnellement les mentions de tarification codées en dur, car ces valeurs changent plus vite que les recommandations sur le comportement des modèles.

Essayez Kimi via une seule passerelle

Si vous souhaitez tester Kimi aux côtés de Claude, GPT et d'autres modèles adaptés aux agents sans connecter chaque fournisseur séparément, utilisez une couche de passerelle et vérifiez les routes actuellement disponibles avant de publier une comparaison de coûts.

Sources

• Guide du modèle de réflexion Moonshot
• Index de tarification de l'API Moonshot
• Documentation du fournisseur Moonshot d'OpenClaw