FR ▾
Obtenir la clé API

kimiapikey.comGuide

Intégration de la clé API Kimi avec les SDK OpenAI et LangChain

Intégrer cette API à une application signifie modifier deux valeurs dans le code que vous avez probablement déjà : l'URL de base et la clé. Ce guide montre la modification pour les SDK OpenAI, LangChain et LiteLLM, puis couvre les tentatives et les limites pour une utilisation en production.

Mis à jour le

Blocs isométriques connectés par des lignes lumineuses à un hub central, montrant des applications s'intégrant à une API

Points clés

  • Chaque client a besoin des trois mêmes valeurs : l'URL de base https://api.kimiapikey.com/v1, votre clé et le modèle uncensored.
  • Stockez-les dans des variables d'environnement afin que vous puissiez changer de fournisseur sans modifier le code.
  • Gérez les réponses 429 séparément : rate_limited, concurrency et une surcharge temporaire avec Retry-After: 5.
  • Une clé complète permet 8 requêtes simultanées et 300 par minute ; une clé d'essai permet 2 et 60.

Ce qui change réellement dans votre code

Une intégration de la clé API Kimi ressemble à un projet, mais pour cet endpoint, c'est un changement de configuration. Le service implémente le format de complétion de chat OpenAI, donc toute bibliothèque cliente qui vous permet de définir une URL de base et une clé fonctionnera. Il n'y a pas de SDK personnalisé à installer ni de nouvelle forme de requête à apprendre.

ParamètreValeur
URL de basehttps://api.kimiapikey.com/v1
AuthentificationLa clé de votre tableau de bord, envoyée en tant que Authorization: Bearer
Modèleuncensored
EndpointsPOST /v1/chat/completions, GET /v1/models

Deux points font gagner du temps. Premièrement, c'est un modèle textuel derrière un seul endpoint : pas de route d'embedding, pas de génération d'image, pas d'audio. Si votre application appelle ces services, gardez un autre fournisseur pour eux et acheminez uniquement le chat ici. Deuxièmement, ce n'est pas l'API officielle de Kimi ou d'un autre fournisseur ; c'est un fournisseur indépendant exécutant un modèle à poids ouverts, donc les noms de modèles d'autres plateformes ne seront pas résolus. L'explication de la clé API Kimi couvre cette différence plus en détail.

Récupérez votre clé sur la page clé API. Les nouveaux comptes peuvent y réclamer 0,50 $ de crédit d'essai, ce qui est largement suffisant pour tout ce qui suit.

Configuration et migration d'une application existante

Les bibliothèques officielles OpenAI pour Python et Node lisent OPENAI_API_KEY et OPENAI_BASE_URL dans l'environnement lorsque vous ne les passez pas explicitement. Cela rend l'intégration la plus simple un changement de shell :

export OPENAI_BASE_URL="https://api.kimiapikey.com/v1"
export OPENAI_API_KEY="YOUR_KEY"

Le code existant qui instancie un client OpenAI() nu communique désormais avec cet endpoint. Vous devez toujours modifier l'argument model vers uncensored. Placez également le nom du modèle dans une variable, par exemple LLM_MODEL, afin que l'environnement de test et celui de production puissent différer sans modifier le code.

L'habitude en vaut la minute qu'elle prend. Lorsque l'URL de base, la clé et le modèle sont dans la configuration, essayer un autre fournisseur compatible OpenAI est un changement de déploiement, et revenir en arrière est le même changement à l'envers.

La plupart des équipes ne commencent pas à partir d'un fichier vide. Elles ont une application qui appelle déjà une API de style OpenAI et veulent qu'elle appelle celle-ci. La migration consiste principalement à rechercher trois chaînes.

  1. Trouvez où le client est construit et modifiez l'URL de base.
  2. Trouvez chaque argument model= et remplacez l'ancien nom par uncensored.
  3. Recherchez les fonctionnalités que votre code utilise et que cette API ne fournit pas, telles que les embeddings, la génération d'images ou l'audio. Ces appels doivent rester avec un autre fournisseur ou être supprimés.

Puis comparez le comportement, pas seulement la syntaxe. Un modèle différent a une voix différente, une longueur par défaut différente et des habitudes différentes en matière de formatage. Exécutez vos prompts de test existants, lisez les réponses côte à côte et ajustez le prompt système lorsque le ton a dérivé. Le texte du prompt qui fonctionnait avec les particularités d'un autre modèle peut parfois ne rien faire ici, et parfois empirer les choses, alors supprimez les contournements anciens un par un et observez ce qui change.

Vérifiez également les paramètres que vous passez. Temperature, top_p, stop, seed et les pénalités sont transmis, donc ils se comportent comme vous vous y attendez. Les champs qui appartiennent à d'autres fournisseurs ou aux fonctionnalités que cette API n'a pas ne feront rien d'utile. Gardez le corps de la requête petit et standard. La limite du corps est de 8 Mo, ce qui n'a de l'importance que si vous intégrez directement de grands documents.

