> ## Documentation Index
> Fetch the complete documentation index at: https://smartac-justin-client-exports.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Créer un message de l’Assistant (v1)

> Génère un message de réponse de l’Assistant pour le domain spécifié. Compatible avec l’AI SDK v4.

<Badge color="orange">Obsolète</Badge>

<Info>
  Le point de terminaison assistant message v1 est compatible avec **AI SDK v4**. Si vous utilisez AI SDK v5 ou une version ultérieure, utilisez plutôt le [point de terminaison assistant message v2](/fr/api/assistant/create-assistant-message-v2).
</Info>

<div id="integration-with-usechat">
  ## Intégration avec `useChat`
</div>

Le hook `useChat` du SDK AI de Vercel est la méthode recommandée pour intégrer l’API de l’Assistant à votre application.

<Steps>
  <Step title="Installer le SDK AI v4">
    ```bash theme={null}
    npm i ai@^4.1.15
    ```
  </Step>

  <Step title="Utiliser le hook">
    ```tsx theme={null}
    import { useChat } from 'ai/react';

    function MyComponent({ domain }) {
      const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
        api: `https://api.mintlify.com/discovery/v1/assistant/${domain}/message`,
        headers: {
          'Authorization': `Bearer ${process.env.PUBLIC_MINTLIFY_ASSISTANT_KEY}`,
        },
        body: {
          fp: 'anonymous',
          retrievalPageSize: 5,
          context: [
            {
              type: 'code',
              value: 'const example = "code snippet";',
              elementId: 'code-block-1',
            },
          ],
        },
        streamProtocol: 'data',
        sendExtraMessageFields: true,
      });

      return (
        <div>
          {messages.map((message) => (
            <div key={message.id}>
              {message.role === 'user' ? 'Utilisateur : ' : 'Assistant : '}
              {message.content}
            </div>
          ))}
          <form onSubmit={handleSubmit}>
            <input value={input} onChange={handleInputChange} />
            <button type="submit">Envoyer</button>
          </form>
        </div>
      );
    }
    ```

    **Configuration requise pour Mintlify :**

    * `streamProtocol: 'data'` - Requis pour les réponses en streaming.
    * `sendExtraMessageFields: true` - Requis pour envoyer les métadonnées des messages.
    * `body.fp` - Identifiant d’empreinte (utilisez 'anonymous' ou un identifiant utilisateur).
    * `body.retrievalPageSize` - Nombre de résultats de recherche à utiliser (recommandé : 5).

    **Configuration optionnelle :**

    * `body.context` - Tableau d’informations contextuelles à fournir à l’Assistant. Chaque objet de contexte contient :
      * `type` - Soit `'code'` soit `'textSelection'`.
      * `value` - L’extrait de code ou le texte sélectionné.
      * `elementId` (optionnel) - Identifiant de l’élément d’interface contenant le contexte.
    * `body.currentPath` - Le chemin de la page actuellement consultée par l’utilisateur. Lorsqu’il est fourni, l’Assistant utilise ce contexte pour donner des réponses plus pertinentes. Longueur maximale : 200 caractères.
  </Step>
</Steps>

Consultez [useChat](https://ai-sdk.dev/docs/reference/ai-sdk-ui/use-chat) dans la documentation du SDK AI pour en savoir plus.

<div id="rate-limits">
  ## Limites de débit
</div>

L’API de l’Assistant applique les limites suivantes :

* 10 000 requêtes par organisation Mintlify et par heure
* 10 000 requêtes par adresse IP et par jour


## OpenAPI

````yaml fr/discovery-openapi.json POST /v1/assistant/{domain}/message
openapi: 3.0.1
info:
  title: Mintlify Assistant API
  description: >-
    Une API pour intégrer les fonctionnalités de découverte de Mintlify à votre
    produit.
  version: 1.0.0
servers:
  - url: https://api.mintlify.com/discovery
security:
  - bearerAuth: []
paths:
  /v1/assistant/{domain}/message:
    post:
      summary: Message de l’Assistant v1
      description: >-
        Génère un message de réponse de l’Assistant pour le domain spécifié.
        Compatible avec l’AI SDK v4.
      parameters:
        - name: domain
          in: path
          required: true
          schema:
            type: string
          description: >-
            L’identifiant de domain à partir de votre URL
            `domain.mintlify.site`. Il se trouve à la fin de l’URL de votre
            Dashboard. Par exemple, `dashboard.mintlify.com/organization/domain`
            a un identifiant de domain de `domain`.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - fp
                - messages
              properties:
                fp:
                  type: string
                  description: "Identifiant de fingerprint pour le suivi des sessions de conversation. Utilisez «\_anonymous\_» pour les utilisateurs anonymes ou fournissez un identifiant utilisateur unique."
                threadId:
                  default: null
                  type: string
                  description: >-
                    Identifiant facultatif utilisé pour maintenir la continuité
                    d’une conversation sur plusieurs messages. Lorsqu’il est
                    fourni, il permet au système de rattacher les messages
                    suivants au même fil de discussion. Le threadId est renvoyé
                    dans la réponse sous la forme event.threadId lorsque
                    event.type === 'finish'.
                messages:
                  type: array
                  default:
                    - id: foobar
                      role: user
                      content: how do i get started
                      parts:
                        - type: text
                          text: How do I get started
                  items:
                    type: object
                    properties:
                      id:
                        type: string
                        description: Identifiant unique du message.
                      role:
                        type: string
                        enum:
                          - system
                          - assistant
                          - data
                          - user
                        description: Rôle de l’émetteur du message.
                      createdAt:
                        type: string
                        format: date-time
                        description: Horodatage de la création du message.
                      content:
                        type: string
                        description: Contenu du message.
                      annotations:
                        type: array
                        items: {}
                        description: Tableau optionnel d’annotations pour ce message.
                      parts:
                        type: array
                        items:
                          oneOf:
                            - type: object
                              properties:
                                type:
                                  type: string
                                  enum:
                                    - text
                                text:
                                  type: string
                              required:
                                - type
                                - text
                            - type: object
                              properties:
                                type:
                                  type: string
                                  enum:
                                    - reasoning
                                reasoning:
                                  type: string
                                details:
                                  type: array
                                  items:
                                    oneOf:
                                      - type: object
                                        properties:
                                          type:
                                            type: string
                                            enum:
                                              - text
                                          text:
                                            type: string
                                          signature:
                                            type: string
                                        required:
                                          - type
                                          - text
                                      - type: object
                                        properties:
                                          type:
                                            type: string
                                            enum:
                                              - redacted
                                          data:
                                            type: string
                                        required:
                                          - type
                                          - data
                              required:
                                - type
                                - reasoning
                                - details
                            - type: object
                              properties:
                                type:
                                  type: string
                                  enum:
                                    - step-start
                              required:
                                - type
                            - type: object
                              properties:
                                type:
                                  type: string
                                  enum:
                                    - source
                                source:
                                  type: object
                                  properties:
                                    sourceType:
                                      type: string
                                      enum:
                                        - url
                                    id:
                                      type: string
                                    url:
                                      type: string
                                    title:
                                      type: string
                                  required:
                                    - sourceType
                                    - id
                                    - url
                              required:
                                - type
                                - source
                            - type: object
                              properties:
                                type:
                                  type: string
                                  enum:
                                    - tool-invocation
                                toolInvocation:
                                  oneOf:
                                    - type: object
                                      properties:
                                        state:
                                          type: string
                                          enum:
                                            - partial-call
                                        step:
                                          type: number
                                        toolCallId:
                                          type: string
                                        toolName:
                                          type: string
                                        args: {}
                                      required:
                                        - state
                                        - toolCallId
                                        - toolName
                                        - args
                                    - type: object
                                      properties:
                                        state:
                                          type: string
                                          enum:
                                            - call
                                        step:
                                          type: number
                                        toolCallId:
                                          type: string
                                        toolName:
                                          type: string
                                        args: {}
                                      required:
                                        - state
                                        - toolCallId
                                        - toolName
                                        - args
                                    - type: object
                                      properties:
                                        state:
                                          type: string
                                          enum:
                                            - result
                                        step:
                                          type: number
                                        toolCallId:
                                          type: string
                                        toolName:
                                          type: string
                                        args: {}
                                        result: {}
                                      required:
                                        - state
                                        - toolCallId
                                        - toolName
                                        - args
                                        - result
                              required:
                                - type
                                - toolInvocation
                        description: >-
                          Tableau de segments de message avec différents types,
                          dont le texte, le raisonnement, les sources et les
                          appels d’outils.
                      experimental_attachments:
                        type: array
                        items:
                          type: object
                          properties:
                            name:
                              type: string
                            contentType:
                              type: string
                            url:
                              type: string
                          required:
                            - url
                        description: >-
                          Tableau facultatif de pièces jointes expérimentales
                          associées au message.
                    required:
                      - id
                      - role
                      - content
                      - parts
                  description: >-
                    Tableau de messages représentant la conversation. Côté
                    frontend, vous utiliserez probablement la fonction
                    handleSubmit du hook useChat du package @ai-sdk pour ajouter
                    les messages utilisateur et gérer les réponses en streaming,
                    plutôt que de définir manuellement les objets de ce tableau,
                    car ils comportent de très nombreux paramètres.
                retrievalPageSize:
                  type: number
                  default: 5
                  description: "Nombre de résultats de recherche dans la documentation à utiliser pour générer la réponse. Des valeurs plus élevées fournissent davantage de contexte mais peuvent augmenter le temps de réponse. Valeur recommandée\_: 5."
                filter:
                  type: object
                  default: null
                  properties:
                    version:
                      type: string
                      description: Filtre de version facultatif.
                    language:
                      type: string
                      description: Filtre de langue facultatif.
                  description: Critères de filtrage facultatifs pour la recherche.
                context:
                  type: array
                  items:
                    type: object
                    properties:
                      type:
                        type: string
                        enum:
                          - code
                          - textSelection
                        description: Type de contexte fourni.
                      value:
                        type: string
                        description: Extrait de code ou texte sélectionné.
                      path:
                        type: string
                        description: Chemin facultatif vers le fichier ou la page source.
                      elementId:
                        type: string
                        description: >-
                          Identifiant facultatif de l’élément d’interface qui
                          contient le contexte.
                    required:
                      - type
                      - value
                  description: >-
                    Tableau facultatif d’informations de contexte à transmettre
                    à l’Assistant.
                currentPath:
                  type: string
                  description: "Chemin de la page que l’utilisateur consulte actuellement. Lorsqu’il est fourni, l’Assistant utilise ce contexte pour donner des réponses plus pertinentes. Longueur maximale\_: 200\_caractères."
      responses:
        '200':
          description: Message généré avec succès.
          content:
            application/json:
              schema:
                type: object
                description: >-
                  Objet de réponse dont les parties du flux de données sont
                  formatées avec le status, les en-têtes et le champ content
                  spécifiés. Pour plus d’informations, consultez la
                  documentation de l’AI SDK sur
                  [ai-sdk.dev/docs/ai-sdk-ui/streaming-data](https://ai-sdk.dev/docs/ai-sdk-ui/streaming-data).
                  Utilisez le [hook useChat de
                  ai-sdk](https://ai-sdk.dev/docs/reference/ai-sdk-ui/use-chat#usechat)
                  pour gérer le flux de réponse.
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        L’en-tête Authorization attend un jeton Bearer. Utilisez une clé d’API
        Assistant (préfixée par `mint_dsc_`). Il s’agit d’une clé publique, que
        vous pouvez utiliser en toute sécurité dans du code côté client.
        Générez-en une sur la page [API
        keys](https://dashboard.mintlify.com/settings/organization/api-keys) de
        votre Dashboard.

````