> ## Documentation Index
> Fetch the complete documentation index at: https://wiki.another-horizon.eu/llms.txt
> Use this file to discover all available pages before exploring further.

# Message de l’Assistant

> Génère un message de réponse de l’Assistant pour le domaine spécifié.

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

<Note>
  L’API de l’Assistant Mintlify est compatible avec **AI SDK v4**. Si vous utilisez AI SDK v5 ou une version ultérieure, vous devez configurer un transport personnalisé.
</Note>

<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.MINTLIFY_TOKEN}`,
        },
        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.
  </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 utilisations par key et par mois
* 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 /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/v1
security:
  - bearerAuth: []
paths:
  /assistant/{domain}/message:
    post:
      summary: Message de l’Assistant
      description: Génère un message de réponse de l’Assistant pour le domaine spécifié.
      parameters:
        - name: domain
          in: path
          required: true
          schema:
            type: string
          description: >-
            L’identifiant de domaine figurant dans votre URL
            `domain.mintlify.app`. Vous pouvez le trouver à la fin de l’URL de
            votre Dashboard. Par exemple,
            `dashboard.mintlify.com/organization/domain` a pour identifiant de
            domaine `domain`.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - fp
                - messages
              properties:
                fp:
                  type: string
                  description: >-
                    Identifiant d’empreinte permettant de suivre les 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 d’associer les messages
                    suivants au même fil de conversation. 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’expéditeur du message
                      createdAt:
                        type: string
                        format: date-time
                        description: Horodatage de création du message
                      content:
                        type: string
                        description: Le contenu du message
                      annotations:
                        type: array
                        items: {}
                        description: Tableau facultatif d’annotations du 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 de types différents,
                          incluant du texte, du raisonnement, des sources et des
                          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 dans la conversation. Côté frontend,
                    vous voudrez probablement utiliser la fonction handleSubmit
                    du hook useChat fourni par le package @ai-sdk pour ajouter
                    les messages des utilisateurs 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 à
                    prendre en compte pour générer la réponse. Des valeurs plus
                    élevées offrent davantage de contexte mais peuvent augmenter
                    le temps de réponse. Recommandé : 5.
                filter:
                  type: object
                  default: null
                  properties:
                    version:
                      type: string
                      description: Filtre de version (optionnel)
                    language:
                      type: string
                      description: Filtre de langue (optionnel)
                  description: Critères de filtrage facultatifs pour la recherche
      responses:
        '200':
          description: Message généré avec succès
          content:
            application/json:
              schema:
                type: object
                description: >-
                  Objet de réponse qui diffuse des segments de flux de données
                  formatés avec le statut, les en-têtes et le contenu spécifiés.
                  Cela correspond à ce qui est attendu par l’AI SDK, tel que
                  documenté sur
                  [ai-sdk.dev/docs/ai-sdk-ui/streaming-data](https://ai-sdk.dev/docs/ai-sdk-ui/streaming-data).
                  Plutôt que d’écrire votre propre analyseur, il est recommandé
                  d’utiliser le [hook useChat d’ai-sdk, comme documenté
                  ici](https://ai-sdk.dev/docs/reference/ai-sdk-ui/use-chat#usechat).
components:
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        L’en-tête Authorization requiert un jeton Bearer. Consultez la
        [documentation sur la clé d’API de
        l’Assistant](/api/introduction#assistant-api-key) pour savoir comment
        obtenir votre clé d’API.

````