---
title: "Serveur MCP"
description: "Connectez votre documentation aux outils IA avec un serveur MCP natif."
canonical_url: "https://docus.dev/fr/ai/mcp"
---
# Serveur MCP

> Connectez votre documentation aux outils IA avec un serveur MCP natif.

## À Propos des Serveurs MCP

Le [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) est un protocole ouvert qui crée des connexions standardisées entre les applications IA et les services externes, comme la documentation.

Chaque instance Docus inclut un serveur MCP intégré, préparant votre contenu pour l'écosystème IA plus large où n'importe quel client MCP (comme Claude, Cursor, VS Code, et autres) peut se connecter à votre documentation.

### Comment Fonctionnent les Serveurs MCP

Lorsqu'un serveur MCP est connecté à un outil IA, le LLM peut décider d'utiliser les outils de votre documentation pendant la génération de réponse :

- Le LLM peut **rechercher proactivement dans votre documentation** pendant qu'il génère une réponse, pas seulement quand on lui demande explicitement.
- Le LLM détermine **quand utiliser les outils** en fonction du contexte de la conversation et de la pertinence de votre documentation.
- Chaque appel d'outil se produit **pendant le processus de génération**, permettant au LLM d'incorporer des informations en temps réel de votre documentation dans sa réponse.

Par exemple, si un utilisateur pose une question de code et que le LLM détermine que votre documentation est pertinente, il peut rechercher dans vos docs et inclure ces informations dans la réponse sans que l'utilisateur demande explicitement votre documentation.

## Accéder à Votre Serveur MCP

Votre serveur MCP est automatiquement disponible au chemin `/mcp` de l'URL de votre documentation.

<note>

Par exemple, si votre documentation est hébergée à `https://docs.example.com`, l'URL de votre serveur MCP est `https://docs.example.com/mcp`.

</note>

<note>

