> ## 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) - Messages : Démarrage rapide

> - Appeler les modèles Kimi via le protocole Anthropic Messages et choisir le modèle avec `model`
- Seuls `model`, `max_tokens` et `messages` sont requis (`max_tokens` est obligatoire dans le protocole Anthropic)
- Les trois modèles ont une fenêtre de contexte de 1 048 576 tokens
- Le raisonnement est toujours activé sur les trois modèles ; son intensité se règle avec `output_config.effort`
- Pour les appels d’outils, la recherche Web, les images en entrée, les sorties structurées et le cache, consulter la [référence complète](/fr/api-manual/language-series/kimi/messages/messages-reference)

> [!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.

> [!NOTE]
>
> **Le raisonnement est toujours activé sur les modèles Kimi**. Le champ `content` contient généralement des blocs `type="thinking"`, qui comptent dans les tokens de sortie. Évitez une valeur trop basse pour `max_tokens` : le raisonnement pourrait épuiser le budget avant de produire le texte de réponse.


## OpenAPI

````yaml fr/api-manual/language-series/kimi/messages/messages-quickstart.json POST /v1/messages
openapi: 3.1.0
info:
  title: 'API Kimi (tous les modèles) - Messages : Démarrage rapide'
  description: >-
    Exemples de démarrage rapide pour appeler les modèles de texte Kimi via le
    protocole Anthropic Messages. Il suffit de `model`, `max_tokens` et
    `messages` pour démarrer une conversation ; consulter la page « Référence
    complète » pour les appels d’outils, la recherche Web et les images en
    entrée, entre autres.
  license:
    name: MIT
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Production (Recommandé)
  - url: https://api.evolink.ai
    description: URL alternative
security:
  - bearerAuth: []
tags:
  - name: Messages
    description: API compatible Anthropic Messages
paths:
  /v1/messages:
    post:
      tags:
        - Messages
      summary: Chat Kimi rapide (tous les modèles, compatible Anthropic)
      description: >-
        - Appeler les modèles Kimi via le protocole Anthropic Messages et
        choisir le modèle avec `model`

        - Seuls `model`, `max_tokens` et `messages` sont requis (`max_tokens`
        est obligatoire dans le protocole Anthropic)

        - Les trois modèles ont une fenêtre de contexte de 1 048 576 tokens

        - Le raisonnement est toujours activé sur les trois modèles ; son
        intensité se règle avec `output_config.effort`

        - Pour les appels d’outils, la recherche Web, les images en entrée, les
        sorties structurées et le cache, consulter la [référence
        complète](/fr/api-manual/language-series/kimi/messages/messages-reference)
      operationId: kimiMessagesQuick
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateMessageQuickRequest'
            examples:
              simple:
                summary: Requête Pro minimale
                value:
                  model: kimi-k3.1-pro
                  max_tokens: 2048
                  messages:
                    - role: user
                      content: Explique le cache de contexte en une phrase.
              highspeed:
                summary: Highspeed avec un faible effort de raisonnement
                value:
                  model: kimi-k3.1-pro-highspeed
                  max_tokens: 2048
                  output_config:
                    effort: low
                  messages:
                    - role: user
                      content: Explique le cache de contexte en une phrase.
              k3:
                summary: Requête minimale Kimi K3
                value:
                  model: kimi-k3
                  max_tokens: 2048
                  messages:
                    - role: user
                      content: Explique le cache de contexte en une phrase.
              multi_turn:
                summary: Instructions système et conversations à plusieurs tours
                value:
                  model: kimi-k3.1-pro
                  max_tokens: 2048
                  output_config:
                    effort: low
                  system: >-
                    Vous êtes un rédacteur technique rigoureux. Répondez avec
                    concision.
                  messages:
                    - 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 ?
              streaming:
                summary: Streaming SSE Anthropic
                value:
                  model: kimi-k3.1-pro
                  max_tokens: 2048
                  output_config:
                    effort: low
                  stream: true
                  messages:
                    - role: user
                      content: Écris un poème de quatre vers sur une nuit d’été.
      responses:
        '200':
          description: >-
            Réponse Message ; les requêtes en streaming renvoient un flux
            d'événements Anthropic SSE
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/MessageResponse'
            text/event-stream:
              schema:
                type: string
                description: >-
                  La séquence d'événements comprend généralement message_start,
                  content_block_*, message_delta et message_stop.
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/Unauthorized'
        '429':
          $ref: '#/components/responses/RateLimited'
        '500':
          $ref: '#/components/responses/InternalError'
components:
  schemas:
    CreateMessageQuickRequest:
      type: object
      required:
        - model
        - max_tokens
        - messages
      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é.
        max_tokens:
          type: integer
          minimum: 1
          maximum: 1048576
          description: >-
            Nombre maximal de tokens autorisés pour cette génération, thinking
            et texte final compris. Une valeur trop basse peut épuiser le budget
            pendant le raisonnement sans produire de texte final. Prévoir au
            moins 1024 et augmenter selon la complexité.
        messages:
          type: array
          minItems: 1
          description: >-
            Messages de la conversation. Fournir l’historique dans l’ordre pour
            les conversations à plusieurs tours ; consulter la référence
            complète pour renvoyer l’historique de raisonnement et d’appels
            d’outils.
          items:
            $ref: '#/components/schemas/MessageSimple'
        system:
          type: string
          description: >-
            Prompt système. Le protocole Messages utilise un champ system de
            premier niveau au lieu d'un rôle system.
        output_config:
          type: object
          description: Configuration de sortie.
          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: Indique si un flux d'événements Anthropic SSE est renvoyé.
    MessageResponse:
      type: object
      properties:
        id:
          type: string
          description: Identifiant de la réponse.
          example: chatcmpl-6adc72c2b5847b4b2ccb39fd
        type:
          type: string
          enum:
            - message
          example: message
        role:
          type: string
          enum:
            - assistant
          example: assistant
        model:
          type: string
          description: Modèle utilisé pour cet appel.
          example: kimi-k3.1-pro
        content:
          type: array
          description: Blocs de contenu de sortie, généralement thinking puis text.
          items:
            $ref: '#/components/schemas/OutputContentBlock'
        stop_reason:
          type:
            - string
            - 'null'
          enum:
            - end_turn
            - max_tokens
            - tool_use
            - null
          description: >-
            Motif d’arrêt : `end_turn` indique une fin naturelle, `max_tokens`
            une limite de sortie atteinte et `tool_use` une demande d’appel
            d’outil.
          example: end_turn
        usage:
          $ref: '#/components/schemas/MessageUsage'
    MessageSimple:
      type: object
      required:
        - role
        - content
      properties:
        role:
          type: string
          enum:
            - user
            - assistant
          description: Rôle du message. Seuls user et assistant sont pris en charge.
        content:
          type: string
          description: Contenu du message (texte brut).
          example: Explique le cache de contexte en une phrase.
    OutputContentBlock:
      type: object
      properties:
        type:
          type: string
          enum:
            - thinking
            - text
          example: text
        thinking:
          type: string
          description: >-
            Raisonnement lorsque `type=thinking`. Le renvoyer sans modification
            avec signature dans les conversations à plusieurs tours.
        signature:
          type: string
          description: >-
            Signature lorsque `type=thinking` ; la renvoyer sans modification
            dans les conversations à plusieurs tours.
        text:
          type: string
          description: Texte de la réponse lorsque `type=text`.
          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.
    MessageUsage:
      type: object
      properties:
        input_tokens:
          type: integer
          description: Tokens d’entrée standard, hors lectures et écritures de cache.
          example: 24
        cache_read_input_tokens:
          type: integer
          description: Tokens d'entrée servis depuis le cache.
          example: 0
        cache_creation_input_tokens:
          type: integer
          description: Tokens d'entrée écrits dans le cache.
          example: 0
        output_tokens:
          type: integer
          description: Tokens de sortie, y compris les tokens thinking.
          example: 96
    ErrorResponse:
      type: object
      properties:
        type:
          type: string
          enum:
            - error
        error:
          type: object
          properties:
            type:
              type: string
            message:
              type: string
        request_id:
          type: string
  responses:
    BadRequest:
      description: Paramètres de requête invalides
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    Unauthorized:
      description: La clé API est absente ou invalide
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    RateLimited:
      description: Limite de débit dépassée ou quota insuffisant
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
    InternalError:
      description: Erreur interne du service
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
  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.