> ## Documentation Index
> Fetch the complete documentation index at: https://evolink.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# API Kimi (tous les modèles) - Responses : Démarrage rapide

> Appeler Kimi avec `model` et `input`. Modèles pris en charge : `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` et `kimi-k3`. Pour `max_output_tokens`, commencer à 1024 afin de réserver de la place au raisonnement et à la réponse.

Consulter la [référence complète](/fr/api-manual/language-series/kimi/responses/responses-reference) pour davantage d’exemples et les différences entre modèles.

> [!NOTE]
>
> **BaseURL** : La BaseURL par défaut est `https://direct.evolink.ai`, qui offre une meilleure prise en charge des modèles textuels et des connexions de longue durée. `https://api.evolink.ai` est le point de terminaison principal pour les services multimodaux et sert d'adresse de repli pour les modèles textuels.

Utilisez `POST /v1/responses` et sélectionnez `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` ou `kimi-k3` avec `model`. Seuls `model` et `input` sont requis.

> [!WARNING]
>
> **Les noms des paramètres diffèrent de Chat Completions** : utilisez `input` pour l’entrée, `max_output_tokens` pour la limite de sortie et `reasoning.effort` pour l’effort de raisonnement.

## Lire le texte de réponse

Le champ `output` peut contenir du raisonnement, du texte de réponse et des appels d’outils. Parcourez les blocs `output_text` des éléments `type="message"` ; ne supposez pas que le premier élément contient la réponse.

En supposant que le JSON de la réponse a été analysé dans `response`, extrayez le texte ainsi :

```python theme={null}
text = "".join(
    part["text"]
    for item in response.get("output", [])
    if item.get("type") == "message"
    for part in item.get("content", [])
    if part.get("type") == "output_text"
)
print(text)
```

> [!NOTE]
>
> **Réservez un budget de sortie pour le raisonnement** : `max_output_tokens` inclut le raisonnement et la réponse. Si `status="incomplete"` et `incomplete_details.reason="max_output_tokens"`, augmentez la limite. Une fois le budget épuisé, la réponse peut ne contenir que du raisonnement, sans texte de réponse.

