mintlify__docs/fr/discovery-openapi.json

{
  "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)."
                }
              }
            }
          }
        }
      }
    },
    "/search/{domain}": {
      "post": {
        "x-mint": {
          "mcp": {
            "enabled": true
          }
        },
        "summary": "Rechercher dans la documentation",
        "description": "Effectuez des recherches sémantiques et par mots-clés dans votre documentation, avec filtrage et pagination configurables.",
        "parameters": [
          {
            "name": "domain",
            "in": "path",
            "required": true,
            "schema": {
              "type": "string"
            },
            "description": "L’identifiant de domaine à partir de 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": [
                  "query"
                ],
                "properties": {
                  "query": {
                    "type": "string",
                    "description": "La requête de recherche à effectuer sur le contenu de votre documentation."
                  },
                  "pageSize": {
                    "type": "number",
                    "default": 10,
                    "description": "Nombre de résultats de recherche à renvoyer. La valeur par défaut est 10 si non spécifié."
                  },
                  "filter": {
                    "type": "object",
                    "description": "Paramètres de filtrage facultatifs pour affiner les résultats de recherche.",
                    "properties": {
                      "version": {
                        "type": "string",
                        "description": "Filtrez les résultats par version de la documentation."
                      },
                      "language": {
                        "type": "string",
                        "description": "Filtrer les résultats par langue du contenu."
                      }
                    }
                  }
                }
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Résultats de recherche",
            "content": {
              "application/json": {
                "schema": {
                  "type": "array",
                  "items": {
                    "type": "object",
                    "properties": {
                      "content": {
                        "type": "string",
                        "description": "Le contenu correspondant dans votre documentation."
                      },
                      "path": {
                        "type": "string",
                        "description": "Le chemin ou l’URL vers le document source."
                      },
                      "metadata": {
                        "type": "object",
                        "description": "Des métadonnées supplémentaires relatives au résultat de recherche."
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "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."
      }
    }
  }
}