Le serveur MCP est documenté dans votre [`llms.txt`](https://docus.dev/fr/ai/llms) sous forme de section `MCP Server`. Un agent qui découvre votre site via `llms.txt` peut s'y connecter sans que personne ne colle l'URL dans la configuration d'un client.

</note>

<note>

Votre site publie aussi une carte de serveur MCP à `/.well-known/mcp/server-card.json`. Elle liste l'endpoint ainsi que les outils, ressources et prompts exposés par le serveur, pour qu'un agent puisse trouver le serveur sans lire la documentation.

</note>

## Désactiver le Serveur MCP

Si vous souhaitez désactiver le serveur MCP, vous pouvez le faire dans votre `nuxt.config.ts` :

```ts [nuxt.config.ts]
export default defineNuxtConfig({
  mcp: {
    enabled: false,
  },
})
```

## Outils Intégrés

Docus fournit deux outils par défaut qui permettent à n'importe quel LLM de découvrir et lire votre documentation :

### `list-pages`

Liste toutes les pages de documentation avec leurs titres, chemins et descriptions. Les assistants IA doivent appeler cet outil en premier pour découvrir le contenu disponible.

<table>
<thead>
  <tr>
    <th>
      Paramètre
    </th>
    
    <th>
      Type
    </th>
    
    <th>
      Description
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      <code>
        locale
      </code>
    </td>
    
    <td>
      string (optionnel)
    </td>
    
    <td>
      Filtrer les pages par locale
    </td>
  </tr>
</tbody>
</table>

### `get-page`

Récupère le contenu markdown complet d'une page de documentation spécifique.

<table>
<thead>
  <tr>
    <th>
      Paramètre
    </th>
    
    <th>
      Type
    </th>
    
    <th>
      Description
    </th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>
      <code>
        path
      </code>
    </td>
    
    <td>
      string (requis)
    </td>
    
    <td>
      Le chemin de la page (ex: <code>
        /fr/getting-started/installation
      </code>
      
      )
    </td>
  </tr>
</tbody>
</table>

## Configuration

Le serveur MCP Docus utilise le transport HTTP et peut être installé dans différents assistants IA.

### Claude Code

Ajoutez le serveur en utilisant la commande CLI :

```bash
claude mcp add --transport http my-docs https://docs.example.com/mcp
```

### Cursor

<install-button ide="cursor" label="Installer dans Cursor" url="https://docs.example.com/mcp">



</install-button>

Ou créez/modifiez manuellement `.cursor/mcp.json` à la racine de votre projet :

```json [.cursor/mcp.json]
{
  "mcpServers": {
    "my-docs": {
      "type": "http",
      "url": "https://docs.example.com/mcp"
    }
  }
}
```

### Visual Studio Code

Assurez-vous d'avoir les extensions GitHub Copilot et GitHub Copilot Chat installées.

<install-button ide="vscode" label="Installer dans VS Code" url="https://docs.example.com/mcp">



</install-button>

Ou créez/modifiez manuellement le fichier `.vscode/mcp.json` :

```json [.vscode/mcp.json]
{
  "servers": {
    "my-docs": {
      "type": "http",
      "url": "https://docs.example.com/mcp"
    }
  }
}
```

### Windsurf

1. Ouvrez Windsurf et naviguez vers **Settings** > **Windsurf Settings** > **Cascade**
2. Cliquez sur le bouton **Manage MCPs**, puis sélectionnez l'option **View raw config**
3. Ajoutez la configuration suivante :

```json [.codeium/windsurf/mcp_config.json]
{
  "mcpServers": {
    "my-docs": {
      "type": "http",
      "url": "https://docs.example.com/mcp"
    }
  }
}
```

### Zed

1. Ouvrez Zed et allez dans **Settings** > **Open Settings**
2. Naviguez vers le fichier de paramètres JSON
3. Ajoutez la configuration de serveur de contexte suivante :

```json [.config/zed/settings.json]
{
  "context_servers": {
    "my-docs": {
      "source": "custom",
      "command": "npx",
      "args": ["mcp-remote", "https://docs.example.com/mcp"],
      "env": {}
    }
  }
}
```

## Personnalisation

Puisque Docus utilise le module `@nuxtjs/mcp-toolkit`, vous pouvez étendre le serveur MCP avec des outils, ressources, prompts et handlers personnalisés.

### Ajouter des Outils Personnalisés

Créez de nouveaux outils dans le répertoire `server/mcp/tools/` :

```ts [server/mcp/tools/search.ts]
import { z } from 'zod'

export default defineMcpTool({
  description: 'Rechercher dans la documentation par mot-clé',
  inputSchema: {
    query: z.string().describe('La requête de recherche'),
  },
  handler: async ({ query }) => {
    const results = await searchDocs(query)
    return {
      content: [{ type: 'text', text: JSON.stringify(results) }],
    }
  },
})
```

### Ajouter des Ressources

Exposez des fichiers ou sources de données comme ressources MCP dans le répertoire `server/mcp/resources/`. La façon la plus simple est d'utiliser la propriété `file` :

```ts [server/mcp/resources/changelog.ts]
export default defineMcpResource({
  file: 'CHANGELOG.md',
  metadata: {
    description: 'Journal des modifications du projet',
  },
})
```

Cela gère automatiquement la génération d'URI, la détection du type MIME et la lecture du fichier.

### Ajouter des Prompts

Créez des prompts réutilisables pour les assistants IA dans le répertoire `server/mcp/prompts/` :

```ts [server/mcp/prompts/migration-help.ts]
import { z } from 'zod'

export default defineMcpPrompt({
  description: 'Obtenir de l\'aide pour migrer entre versions',
  inputSchema: {
    fromVersion: z.string().describe('Version actuelle'),
    toVersion: z.string().describe('Version cible'),
  },
  handler: async ({ fromVersion, toVersion }) => {
    return {
      messages: [{
        role: 'user',
        content: {
          type: 'text',
          text: `Aidez-moi à migrer de la version ${fromVersion} vers ${toVersion}. Quels sont les changements breaking et les étapes à suivre ?`,
        },
      }],
    }
  },
})
```

### Ajouter des Handlers Personnalisés

Les handlers permettent de créer des endpoints MCP séparés avec leurs propres outils, ressources et prompts. C'est utile pour exposer différentes capacités sur différentes routes.

Par exemple, vous pourriez avoir :

- `/mcp` - Serveur MCP principal de documentation
- `/mcp/migration` - Serveur MCP dédié à l'assistance à la migration

```ts [server/mcp/migration.ts]
import { z } from 'zod'

const migrationTool = defineMcpTool({
  name: 'migrate-v3-to-v4',
  description: 'Migrer du code de la version 3 vers la version 4',
  inputSchema: {
    code: z.string().describe('Le code à migrer'),
  },
  handler: async ({ code }) => {
    // Logique de migration
    return {
      content: [{ type: 'text', text: migratedCode }],
    }
  },
})

export default defineMcpHandler({
  route: '/mcp/migration',
  name: 'Assistant Migration',
  version: '1.0.0',
  tools: [migrationTool],
})
```

### Surcharger les Outils Intégrés

Vous pouvez remplacer les outils par défaut `list-pages` ou `get-page` en créant un outil avec le même nom dans votre projet :

```ts [server/mcp/tools/list-pages.ts]
import { z } from 'zod'

export default defineMcpTool({
  description: 'Implémentation personnalisée de list pages',
  inputSchema: {
    locale: z.string().optional(),
    category: z.string().optional(),
  },
  handler: async ({ locale, category }) => {
    const pages = await getCustomPageList(locale, category)
    return {
      content: [{ type: 'text', text: JSON.stringify(pages) }],
    }
  },
})
```

<tip to="https://mcp-toolkit.nuxt.dev/">

Consultez la documentation MCP Toolkit pour plus d'informations sur les outils, ressources, prompts, handlers et la configuration avancée.

</tip>


## Sitemap

See the full [sitemap](https://docus.dev/sitemap.md) for all pages.