# Créer un message de l’Assistant (v1) (/fr/api/assistant/create-assistant-message)

<!-- agent-signals: reading_time_min: 7 · est_tokens: 5320 · updated: 2026-07-30 -->

<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` [#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
    npm i ai@^4.1.15
    ```
  </Step>

  <Step title="Utiliser le hook">
    ```tsx
    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 [#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

`POST /v1/assistant/{domain}/message`

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

Authentifiez-vous avec une clé d'API assistant.

## OpenAPI

```json
{
  "security": [
    {
      "bearerAuth": []
    }
  ],
  "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."
          }
        }
      }
    }
  }
}
```
