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

# Serveur Search Model Context Protocol (MCP)

> Connectez Claude, Cursor, ChatGPT et autres outils d'IA à votre serveur MCP de recherche hébergé pour qu'ils interrogent et récupèrent votre contenu.

export const PreviewButton = ({children, href}) => {
  return <a href={href} className="text-sm font-medium text-white dark:!text-zinc-950 bg-zinc-900 hover:bg-zinc-700 dark:bg-zinc-100 hover:dark:bg-zinc-300 rounded-full px-3.5 py-1.5 not-prose">
        {children}
      </a>;
};

<div id="about-mcp-servers">
  ## À propos des serveurs MCP
</div>

Le Model Context Protocol (MCP) est un protocole ouvert qui crée des connexions standardisées entre les applications d'IA et des services externes, comme la documentation. Mintlify génère un serveur Search MCP pour votre site, en préparant votre contenu pour un écosystème d'IA plus vaste. N'importe quel client MCP comme Claude, Cursor, Goose ou ChatGPT peut se connecter à votre contenu.

Votre serveur Search MCP expose des outils permettant aux applications d'IA de rechercher et de récupérer votre contenu. Vos utilisateurs doivent connecter votre serveur Search MCP à leurs outils.

<Tip>
  Vous souhaitez plutôt permettre aux agents de modifier votre contenu au lieu de simplement le lire ? Utilisez le [serveur Admin MCP](/fr/ai/mintlify-mcp) pour un serveur MCP authentifié qui expose des outils de branching, d'édition de pages, de navigation et de `docs.json` aux agents de confiance.
</Tip>

<div id="how-mcp-servers-work">
  ### Fonctionnement des serveurs MCP
</div>

Lorsqu'une application d'IA se connecte à votre serveur Search MCP, elle peut rechercher dans votre contenu et récupérer des pages complètes au format Markdown en réponse à la requête d'un utilisateur. Cela évite de s'appuyer sur des informations issues des données d'entraînement ou de recherches web génériques. Votre serveur Search MCP donne accès à tout le contenu indexé de votre site Mintlify.

* Les applications d'IA peuvent rechercher de manière proactive dans votre contenu pendant qu'elles génèrent une réponse, même s'il ne leur a pas été explicitement demandé d'y rechercher une réponse.
* Les applications d'IA déterminent quand utiliser les outils disponibles en fonction du contexte de la conversation et de la pertinence de votre contenu.
* Chaque appel d'outil a lieu pendant le processus de génération, de sorte que l'application d'IA utilise des informations à jour de votre site pour générer sa réponse.

<Tip>
  Certains outils d'IA comme Claude prennent en charge à la fois MCP et les skills. MCP donne accès à votre contenu, tandis que les skills indiquent aux agents comment utiliser ce contenu efficacement. Ils sont complémentaires et la connexion de votre serveur MCP donne aux agents accès aux deux.
</Tip>

<div id="mcp-tools">
  ### Outils MCP
</div>

Votre serveur Search MCP fournit deux outils que les agents peuvent utiliser :

* **Search** : Recherche sur votre site pour trouver du contenu pertinent, en renvoyant des extraits avec des titres et des liens. Utilisez cet outil pour découvrir des informations ou trouver des pages correspondant à une requête.
* **Query docs filesystem** : Lit et parcourt le système de fichiers virtuel de votre site à l'aide de commandes de type shell. Utilisez cet outil pour parcourir et récupérer du contenu, ou extraire des sections spécifiques — y compris des lectures par lots sur plusieurs pages en un seul appel.

Les agents déterminent quand utiliser chaque outil en fonction du contexte de la conversation. Par exemple, un agent peut d'abord rechercher sur votre site pour trouver des pages pertinentes, puis utiliser l'outil query docs filesystem pour lire le contenu complet des résultats les plus pertinents.

<div id="mcp-resources">
  ### Ressources MCP
</div>

Votre serveur Search MCP expose également vos [fichiers skill.md](/fr/ai/skillmd) en tant que ressources MCP. Les agents connectés à votre serveur Search MCP peuvent découvrir et accéder à vos fichiers de skill sans les installer séparément.