Pour les appels d’outils, la recherche Web, les images en entrée et les sorties structurées, consultez la [référence complète](https://evolink.ai/docs/fr/api-manual/language-series/kimi/responses/responses-reference.md).


## OpenAPI

````yaml fr/api-manual/language-series/kimi/responses/responses-quickstart.json POST /v1/responses
openapi: 3.1.0
info:
  title: 'API Kimi (tous les modèles) - Responses : Démarrage rapide'
  description: >-
    Exemples de démarrage rapide pour appeler les modèles de texte Kimi via le
    protocole OpenAI Responses. Il suffit de `model` et `input` pour démarrer
    une conversation ; consulter la page « Référence complète » pour les appels
    d’outils, la recherche Web, les sorties structurées et les images en entrée,
    entre autres.
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Production (Recommandé)
  - url: https://api.evolink.ai
    description: URL alternative
security:
  - bearerAuth: []
paths:
  /v1/responses:
    post:
      tags:
        - Responses
      summary: Appel rapide Kimi Responses
      description: >-
        Appeler Kimi avec `model` et `input`. Modèles pris en charge :
        `kimi-k3.1-pro`, `kimi-k3.1-pro-highspeed` et `kimi-k3`. Pour
        `max_output_tokens`, commencer à 1024 afin de réserver de la place au
        raisonnement et à la réponse.


        Consulter la [référence
        complète](/fr/api-manual/language-series/kimi/responses/responses-reference)
        pour davantage d’exemples et les différences entre modèles.
      operationId: kimiResponsesQuick
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/ResponsesQuickRequest'
            examples:
              simple:
                summary: Requête Pro minimale
                value:
                  model: kimi-k3.1-pro
                  input: Explique le cache de contexte en une phrase.
              highspeed:
                summary: Highspeed avec un faible effort de raisonnement
                value:
                  model: kimi-k3.1-pro-highspeed
                  input: Explique le cache de contexte en une phrase.
                  reasoning:
                    effort: low
                  max_output_tokens: 1024
              k3:
                summary: Requête minimale Kimi K3
                value:
                  model: kimi-k3
                  input: Explique le cache de contexte en une phrase.
              multi_turn:
                summary: Instructions système et conversations à plusieurs tours
                value:
                  model: kimi-k3.1-pro
                  input:
                    - role: developer
                      content: >-
                        Vous êtes un rédacteur technique rigoureux. Répondez
                        avec concision.
                    - role: user
                      content: Qu’est-ce que le cache de contexte ?
                    - role: assistant
                      content: >-
                        Le cache de contexte conserve les préfixes répétés des
                        requêtes pour traiter les requêtes suivantes plus
                        rapidement et à moindre coût lorsqu’elles trouvent ce
                        cache.
                    - role: user
                      content: À quels usages convient-il ?
                  reasoning:
                    effort: low
                  max_output_tokens: 2048
              streaming:
                summary: Sortie SSE en streaming
                value:
                  model: kimi-k3.1-pro
                  input: Écris un poème de quatre vers sur une nuit d’été.
                  reasoning:
                    effort: low
                  max_output_tokens: 2048
                  stream: true
      responses:
        '200':
          description: >-
            Réponse créée avec succès ; les requêtes en streaming renvoient un
            flux d’événements SSE
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ResponsesResponse'
            text/event-stream:
              schema:
                type: string
                description: >-
                  Flux d’événements SSE au format Responses, se terminant par
                  `response.completed`, `response.incomplete` ou
                  `response.failed`.
        '400':
          description: Requête incorrecte - paramètres invalides
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '401':
          description: Non autorisé - clé API invalide ou absente
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '429':
          description: Limite de débit dépassée ou quota insuffisant
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Erreur serveur
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    ResponsesQuickRequest:
      type: object
      required:
        - model
        - input
      properties:
        model:
          type: string
          enum:
            - kimi-k3.1-pro
            - kimi-k3.1-pro-highspeed
            - kimi-k3
          default: kimi-k3.1-pro
          description: >-
            Modèle à appeler :


            | Identifiant du modèle | Positionnement |

            |---|---|

            | `kimi-k3.1-pro` | Dernière génération (recommandée) |

            | `kimi-k3.1-pro-highspeed` | Mêmes paramètres que Pro, génération
            plus rapide |

            | `kimi-k3` | Génération précédente |


            Les trois modèles ont une fenêtre de contexte de 1 048 576 tokens et
            un raisonnement toujours activé.
        input:
          description: >-
            Entrée de cette requête. Une chaîne équivaut à un message user ; un
            tableau fournit l’historique des messages dans l’ordre.
          oneOf:
            - type: string
            - type: array
              items:
                $ref: '#/components/schemas/InputMessage'
        max_output_tokens:
          type: integer
          minimum: 1
          maximum: 1048576
          default: 131072
          description: >-
            Nombre maximal de tokens générés, raisonnement et réponse finale
            compris ; 131072 par défaut, 1048576 au maximum.
        reasoning:
          type: object
          description: Configuration du raisonnement.
          properties:
            effort:
              type: string
              enum:
                - low
                - high
                - max
              default: max
              description: >-
                Effort de raisonnement, `max` par défaut. `kimi-k3` prend
                uniquement en charge `max` ; les autres valeurs compatibles sont
                décrites dans la référence complète.
        stream:
          type: boolean
          default: false
          description: Si true, renvoie la réponse sous forme de flux SSE.
    ResponsesResponse:
      type: object
      properties:
        id:
          type: string
          description: Identifiant de la réponse.
          example: resp_6adc72aab1f2eaaebe6b869e
        object:
          type: string
          enum:
            - response
          example: response
        created_at:
          type: integer
          description: Date de création, horodatage Unix en secondes.
          example: 1792832171
        status:
          type: string
          enum:
            - completed
            - incomplete
            - failed
          description: >-
            État de la réponse. `incomplete` signifie généralement que la limite
            `max_output_tokens` a été atteinte.
          example: completed
        incomplete_details:
          type:
            - object
            - 'null'
          description: Motif fourni lorsque `status` vaut `incomplete`.
          properties:
            reason:
              type: string
              enum:
                - max_output_tokens
                - content_filter
        model:
          type: string
          description: Modèle utilisé pour cet appel.
          example: kimi-k3.1-pro
        output:
          type: array
          description: Éléments de sortie, généralement reasoning puis message.
          items:
            $ref: '#/components/schemas/OutputItem'
        usage:
          $ref: '#/components/schemas/Usage'
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            message:
              type: string
              description: Message expliquant la cause de l’erreur.
            type:
              type: string
              description: Type d'erreur
            code:
              type: string
              description: Code d’erreur
          required:
            - message
      required:
        - error
    InputMessage:
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
            - assistant
            - developer
          description: >-
            Rôle du message. `developer` est traité comme des instructions
            système.
        content:
          type: string
          description: Contenu du message (texte brut).
          example: Explique le cache de contexte en une phrase.
    OutputItem:
      type: object
      properties:
        type:
          type: string
          enum:
            - reasoning
            - message
          description: '`reasoning` contient le raisonnement et `message` la réponse finale.'
          example: message
        id:
          type: string
          example: msg_6adc72aab1f2eaaebe6b869f
        summary:
          type: array
          description: Contenu du raisonnement lorsque `type=reasoning`.
          items:
            type: object
            properties:
              type:
                type: string
                enum:
                  - summary_text
              text:
                type: string
        role:
          type: string
          enum:
            - assistant
          description: Renvoyé lorsque `type=message`.
        content:
          type: array
          description: Contenu de la réponse lorsque `type=message`.
          items:
            $ref: '#/components/schemas/OutputText'
        status:
          type: string
          enum:
            - completed
          example: completed
    Usage:
      type: object
      properties:
        input_tokens:
          type: integer
          description: Tokens d’entrée, y compris ceux issus du cache.
          example: 24
        input_tokens_details:
          type: object
          properties:
            cached_tokens:
              type: integer
              description: Tokens d'entrée servis depuis le cache.
              example: 0
        output_tokens:
          type: integer
          description: Tokens de sortie, raisonnement compris.
          example: 96
        output_tokens_details:
          type: object
          properties:
            reasoning_tokens:
              type: integer
              description: Tokens de raisonnement, déjà inclus dans output_tokens.
              example: 62
        total_tokens:
          type: integer
          description: Nombre total de tokens d'entrée et de sortie.
          example: 120
    OutputText:
      type: object
      properties:
        type:
          type: string
          enum:
            - output_text
          example: output_text
        text:
          type: string
          example: >-
            Le cache de contexte conserve les préfixes répétés des requêtes pour
            traiter les requêtes suivantes plus rapidement et à moindre coût
            lorsqu’elles trouvent ce cache.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        ##Toutes les API nécessitent une authentification par Bearer Token##


        **Obtenir une clé API :**


        Visitez la [page de gestion des clés
        API](https://evolink.ai/dashboard/keys) pour obtenir votre clé API


        **Ajouter à l'en-tête de requête :**

        ```

        Authorization: Bearer YOUR_API_KEY

        ```

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.