Python : synchrone, streaming et asynchrone

La forme explicite, qui ne dépend pas des variables d'environnement :

from openai import OpenAI

client = OpenAI(
    base_url="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You answer in plain English."},
        {"role": "user", "content": "Explain idempotency in two sentences."},
    ],
    temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Pour le streaming, définissez stream=True et lisez les chunks à mesure qu'ils arrivent. Le stream est livré via des événements envoyés par le serveur, et l'utilisation est rapportée à la fin.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a limerick about retries."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Pour un service qui gère de nombreux utilisateurs, utilisez le client asynchrone et limitez votre propre parallélisme afin de ne jamais dépasser la limite de concurrence de la clé. Un sémaphore est le moyen le plus simple :

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
)
gate = asyncio.Semaphore(8)

async def ask(prompt: str) -> str:
    async with gate:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Give one fact about the number {n}." for n in range(20)]
    answers = await asyncio.gather(*(ask(p) for p in prompts))
    print(len(answers), "answers")

asyncio.run(main())

Définissez le sémaphore à 2 lorsque vous êtes sur la clé d'essai, et à 8 sur une clé financée.

Node et TypeScript

La bibliothèque Node prend les mêmes deux options sous des noms légèrement différents :

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.kimiapikey.com/v1",
  apiKey: process.env.API_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Name three HTTP status codes." }],
});

console.log(completion.choices[0].message.content);

Le streaming avec le même client utilise stream: true et un itérateur asynchrone sur le résultat. Si vous utilisez un framework front-end qui enveloppe la bibliothèque OpenAI, comme un framework UI de chat, recherchez son option d'URL de base et définissez-la de la même manière. Gardez la clé sur le serveur. Une clé placée dans le code du navigateur peut être copiée par quiconque ouvre les outils de développement, et le crédit associé est de l'argent réel.

LangChain et LiteLLM

Les frameworks qui enveloppent le client OpenAI exposent généralement les mêmes deux paramètres. Dans LangChain pour Python, la classe de modèle de chat OpenAI les accepte directement :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="uncensored",
    base_url="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
    temperature=0.5,
)

reply = llm.invoke("Summarize what a message queue does in one sentence.")
print(reply.content)

À partir de là, les chaînes, les modèles de prompt et les analyseurs de sortie fonctionnent comme avec n'importe quel modèle de chat. Si vous liez des outils, l'API prend en charge l'appel de fonctions avec tools et tool_choice, et les résultats des outils reviennent au modèle en tant que messages role: "tool", ce que le framework produit.

LiteLLM est utile lorsque vous souhaitez une convention d'appel unique pour plusieurs fournisseurs. Préfixez le modèle avec openai/ et passez l'URL de base en tant que api_base :

import litellm

resp = litellm.completion(
    model="openai/uncensored",
    api_base="https://api.kimiapikey.com/v1",
    api_key="YOUR_KEY",
    messages=[{"role": "user", "content": "Say hello in French."}],
)
print(resp.choices[0].message.content)

Pour les données structurées, passez response_format={"type": "json_object"} et indiquez dans le prompt que vous souhaitez du JSON. Analysez toujours le résultat de manière défensive, car le mode JSON exige un JSON valide, mais votre schéma reste une requête dans le prompt.

Limites, tentatives et gestion des erreurs

Une clé financée permet 8 requêtes simultanées et 300 requêtes par minute. Une clé d'essai en permet 2 et 60. Le corps peut faire jusqu'à 8 Mo, et la fenêtre de contexte est de 100 000 tokens pour le prompt et la complétion ensemble. Lorsque vous dépassez une limite, l'API répond avec un HTTP 429 et l'un de ces codes :

  • rate_limited : trop de requêtes par minute. Patientez quelques secondes.
  • concurrency : trop de requêtes en cours en même temps. Attendez qu'une se termine. Une requête en streaming occupe sa place jusqu'à la fin du stream, donc un consommateur lent compte contre vous.
  • Un 429 avec Retry-After: 5 : surcharge temporaire. Attendez cinq secondes et réessayez.

Un petit wrapper de retry qui respecte l'en-tête gère les trois cas :

import time
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.kimiapikey.com/v1", api_key="YOUR_KEY", max_retries=0)