Les ressources `Skill.md` apparaissent dans la liste des ressources du serveur Search MCP et contiennent les descriptions de capacités que Mintlify génère ou que vous définissez dans vos [fichiers de skill personnalisés](/fr/ai/skillmd#custom-skill-files).

<div id="search-parameters">
  ### Paramètres de recherche
</div>

L’outil de recherche MCP prend en charge des paramètres facultatifs que les applications d’IA utilisent pour contrôler et affiner les résultats de recherche.

* **`version`** : Filtre les résultats pour une version spécifique du site. Par exemple, `'v0.7'`. Disponible uniquement lorsque votre site comporte plusieurs versions. Ne renvoie que le contenu balisé avec la version spécifiée ou le contenu disponible dans toutes les versions.
* **`language`** : Filtre les résultats pour un code de langue spécifique. Par exemple, `'en'`, `'zh'` ou `'es'`. Disponible uniquement lorsque votre site comporte plusieurs langues. Ne renvoie que le contenu dans la langue spécifiée ou le contenu disponible dans toutes les langues.

Les applications d’IA déterminent quand appliquer ces paramètres en fonction du contexte de la requête de l’utilisateur. Par exemple, si un utilisateur pose une question sur une version spécifique d’une API, l’application d’IA peut appliquer automatiquement le filtre approprié pour fournir des résultats plus pertinents.

<div id="mcp-compared-to-web-search">
  ### Search MCP par rapport à la recherche sur le web
</div>

Les outils d'IA peuvent rechercher sur le web, mais le Search MCP offre des avantages spécifiques.

* **Accès direct à la source** : La recherche sur le web dépend de ce que les moteurs de recherche ont indexé, ce qui peut être obsolète ou incomplet. Le Search MCP interroge directement votre contenu indexé le plus à jour.
* **Flux de travail intégré** : MCP permet à l'IA de rechercher pendant la génération de la réponse plutôt que d'effectuer une recherche web séparée.
* **Aucun bruit de recherche** : Les algorithmes de référencement (SEO) et de classement influencent les résultats de la recherche sur le web. MCP accède directement à votre contenu.

<div id="access-your-mcp-server">
  ## Accéder à votre serveur Search MCP
</div>

Mintlify génère un serveur Search MCP pour votre site et l'héberge au chemin `/mcp` de l'URL de votre site. Par exemple, le serveur Search MCP de Mintlify est disponible à l'adresse `https://mintlify.com/docs/mcp`.

* Pour un contenu public, votre serveur Search MCP est accessible à tous. Il recherche dans toutes les pages publiques indexées.
* Pour un contenu avec authentification partielle, où certaines pages sont publiques et d'autres nécessitent une connexion, vous devez activer votre serveur Search MCP avant que les utilisateurs puissent y accéder. Les utilisateurs non authentifiés peuvent rechercher dans le contenu public. Les utilisateurs qui s'authentifient peuvent rechercher dans tout le contenu auquel ils ont l'autorisation d'accéder en fonction de leurs [groupes d'utilisateurs](/fr/deploy/authentication-setup).
* Pour un contenu où toutes les pages requièrent une authentification, vous devez activer votre serveur Search MCP avant qu'il soit accessible aux utilisateurs. Les utilisateurs doivent s'authentifier avant de se connecter à votre serveur Search MCP. Votre serveur Search MCP recherche uniquement dans le contenu auquel chaque utilisateur a accès en fonction de ses [groupes d'utilisateurs](/fr/deploy/authentication-setup).

Vous pouvez afficher et copier l'URL de votre serveur Search MCP sur la [page du serveur MCP](https://dashboard.mintlify.com/products/mcp) dans votre Dashboard.

<Frame>
  <img src="https://mintcdn.com/smartac-mintlify-f05786c0/FBQJBHokyIa03ZEa/images/mcp/mcp-server-page-light.png?fit=max&auto=format&n=FBQJBHokyIa03ZEa&q=85&s=da74b60eb6431937a2642bf8774e47e1" alt="Page du serveur MCP dans le Dashboard." className="block dark:hidden" width="2066" height="972" data-path="images/mcp/mcp-server-page-light.png" />

  <img src="https://mintcdn.com/smartac-mintlify-f05786c0/FBQJBHokyIa03ZEa/images/mcp/mcp-server-page-dark.png?fit=max&auto=format&n=FBQJBHokyIa03ZEa&q=85&s=256a7aacc81a848e60f5403f513fead6" alt="Page du serveur MCP dans le Dashboard." className="hidden dark:block" width="2068" height="974" data-path="images/mcp/mcp-server-page-dark.png" />
</Frame>

<Note>
  Les serveurs Search MCP utilisent les chemins `/mcp` et `/authed/mcp`. Les autres éléments de navigation ne peuvent pas utiliser ces chemins.
</Note>

<div id="discovery-endpoint">
  ### Point de terminaison de découverte
</div>

Mintlify héberge un document de découverte à l'adresse `/.well-known/mcp` pour permettre aux agents et aux outils de localiser votre serveur Search MCP sans configuration préalable.

`GET /.well-known/mcp` renvoie un document JSON décrivant votre serveur Search MCP :

```json theme={null}
{
  "version": "1.0.0",
  "transport": "http",
  "url": "https://your-docs.com/mcp",
  "servers": [
    {
      "name": "public",
      "url": "https://your-docs.com/mcp",
      "transport": "http",
      "authentication": "none"
    },
    {
      "name": "authenticated",
      "url": "https://your-docs.com/authed/mcp",
      "transport": "http",
      "authentication": "oauth2"
    }
  ]
}
```

| Champ                      | Description                                                                                                                                                        |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `version`                  | La version du serveur MCP.                                                                                                                                         |
| `transport`                | Le protocole de transport. Toujours `http`.                                                                                                                        |
| `url`                      | L’URL publique par défaut du serveur MCP.                                                                                                                          |
| `servers`                  | Serveurs MCP disponibles. Inclut toujours une entrée `public`. Lorsque l’authentification est activée sur votre site, inclut également une entrée `authenticated`. |
| `servers[].name`           | Identifiant de l’entrée du serveur.                                                                                                                                |
| `servers[].authentication` | Méthode d’authentification de l’entrée du serveur.                                                                                                                 |

Pour la compatibilité avec les agents, le même document de découverte est également disponible à l’adresse `/.well-known/mcp.json`. Mintlify expose en plus une carte de serveur MCP à `/.well-known/mcp/server-card.json` et une liste de cartes de serveur à `/.well-known/mcp/server-cards.json`. Tous les endpoints de découverte sont servis automatiquement et ne nécessitent aucune configuration.

<div id="server-card-endpoints">
  #### Endpoints des cartes de serveur
</div>

`GET /.well-known/mcp/server-card.json` renvoie une seule carte de serveur décrivant votre serveur MCP. `GET /.well-known/mcp/server-cards.json` renvoie un tableau `servers` contenant une carte par endpoint disponible (inclut toujours une carte de serveur publique, ainsi qu’une carte de serveur authentifiée lorsque l’authentification est activée).

Chaque carte de serveur inclut les champs de découverte standards et un tableau `tools` qui décrit les outils MCP annoncés par le serveur. Utilisez-le pour pré-remplir les métadonnées des outils dans les clients MCP sans avoir à effectuer un appel `initialize` au serveur.

```json theme={null}
{
  "name": "your-docs-search",
  "version": "1.0.0",
  "url": "https://your-docs.com/mcp",
  "transport": "http",
  "description": "Search and retrieve your documentation",
  "capabilities": {
    "tools": true,
    "resources": true
  },
  "authentication": "none",
  "tools": [
    {
      "name": "search_your_docs",
      "title": "Search documentation",
      "description": "Search across your documentation site.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": { "type": "string", "description": "Search query" }
        },
        "required": ["query"]
      },
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "idempotentHint": true,
        "openWorldHint": false
      }
    }
  ]
}
```

| Champ                 | Description                                                                                                                                                                     |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `tools[].name`        | Nom de l’outil annoncé via MCP. Les noms d’outils sont spécifiques à chaque site ; utilisez donc la valeur renvoyée par l’endpoint de découverte plutôt que de la coder en dur. |
| `tools[].title`       | Titre lisible facultatif pour l’outil.                                                                                                                                          |
| `tools[].description` | Description lisible de ce que fait l’outil.                                                                                                                                     |
| `tools[].inputSchema` | JSON Schema des paramètres d’entrée de l’outil.                                                                                                                                 |
| `tools[].annotations` | [Annotations d’outils MCP](https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-annotations) facultatives qui décrivent le comportement de l’outil.       |

Les outils intégrés de recherche et de requête du système de fichiers de documentation sont annoncés comme étant en lecture seule et non destructifs, avec les annotations suivantes :

* `readOnlyHint: true` — l’outil ne modifie aucun état.
* `destructiveHint: false` — l’outil n’a aucun effet de bord destructeur.
* `idempotentHint: true` — des appels répétés avec les mêmes arguments renvoient des résultats équivalents.
* `openWorldHint: false` — l’outil opère sur votre documentation indexée plutôt que sur le web ouvert.

Les clients MCP peuvent utiliser ces annotations pour présenter des informations de sécurité aux utilisateurs ou pour permettre aux outils en lecture seule de s’exécuter sans approbation explicite.

<div id="enable-authenticated-mcp">
  ### Activer le MCP avec authentification
</div>

Si votre site nécessite une authentification, votre serveur Search MCP demande aux utilisateurs de s'authentifier avant de se connecter. Lorsqu'un utilisateur ajoute l'URL de votre serveur MCP à son outil d'IA, il doit se connecter avec ses identifiants existants. Après l'authentification, une redirection le renvoie vers son outil. Le serveur MCP ne renvoie que le contenu auquel chaque utilisateur est autorisé à accéder en fonction de ses [groupes d'utilisateurs](/fr/deploy/authentication-setup).

Si votre site utilise une authentification partielle avec des pages publiques et des pages protégées, vous disposez de deux endpoints de serveur Search MCP :

* `/mcp` : Ne nécessite pas d’authentification. Renvoie uniquement le contenu public. Partagez-le avec les utilisateurs qui ont besoin d’accéder au contenu public.
* `/authed/mcp` : Nécessite toujours une authentification. Renvoie le contenu en fonction des permissions de chaque utilisateur selon ses [groupes d’utilisateurs](/fr/deploy/authentication-setup). Partagez-le avec les utilisateurs qui ont besoin d’accéder au contenu protégé.

L’endpoint `/authed/mcp` utilise son propre flux OAuth à `/authed/mcp/oauth/*`. Les domaines de redirection configurés pour votre serveur MCP s’appliquent à la fois à `/mcp` et à `/authed/mcp`.

Par défaut, votre serveur MCP est uniquement disponible pour les outils localhost. Pour autoriser les outils web à se connecter, ajoutez les domaines de redirection des outils d’IA. Un domaine de redirection est le nom d’hôte qu’un outil d’IA utilise une fois l’authentification terminée, comme `claude.ai` ou `app.cursor.ai`. Les outils d’IA de vos utilisateurs ne peuvent pas finaliser l’authentification si leur domaine de redirection ne figure pas dans cette liste.

<Steps>
  <Step title="Activer le MCP avec authentification dans votre Dashboard">
    1. Accédez à la [page du serveur MCP](https://dashboard.mintlify.com/products/mcp) dans votre Dashboard.
    2. Cliquez sur le bouton bascule **Enable MCP Server**.
  </Step>

  <Step title="Ajouter des domaines de redirection">
    Ajoutez les domaines de redirection des outils d’IA auxquels vous souhaitez donner accès à vos utilisateurs. Les outils d’IA de vos utilisateurs ne peuvent pas finaliser l’authentification si leur domaine de redirection ne figure pas dans cette liste. Les domaines de redirection courants incluent `claude.ai` et `vscode.dev/redirect`.

    Par défaut, les domaines de redirection utilisent `https://`. Pour autoriser un schéma de protocole personnalisé, incluez le protocole complet dans l’entrée du domaine. Par exemple, un callback d’application native comme `myapp://callback`. Mintlify bloque toujours les protocoles dangereux tels que `javascript:`, `data:` et `file:`.

    Les adresses loopback (`localhost`, `127.0.0.1`) sont toujours approuvées et n’ont pas besoin d’être ajoutées.
  </Step>
</Steps>

<div id="client-credentials">
  ### Identifiants client
</div>

Les identifiants client vous permettent de vous connecter à votre serveur MCP authentifié de manière programmatique, sans connexion via un navigateur. Utilisez les identifiants client pour les intégrations côté serveur, les pipelines CI/CD, les workflows automatisés et tout environnement dans lequel un utilisateur ne peut pas effectuer un flux OAuth interactif.

Les identifiants client s'authentifient auprès de l'endpoint `/authed/mcp` et renvoient l'ensemble du contenu des pages publiques et des pages authentifiées qui ne sont pas restreintes à des groupes spécifiques.

<Note>
  Les identifiants client MCP sont distincts des [clés d'API Mintlify](/fr/api/introduction). Les clés d'API admin et assistant authentifient les requêtes à l'API REST de Mintlify et ne peuvent pas être utilisées pour s'authentifier auprès de votre serveur MCP. Pour appeler votre serveur MCP de manière programmatique, créez un identifiant client sur la [page du serveur MCP](https://dashboard.mintlify.com/products/mcp) et échangez-le contre un jeton d'accès en suivant les étapes ci-dessous.
</Note>

<Steps>
  <Step title="Créer un identifiant client">
    1. Accédez à la [page du serveur MCP](https://dashboard.mintlify.com/products/mcp) dans votre Dashboard.
    2. Dans la section **Client Credentials**, sélectionnez **Create credential**.
    3. Saisissez un libellé pour l'identifiant afin d'en identifier l'usage.
    4. Copiez le **client ID** et le **client secret**. Le client secret n'est affiché qu'une seule fois. Vous ne pourrez pas le récupérer ultérieurement.
  </Step>

  <Step title="Échanger les identifiants contre un jeton d'accès">
    Envoyez une requête POST à l'endpoint de jeton de votre serveur MCP avec votre client ID et votre secret. Votre endpoint de jeton se trouve au chemin `/authed/mcp/oauth/token` de l'URL de votre site.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://your-docs.com/authed/mcp/oauth/token \
        -H 'Content-Type: application/x-www-form-urlencoded' \
        -d 'grant_type=client_credentials&client_id=CLIENT_ID&client_secret=CLIENT_SECRET'
      ```

      ```bash cURL (Basic Auth) theme={null}
      curl -X POST https://your-docs.com/authed/mcp/oauth/token \
        -H 'Content-Type: application/x-www-form-urlencoded' \
        -H 'Authorization: Basic BASE64_CLIENT_ID_COLON_SECRET' \
        -d 'grant_type=client_credentials'
      ```
    </CodeGroup>

    La réponse inclut un jeton d'accès et un jeton de rafraîchissement :

    ```json theme={null}
    {
      "access_token": "eyJhbGciOi...",
      "token_type": "Bearer",
      "expires_in": 1209600,
      "refresh_token": "eyJhbGciOi...",
      "scope": "mcp:search"
    }
    ```

    Les jetons d'accès expirent au bout du nombre de secondes spécifié dans `expires_in`. Utilisez le `refresh_token` pour obtenir un nouveau jeton d'accès lorsque le jeton actuel expire.
  </Step>

  <Step title="Se connecter au serveur MCP">
    Utilisez le jeton d'accès comme bearer token lors de la connexion à l'endpoint `/authed/mcp`.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://your-docs.com/authed/mcp \
        -H 'Authorization: Bearer ACCESS_TOKEN' \
        -H 'Content-Type: application/json' \
        -H 'Accept: application/json, text/event-stream' \
        -d '{
          "jsonrpc": "2.0",
          "id": 1,
          "method": "initialize",
          "params": {
            "protocolVersion": "2025-03-26",
            "capabilities": {},
            "clientInfo": {"name": "my-integration", "version": "1.0.0"}
          }
        }'
      ```

      ```bash Claude Code theme={null}
      claude mcp add --transport http \
        --header "Authorization: Bearer ACCESS_TOKEN" \
        my-docs https://your-docs.com/authed/mcp
      ```
    </CodeGroup>
  </Step>
</Steps>

<div id="managing-client-credentials">
  #### Gestion des identifiants client
</div>

Vous pouvez gérer vos identifiants client depuis la [page du serveur MCP](https://dashboard.mintlify.com/products/mcp) dans votre Dashboard.

* **Supprimer un identifiant** pour révoquer définitivement l'accès. Cette action est irréversible.

<Warning>
  Traitez les client secrets comme des mots de passe. Ne les intégrez pas dans le contrôle de version et ne les exposez pas dans du code côté client. Utilisez des variables d'environnement ou un gestionnaire de secrets pour les stocker.
</Warning>

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

Pour protéger la disponibilité, Mintlify applique des limites de débit aux serveurs MCP.

| Portée                                              | Limite                    | Description                                                                                                                            |
| :-------------------------------------------------- | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------------- |
| Par utilisateur (adresse IP)                        | 5 000 requêtes par heure  | Limite la fréquence à laquelle un même utilisateur peut interroger la configuration de votre serveur MCP.                              |
| Search par site (domain)                            | 10 000 requêtes par heure | Limite le nombre total d'appels à l'outil de recherche effectués par tous les utilisateurs de votre serveur MCP.                       |
| Query docs filesystem par site (domain)             | 10 000 requêtes par heure | Limite le nombre total d'appels à l'outil query docs filesystem effectués par tous les utilisateurs de votre serveur MCP.              |
| Search authentifié par site (domain)                | 5 000 requêtes par heure  | Limite le nombre total d'appels authentifiés à l'outil de recherche effectués par tous les utilisateurs de votre serveur MCP.          |
| Query docs filesystem authentifié par site (domain) | 5 000 requêtes par heure  | Limite le nombre total d'appels authentifiés à l'outil query docs filesystem effectués par tous les utilisateurs de votre serveur MCP. |

<div id="content-filtering-and-indexing">
  ## Filtrage du contenu et indexation
</div>

Votre serveur MCP recherche le contenu que Mintlify indexe à partir du référentiel de votre projet. Le traitement des fichiers et l'indexation pour la recherche déterminent quel contenu est disponible via votre serveur MCP.

Pour les sites nécessitant une authentification, votre serveur MCP indexe les [pages publiques](/fr/deploy/authentication-setup#make-pages-public) ainsi que toutes les pages auxquelles un utilisateur authentifié a l'autorisation d'accéder en fonction de ses [groupes d'utilisateurs](/fr/deploy/authentication-setup#restrict-pages-to-specific-user-groups).

Pour les sites avec authentification partielle, les utilisateurs non authentifiés peuvent rechercher dans les pages publiques. Les utilisateurs authentifiés peuvent rechercher dans les pages publiques ainsi que dans toutes les pages auxquelles ils ont l'autorisation d'accéder en fonction de leurs groupes d'utilisateurs.

<div id="file-processing-with-mintignore">
  ### Traitement des fichiers avec `.mintignore`
</div>

Si des fichiers correspondent aux modèles définis dans [.mintignore](/fr/organize/mintignore), Mintlify ne les traite pas et ne les indexe pas. Ces fichiers ne sont pas disponibles via votre serveur MCP.

<div id="search-indexing-with-docsjson">
  ### Indexation pour la recherche avec `docs.json`
</div>

Par défaut, Mintlify n'indexe, pour la recherche via votre serveur MCP, que les pages incluses dans la navigation de votre `docs.json`.

Mintlify exclut les [pages masquées](/fr/organize/hidden-pages) (pages qui ne figurent pas dans votre navigation) de l'index de recherche, sauf si vous choisissez d'indexer toutes les pages. Pour inclure les pages masquées dans les résultats de recherche de votre serveur MCP, ajoutez la propriété `seo.indexing` à votre `docs.json`.

```json theme={null}
"seo": {
    "indexation": "all"
}
```

Pour exclure une page donnée de l'indexation par les moteurs de recherche, ajoutez `noindex: true` à son frontmatter.

```mdx theme={null}
---
title: "Page cachée"
description: "Cette page ne figure pas dans la navigation et n'est pas accessible via la recherche."
noindex: true
---
```

<div id="use-your-mcp-server">
  ## Utiliser votre serveur MCP
</div>

Vos utilisateurs doivent connecter votre serveur MCP à leurs outils d'IA préférés.

1. Rendez l'URL de votre serveur MCP publique.
2. Les utilisateurs copient l'URL de votre serveur MCP et l'ajoutent à leurs outils.
3. Les utilisateurs accèdent à votre contenu depuis leurs outils.

Voici quelques façons d'aider vos utilisateurs à se connecter à votre serveur MCP :

<Tabs>
  <Tab title="Menu contextuel">
    Ajoutez des options dans le [menu contextuel](/fr/ai/contextual-menu) pour permettre à vos utilisateurs de se connecter à votre serveur MCP depuis n'importe quelle page de votre site.

    | Option                                    | Identifiant | Description                                                               |
    | :---------------------------------------- | :---------- | :------------------------------------------------------------------------ |
    | **Copier l'URL du serveur MCP**           | `mcp`       | Copie l'URL de votre serveur MCP dans le presse‑papiers de l'utilisateur. |
    | **Copier la commande d'installation MCP** | `add-mcp`   | Copie la commande `npx add-mcp` pour installer le serveur MCP.            |
    | **Se connecter à Cursor**                 | `cursor`    | Installe votre serveur MCP dans Cursor.                                   |
    | **Se connecter à VS Code**                | `vscode`    | Installe votre serveur MCP dans VS Code.                                  |
  </Tab>

  <Tab title="Claude">
    <Steps>
      <Step title="Obtenez l'URL de votre serveur MCP">
        Accédez à votre [Dashboard](https://dashboard.mintlify.com/products/mcp) et trouvez l'URL de votre serveur MCP.
      </Step>

      <Step title="Publiez l'URL de votre serveur MCP pour vos utilisateurs">
        Créez un guide pour vos utilisateurs qui inclut l'URL de votre serveur MCP et les étapes pour le connecter à Claude.

        1. Accédez à la page [Connectors](https://claude.ai/settings/connectors) dans les paramètres de Claude.
        2. Sélectionnez **Add custom connector**.
        3. Ajoutez le nom et l'URL de votre serveur MCP.
        4. Sélectionnez **Add**.
        5. Lors de l'utilisation de Claude, sélectionnez le bouton des pièces jointes (l'icône « plus »).
        6. Sélectionnez votre serveur MCP.
      </Step>
    </Steps>

    Voir la [documentation Model Context Protocol](https://modelcontextprotocol.io/docs/tutorials/use-remote-mcp-server#connecting-to-a-remote-mcp-server) pour plus de détails.
  </Tab>

  <Tab title="Claude Code">
    <Steps>
      <Step title="Obtenez l'URL de votre serveur MCP">
        Accédez à votre [Dashboard](https://dashboard.mintlify.com/products/mcp) et trouvez l'URL de votre serveur MCP.
      </Step>

      <Step title="Publiez l'URL de votre serveur MCP pour vos utilisateurs">
        Créez un guide pour vos utilisateurs qui inclut l'URL de votre serveur MCP et la commande pour le connecter à Claude Code.

        ```bash theme={null}
        claude mcp add --transport http <name> <url>
        ```
      </Step>
    </Steps>

    Voir la [documentation Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#installing-mcp-servers) pour plus de détails.
  </Tab>

  <Tab title="Cursor">
    <Steps>
      <Step title="Obtenez l'URL de votre serveur MCP">
        Accédez à votre [Dashboard](https://dashboard.mintlify.com/products/mcp) et trouvez l'URL de votre serveur MCP.
      </Step>

      <Step title="Publiez l'URL de votre serveur MCP pour vos utilisateurs">
        Créez un guide pour vos utilisateurs qui inclut l'URL de votre serveur MCP et les étapes pour le connecter à Cursor.

        1. Utilisez <kbd>Command</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> sous Windows) pour ouvrir la palette de commandes.
        2. Recherchez « Open MCP settings ».
        3. Sélectionnez **Add custom MCP**. Cela ouvre le fichier `mcp.json`.
        4. Dans `mcp.json`, configurez votre serveur :

        ```json theme={null}
        {
          "mcpServers": {
            "<your-mcp-server-name>": {
              "url": "<your-mcp-server-url>"
            }
          }
        }
        ```
      </Step>
    </Steps>

    Voir la [documentation Cursor](https://docs.cursor.com/en/context/mcp#installing-mcp-servers) pour plus de détails.
  </Tab>

  <Tab title="VS Code">
    <Steps>
      <Step title="Obtenez l'URL de votre serveur MCP">
        Accédez à votre [Dashboard](https://dashboard.mintlify.com/products/mcp) et trouvez l'URL de votre serveur MCP.
      </Step>

      <Step title="Publiez l'URL de votre serveur MCP pour vos utilisateurs">
        Créez un guide pour vos utilisateurs qui inclut l'URL de votre serveur MCP et les étapes pour le connecter à VS Code.

        1. Créez un fichier `.vscode/mcp.json`.
        2. Dans `mcp.json`, configurez votre serveur :

        ```json theme={null}
        {
          "servers": {
            "<your-mcp-server-name>": {
              "type": "http",
              "url": "<your-mcp-server-url>"
            }
          }
        }
        ```
      </Step>
    </Steps>

    Voir la [documentation VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) pour plus de détails.
  </Tab>
</Tabs>

<div id="example-connect-to-the-mintlify-mcp-server">
  ### Exemple : connexion au serveur MCP de Mintlify
</div>

Connectez-vous au serveur MCP de Mintlify pour rechercher sur ce site de documentation depuis votre outil d'IA préféré. Vous obtiendrez ainsi des réponses plus précises sur l'utilisation de Mintlify dans votre environnement local, et vous verrez comment aider vos utilisateurs à se connecter à votre serveur MCP.

<Tabs>
  <Tab title="Menu contextuel">
    En haut de cette page, ouvrez le menu contextuel et choisissez **Connect to Cursor** ou **Connect to VS Code** pour connecter le serveur MCP de Mintlify à l'IDE de votre choix.
  </Tab>

  <Tab title="Claude">
    Pour utiliser le serveur MCP de Mintlify avec Claude :

    <Steps>
      <Step title="Ajouter le serveur MCP de Mintlify à Claude">
        1. Accédez à la page [Connectors](https://claude.ai/settings/connectors) dans les paramètres de Claude.
        2. Sélectionnez **Add custom connector**.
        3. Ajoutez le serveur MCP de Mintlify :

        * Name: `Mintlify`
        * URL: `https://mintlify.com/docs/mcp`

        4. Sélectionnez **Add**.
      </Step>

      <Step title="Accéder au serveur MCP dans votre chat">
        1. Dans Claude, cliquez sur le bouton des pièces jointes (l'icône "plus").
        2. Sélectionnez le serveur MCP de Mintlify.
        3. Posez à Claude une question sur Mintlify.
      </Step>
    </Steps>

    Consultez la [documentation Model Context Protocol](https://modelcontextprotocol.io/docs/tutorials/use-remote-mcp-server#connecting-to-a-remote-mcp-server) pour plus de détails.
  </Tab>

  <Tab title="Claude Code">
    Pour utiliser le serveur MCP de Mintlify avec Claude Code, exécutez la commande suivante :

    ```bash theme={null}
    claude mcp add --transport http Mintlify https://mintlify.com/docs/mcp
    ```

    Testez la connexion en exécutant :

    ```bash theme={null}
    claude mcp list
    ```

    Consultez la [documentation Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#installing-mcp-servers) pour plus de détails.
  </Tab>

  <Tab title="Cursor">
    <PreviewButton href="cursor://anysphere.cursor-deeplink/mcp/install?name=mintlify&config=eyJ1cmwiOiJodHRwczovL21pbnRsaWZ5LmNvbS9kb2NzL21jcCJ9">Installer dans Cursor</PreviewButton>

    Pour connecter le serveur MCP de Mintlify à Cursor, cliquez sur le bouton **Installer dans Cursor**. Ou, pour le connecter manuellement, suivez ces étapes :

    <Steps>
      <Step title="Ouvrir les paramètres MCP">
        1. Utilisez <kbd>Command</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> sous Windows) pour ouvrir la palette de commandes.
        2. Recherchez « Open MCP settings ».
        3. Sélectionnez **Add custom MCP**. Cela ouvre le fichier `mcp.json`.
      </Step>

      <Step title="Configurer le serveur MCP de Mintlify">
        Dans `mcp.json`, ajoutez :

        ```json theme={null}
        {
          "mcpServers": {
            "Mintlify": {
              "url": "https://mintlify.com/docs/mcp"
            }
          }
        }
        ```
      </Step>

      <Step title="Tester la connexion">
        Dans le chat de Cursor, demandez « What tools do you have available? ». Cursor doit afficher le serveur MCP de Mintlify comme outil disponible.
      </Step>
    </Steps>

    Voir [Installing MCP servers](https://docs.cursor.com/en/context/mcp#installing-mcp-servers) dans la documentation de Cursor pour plus de détails.
  </Tab>

  <Tab title="VS Code">
    <PreviewButton href="https://vscode.dev/redirect/mcp/install?name=mintlify&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmintlify.com%2Fdocs%2Fmcp%22%7D">Installer dans VS Code</PreviewButton>

    Pour connecter le serveur MCP de Mintlify à VS Code, cliquez sur le bouton **Installer dans VS Code**. Ou, pour le connecter manuellement, créez un fichier `.vscode/mcp.json` et ajoutez :

    ```json theme={null}
    {
      "servers": {
        "Mintlify": {
          "type": "http",
          "url": "https://mintlify.com/docs/mcp"
        }
      }
    }
    ```

    Consultez la [documentation VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) pour plus de détails.
  </Tab>
</Tabs>

<div id="using-multiple-mcp-servers">
  ### Utiliser plusieurs serveurs MCP
</div>

Les utilisateurs peuvent connecter plusieurs serveurs MCP à leurs outils d’IA. Les serveurs MCP connectés ne consomment pas de contexte tant que l’IA n’appelle pas un outil de recherche. L’IA décide quand effectuer une recherche en fonction de la pertinence de la requête ; elle ne recherche donc pas sur chaque serveur connecté pour chaque question.

Lorsque l’IA effectue une recherche, chaque requête renvoie plusieurs résultats qui s’ajoutent au contexte de la conversation. Si l’IA interroge plusieurs serveurs pour une seule question, cela peut consommer une quantité importante de contexte.

Bonnes pratiques pour utiliser plusieurs serveurs MCP :

* Connectez uniquement les serveurs MCP pertinents pour votre travail actuel.
* Soyez précis dans vos prompts afin que l’IA interroge le serveur le plus pertinent.
* Déconnectez les serveurs que vous n’utilisez pas activement pour réduire l’utilisation potentielle du contexte.