def chat(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = int(e.response.headers.get("retry-after", 2 ** attempt))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Les requêtes échouées ou refusées ne sont pas facturées, donc réessayer n'entraîne aucune pénalité de facturation. Journalisez l'en-tête de réponse X-Request-Id avec chaque appel ; c'est le moyen le plus rapide de pointer vers une requête si quelque chose semble incorrect. X-Balance-USD vous indique combien de crédit reste, ce que vous pouvez alimenter dans une alerte. La documentation liste tous les en-têtes de réponse.

Appel de fonctions via un framework

Les frameworks d'agent dépendent de l'appel de fonctions, donc cela vaut la peine de faire un court test avant de construire dessus. Cette API accepte tools et tool_choice, renvoie tool_calls lorsque le modèle veut exécuter une fonction, et attend le résultat en tant que message role: "tool" qui fait référence à l'ID d'appel. Le streaming fonctionne avec les outils, avec l'appel arrivant en fragments que le SDK assemble pour vous.

Un bon premier test est un agent à un outil avec une fonction dont vous pouvez vérifier le résultat à l'œil nu, comme une calculatrice ou une recherche dans un petit dictionnaire. Exécutez-le dix fois. Si le modèle sélectionne l'outil et remplit correctement ses arguments à chaque fois, vous pouvez ajouter un deuxième outil. Si parfois il répond à partir de la mémoire au lieu d'appeler la fonction, rendez la description de l'outil plus spécifique, ou définissez tool_choice pour forcer l'appel pour cette étape. Les modèles diffèrent dans la fiabilité avec laquelle ils pilotent de longues chaînes d'appels, donc gardez les chaînes courtes et ajoutez une limite d'étapes à toute boucle afin qu'une exécution confuse ne puisse pas tourner indéfiniment et dépenser du crédit.

Une courte liste de vérification avant le lancement

  1. Exécutez une requête via curl ou le SDK et confirmez que le bloc d'utilisation est présent.
  2. Testez le streaming avec le client qui sera utilisé en production, y compris ce qui se passe lorsque l'utilisateur ferme la page en plein milieu du stream.
  3. Limitez votre propre concurrence en dessous de la limite de la clé.
  4. Définissez max_tokens là où des réponses courtes sont attendues, et réduisez l'historique du chat avant qu'il ne dépasse ce que vous voulez payer.
  5. Gardez la clé dans la configuration côté serveur et renouvelez-la si elle apparaît dans un journal.
  6. Vérifiez le coût sur le trafic réel. À $0,15 par 1M d'entrée et $0,50 par 1M de sortie, une requête avec 3 000 tokens en entrée et 700 en sortie coûte $0,0008, donc 10 000 d'entre eux coûtent environ $8. Les détails sont sur la page des tarifs.

Les prompts envoyés à l'API ne sont pas utilisés pour l'entraînement. La seule règle de contenu qui ne change jamais est la limite stricte sur le contenu sexuel impliquant des mineurs ; le modèle est autrement ajusté pour répondre sans refus pour une utilisation adulte légale, donc les applications qui servent le public devraient toujours ajouter leur propre modération et vérifications d'âge là où la loi ou vos utilisateurs les attendent.

Questions fréquemment posées

Le modèle est-il le même que le Kimi officiel de Moonshot ?
Non, nous hébergeons un modèle à poids ouverts qui est ajusté pour être sans censure. Il ne s'agit pas de GPT, Claude, Gemini, Grok, DeepSeek ou de tout autre modèle d'un autre fournisseur. C'est un modèle distinct exécuté sur nos propres serveurs.

Entraînez-vous sur mes données ?
Non. Vos prompts et vos complétions ne sont pas utilisés pour l'entraînement. Nous valorisons la confidentialité et la transparence, vos données restent donc les vôtres.

Quelles sont les limites de débit ?
Vous êtes limité à 300 requêtes par minute par clé. La taille maximale du corps de la requête est de 8 Mo. Ces limites sont conçues pour garantir des performances stables pour tous les utilisateurs.

Quelle est la politique en matière de contenu ?
Le modèle est sans censure concernant les sujets pour adultes, controversés et créatifs. Cependant, nous bloquons le contenu sexuel impliquant des mineurs. Il s'agit d'une limite stricte qui s'applique toujours, quel que soit votre niveau d'abonnement.

Questions et réponses

Ai-je besoin d'un SDK spécial ?

Non. Les bibliothèques OpenAI standard pour Python et Node fonctionnent après avoir défini l'URL de base sur https://api.kimiapikey.com/v1 et utilisé votre clé. LangChain et LiteLLM fonctionnent de la même manière.

Quel nom de modèle mon code doit-il utiliser ?

Utilisez uncensored. C'est le seul ID de modèle que l'API sert, et GET /v1/models le liste.

Comment éviter les erreurs 429 ?

Limitez vos requêtes simultanées à 8 sur une clé financée ou à 2 sur une clé d'essai, et réessayez après le délai Retry-After lorsque l'API le demande.

Prend-il en charge l'appel de fonctions et le mode JSON ?

Oui. Utilisez tools et tool_choice pour les appels de fonctions, et response_format avec type json_object pour la sortie JSON. Le streaming fonctionne également.

Puis-je utiliser les embeddings ou la génération d'images avec la même clé ?

Non. L'API est uniquement destinée au chat textuel, sans endpoints pour les embeddings, les images, l'audio ou la vidéo.

Votre clé n'est qu'à un formulaire d'ici

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé APILire la documentation