---
title: "Connecter un serveur MCP | mcp.tc"
description: "Ajoutez un serveur MCP à Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code et d’autres clients : comptes, clés API et serveurs locaux expliqués."
url: "https://mcp.tc/fr/docs/connect"
markdown: "https://mcp.tc/fr/docs/connect.md"
lang: "fr"
---

# Connecter un serveur MCP

Comment ajouter un serveur de mcp.tc à Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code et d’autres clients. Chaque étape utilise l’URL ou le paquet du serveur lui-même, comme les boutons de chaque fiche.

## Avant de commencer

Chaque fiche indique en haut de sa page avec quoi vous connecter : l’URL du serveur pour un serveur distant, ou la commande d’installation pour un serveur local. Quand nous n’avons pu confirmer ni l’une ni l’autre, elle renvoie aux instructions du projet. Les badges sous le nom indiquent ce dont le serveur a besoin.

Les étapes ci-dessous sont celles qu’affiche la section **Configuration** de chaque fiche, ici pour quatre serveurs d’exemple. Choisissez-en un avec les onglets ; le choix s’applique à tous les clients de cette page.

- **Sans compte** : [DeepWiki, vérifié](https://mcp.tc/fr/i/deepwiki), un serveur distant que tout le monde peut utiliser, à `https://mcp.deepwiki.com/mcp`.
- **Compte requis** : [Notion, vérifié](https://mcp.tc/fr/i/notion), un serveur distant qui vous demande de vous connecter avec OAuth.
- **Clé API** : un serveur fictif sur `mcp.example.com` qui demande une clé dans l’en-tête `Authorization`.
- **Local** : [Memory, vérifié](https://mcp.tc/fr/i/memory), que votre client lance avec `npx -y @modelcontextprotocol/server-memory`.

Sur la page d’une fiche, les mêmes étapes sont déjà remplies pour ce serveur, et les boutons **Ajouter à** font la première étape pour vous.

Depuis un terminal, [mcp-tc](https://mcp.tc/fr/cli), notre outil open source en ligne de commande, suit les mêmes étapes. `npx mcp-tc add deepwiki --client cursor` ajoute le serveur à votre client comme l’indique la section **Configuration** : il affiche la commande qu’il va lancer ou la modification de votre fichier de configuration, vous demande d’abord votre accord, sauvegarde le fichier de configuration avant de l’écrire et garde les clés API sur votre ordinateur. `npx mcp-tc scan` recherche sur mcp.tc les serveurs présents dans les configurations de vos clients. Pour chaque serveur, il n’envoie qu’une adresse : son URL https sans identifiants, sans paramètres de requête ni parties du chemin qui ressemblent à des clés, ou, pour un serveur local, le nom du paquet ou l’URL du dépôt. Les clés, les en-têtes et les variables d’environnement restent sur votre ordinateur, et les adresses privées ne sont jamais envoyées.

## Claude Code

Claude Code ajoute des serveurs depuis le terminal avec `claude mcp add`. Sur une fiche, **Ajouter à Claude Code** copie la commande.

### Sans compte

1. Lancez ceci dans un terminal, dans le dossier de votre projet :

```
claude mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp
```

2. Démarrez Claude Code et tapez `/mcp`. **deepwiki** devrait apparaître comme connecté.

Ajoutez `--scope user` pour le rendre disponible dans tous vos projets, pas seulement celui-ci.

### Compte requis

1. Lancez ceci dans un terminal, dans le dossier de votre projet :

```
claude mcp add --transport http notion https://mcp.notion.com/mcp
```

2. Démarrez Claude Code, tapez `/mcp`, choisissez **notion** puis **Authenticate**. Une fenêtre de navigateur s’ouvre pour la connexion à Notion.

Ajoutez `--scope user` pour le rendre disponible dans tous vos projets, pas seulement celui-ci.

### Clé API

1. Lancez ceci dans un terminal, dans le dossier de votre projet :

```
claude mcp add --transport http example https://mcp.example.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"
```

2. Remplacez l’espace réservé par votre clé avant de lancer la commande, puis vérifiez avec `/mcp` dans Claude Code.

Ajoutez `--scope user` pour le rendre disponible dans tous vos projets, pas seulement celui-ci.

### Local

1. Lancez ceci dans un terminal, dans le dossier de votre projet :

```
claude mcp add --transport stdio memory -- npx -y @modelcontextprotocol/server-memory
```

2. Démarrez Claude Code et tapez `/mcp`. **memory** devrait apparaître comme connecté.

Ajoutez `--scope user` pour le rendre disponible dans tous vos projets.

## claude.ai

claude.ai ajoute les serveurs distants comme connecteurs personnalisés. **Ajouter à claude.ai** ouvre le formulaire du connecteur avec le nom et l’URL remplis. Un serveur qui demande une clé API fonctionne aussi : ajoutez la clé dans **Request headers** du même formulaire, par exemple `Authorization: Bearer YOUR_KEY`. claude.ai ne peut pas lancer de serveurs locaux, donc les fiches locales ne le proposent pas.

### Sans compte

1. Ouvrez le formulaire des connecteurs sur claude.ai. Ce bouton remplit le nom et l’URL pour vous :

[Ajouter à claude.ai](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=DeepWiki&connectorUrl=https%3A%2F%2Fmcp.deepwiki.com%2Fmcp)

2. Vérifiez que l’URL est `https://mcp.deepwiki.com/mcp` et cliquez sur **Add**.
3. Activez-le dans une conversation depuis le menu des outils.

Les offres gratuites permettent un connecteur personnalisé. Sur les offres Team et Enterprise, un propriétaire l’ajoute dans **Organization settings → Connectors**.

### Compte requis

1. Ouvrez le formulaire des connecteurs sur claude.ai. Ce bouton remplit le nom et l’URL pour vous :

[Ajouter à claude.ai](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Notion&connectorUrl=https%3A%2F%2Fmcp.notion.com%2Fmcp)

2. Vérifiez que l’URL est `https://mcp.notion.com/mcp` et cliquez sur **Add**.
3. Cliquez sur **Connect** et connectez-vous quand Notion le demande.

Les offres gratuites permettent un connecteur personnalisé. Sur les offres Team et Enterprise, un propriétaire l’ajoute dans **Organization settings → Connectors**.

### Clé API

1. Ouvrez le formulaire des connecteurs sur claude.ai. Ce bouton remplit le nom et l’URL pour vous :

[Ajouter à claude.ai](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Example&connectorUrl=https%3A%2F%2Fmcp.example.com%2Fmcp)

2. Vérifiez que l’URL est `https://mcp.example.com/mcp`. Dans **Request headers**, ajoutez `Authorization: Bearer <YOUR_API_KEY>` avec votre clé obtenue auprès de Example, puis cliquez sur **Add**.
3. Activez-le dans une conversation depuis le menu des outils.

Les offres gratuites permettent un connecteur personnalisé. Sur les offres Team et Enterprise, un propriétaire l’ajoute dans **Organization settings → Connectors**.

## Claude Desktop

Les serveurs distants passent par les **Connectors**, les mêmes que sur claude.ai, y compris ceux qui demandent une clé API dans **Request headers**. Les serveurs locaux vont dans son fichier de configuration JSON. Pour garder une clé sur votre ordinateur, utilisez plutôt la passerelle `mcp-remote`.

### Sans compte

1. Ouvrez **Customize → Connectors**, cliquez sur **+ Add**, puis sur **Add custom connector**.
2. Nommez-le **DeepWiki** et collez cette URL :

```
https://mcp.deepwiki.com/mcp
```

3. Cliquez sur **Add**. Ses outils apparaissent dans le menu des outils de la conversation.

Le fichier de configuration JSON de Claude Desktop ne lance que des serveurs locaux. Les serveurs distants passent par les Connectors, et les connecteurs ajoutés sur claude.ai apparaissent aussi ici.

### Compte requis

1. Ouvrez **Customize → Connectors**, cliquez sur **+ Add**, puis sur **Add custom connector**.
2. Nommez-le **Notion** et collez cette URL :

```
https://mcp.notion.com/mcp
```

3. Cliquez sur **Add**, puis sur **Connect**, et connectez-vous quand Notion le demande.

Le fichier de configuration JSON de Claude Desktop ne lance que des serveurs locaux. Les serveurs distants passent par les Connectors, et les connecteurs ajoutés sur claude.ai apparaissent aussi ici.

### Clé API

1. Utilisez la passerelle `mcp-remote`, qui garde la clé sur cet ordinateur (un connecteur ajouté sur claude.ai avec la clé dans **Request headers** apparaît aussi ici). Ouvrez **Settings → Developer → Edit Config** et ajoutez :

`claude_desktop_config.json`:

```
{
  "mcpServers": {
    "example": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.example.com/mcp",
        "--header",
        "Authorization: Bearer <YOUR_API_KEY>"
      ]
    }
  }
}
```

2. Remplacez l’espace réservé par votre clé et redémarrez Claude Desktop.

La passerelle nécessite Node.js sur votre ordinateur.

### Local

1. Ouvrez **Settings → Developer → Edit Config**. Cela ouvre `claude_desktop_config.json`. Ajoutez :

`claude_desktop_config.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

2. Enregistrez le fichier et redémarrez Claude Desktop.

Nécessite Node.js sur votre ordinateur. Le fichier se trouve dans `~/Library/Application Support/Claude/` sous macOS et dans `%APPDATA%\Claude\` sous Windows.

## ChatGPT

ChatGPT se connecte aux serveurs distants que vous ajoutez dans Plugins. Comme claude.ai, il ne peut ni lancer de serveurs locaux ni envoyer l’en-tête d’une clé API.

### Sans compte

1. Sur chatgpt.com, allez dans **Plugins**, sélectionnez **+**, puis **Add custom MCP server**.
2. Saisissez un nom pour le serveur.
3. Dans **Connection**, collez `https://mcp.deepwiki.com/mcp` comme URL du serveur, puis pour l’authentification choisissez **No authentication**.
4. Cochez **I understand and want to continue**, puis sélectionnez **Create as a plugin**.

La possibilité d’ajouter un serveur MCP personnalisé dépend de votre forfait ChatGPT et des autorisations de votre espace de travail (dans les espaces Business, les administrateurs et les propriétaires le peuvent).

### Compte requis

1. Sur chatgpt.com, allez dans **Plugins**, sélectionnez **+**, puis **Add custom MCP server**.
2. Saisissez un nom pour le serveur.
3. Dans **Connection**, collez `https://mcp.notion.com/mcp` comme URL du serveur, puis pour l’authentification choisissez **OAuth**. ChatGPT vous envoie chez Notion pour vous connecter.
4. Cochez **I understand and want to continue**, puis sélectionnez **Create as a plugin**.

La possibilité d’ajouter un serveur MCP personnalisé dépend de votre forfait ChatGPT et des autorisations de votre espace de travail (dans les espaces Business, les administrateurs et les propriétaires le peuvent).

## Cursor

**Ajouter à Cursor** ouvre la page d’installation de Cursor avec le serveur déjà rempli. Vous pouvez aussi l’ajouter à la main dans `mcp.json`.

### Sans compte

[Ajouter à Cursor](https://cursor.com/install-mcp?name=deepwiki&config=eyJ1cmwiOiJodHRwczovL21jcC5kZWVwd2lraS5jb20vbWNwIn0%3D)

Ou ajoutez-le à la main dans `~/.cursor/mcp.json` (tous les projets) ou `.cursor/mcp.json` (ce projet) :

`mcp.json`:

```
{
  "mcpServers": {
    "deepwiki": {
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

### Compte requis

[Ajouter à Cursor](https://cursor.com/install-mcp?name=notion&config=eyJ1cmwiOiJodHRwczovL21jcC5ub3Rpb24uY29tL21jcCJ9)

Ou ajoutez-le à la main dans `~/.cursor/mcp.json` (tous les projets) ou `.cursor/mcp.json` (ce projet) :

`mcp.json`:

```
{
  "mcpServers": {
    "notion": {
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

Cursor affiche **Needs authentication** à côté du serveur. Cliquez sur le bouton juste à côté pour vous connecter.

### Clé API

[Ajouter à Cursor](https://cursor.com/install-mcp?name=example&config=eyJ1cmwiOiJodHRwczovL21jcC5leGFtcGxlLmNvbS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgPFlPVVJfQVBJX0tFWT4ifX0%3D)

Ou ajoutez-le à la main dans `~/.cursor/mcp.json` (tous les projets) ou `.cursor/mcp.json` (ce projet) :

`mcp.json`:

```
{
  "mcpServers": {
    "example": {
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

### Local

[Ajouter à Cursor](https://cursor.com/install-mcp?name=memory&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBtb2RlbGNvbnRleHRwcm90b2NvbC9zZXJ2ZXItbWVtb3J5Il19)

Ou ajoutez-le à la main dans `~/.cursor/mcp.json` (tous les projets) ou `.cursor/mcp.json` (ce projet) :

`mcp.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Nécessite Node.js sur votre ordinateur.

## VS Code

**Ajouter à VS Code** ouvre l’invite d’installation de VS Code. Vous pouvez aussi lancer `code --add-mcp`, ou committer `.vscode/mcp.json` pour que tous ceux qui travaillent sur le projet aient le serveur.

### Sans compte

[Installer dans VS Code](https://vscode.dev/redirect/mcp/install?name=deepwiki&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.deepwiki.com%2Fmcp%22%7D)

Ou depuis un terminal :

```
code --add-mcp '{"name":"deepwiki","type":"http","url":"https://mcp.deepwiki.com/mcp"}'
```

Ou committez-le dans le dépôt, dans `.vscode/mcp.json` :

`.vscode/mcp.json`:

```
{
  "servers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

### Compte requis

[Installer dans VS Code](https://vscode.dev/redirect/mcp/install?name=notion&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.notion.com%2Fmcp%22%7D)

Ou depuis un terminal :

```
code --add-mcp '{"name":"notion","type":"http","url":"https://mcp.notion.com/mcp"}'
```

Ou committez-le dans le dépôt, dans `.vscode/mcp.json` :

`.vscode/mcp.json`:

```
{
  "servers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

VS Code vous demande de vous connecter au premier démarrage du serveur.

### Clé API

Ajoutez-le à `.vscode/mcp.json`. VS Code demande la clé la première fois et la stocke de façon sécurisée :

`.vscode/mcp.json`:

```
{
  "servers": {
    "example": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:api-key}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "api-key",
      "description": "API key",
      "password": true
    }
  ]
}
```

### Local

[Installer dans VS Code](https://vscode.dev/redirect/mcp/install?name=memory&config=%7B%22type%22%3A%22stdio%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-memory%22%5D%7D)

Ou depuis un terminal :

```
code --add-mcp '{"name":"memory","type":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-memory"]}'
```

Ou committez-le dans le dépôt, dans `.vscode/mcp.json` :

`.vscode/mcp.json`:

```
{
  "servers": {
    "memory": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Nécessite Node.js sur votre ordinateur.

## Autres clients

### Devin Desktop (anciennement Windsurf)

### Sans compte

1. Ajoutez-le à `~/.config/devin/mcp_config.json` (macOS et Linux) ou `%APPDATA%\devin\mcp_config.json` (Windows) :

`mcp_config.json`:

```
{
  "mcpServers": {
    "deepwiki": {
      "serverUrl": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

2. Actualisez la liste des serveurs MCP dans Cascade.

Devin Desktop est le nouveau nom de Windsurf. Pour les serveurs distants, il lit `serverUrl` (ou `url`).

### Compte requis

1. Ajoutez-le à `~/.config/devin/mcp_config.json` (macOS et Linux) ou `%APPDATA%\devin\mcp_config.json` (Windows) :

`mcp_config.json`:

```
{
  "mcpServers": {
    "notion": {
      "serverUrl": "https://mcp.notion.com/mcp"
    }
  }
}
```

2. Actualisez la liste des serveurs MCP dans Cascade et connectez-vous quand c’est demandé.

Devin Desktop est le nouveau nom de Windsurf. Pour les serveurs distants, il lit `serverUrl` (ou `url`).

### Clé API

1. Ajoutez-le à `~/.config/devin/mcp_config.json` (macOS et Linux) ou `%APPDATA%\devin\mcp_config.json` (Windows) :

`mcp_config.json`:

```
{
  "mcpServers": {
    "example": {
      "serverUrl": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

2. Actualisez la liste des serveurs MCP dans Cascade.

Devin Desktop est le nouveau nom de Windsurf. Pour les serveurs distants, il lit `serverUrl` (ou `url`).

### Local

1. Ajoutez-le à `~/.config/devin/mcp_config.json` (macOS et Linux) ou `%APPDATA%\devin\mcp_config.json` (Windows) :

`mcp_config.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

2. Actualisez la liste des serveurs MCP dans Cascade.

Devin Desktop est le nouveau nom de Windsurf.

### Codex

### Sans compte

```
codex mcp add deepwiki --url https://mcp.deepwiki.com/mcp
```

Ou modifiez directement `~/.codex/config.toml` :

`config.toml`:

```
[mcp_servers.deepwiki]
url = "https://mcp.deepwiki.com/mcp"
```

### Compte requis

```
codex mcp add notion --url https://mcp.notion.com/mcp
codex mcp login notion
```

Ou modifiez directement `~/.codex/config.toml` :

`config.toml`:

```
[mcp_servers.notion]
url = "https://mcp.notion.com/mcp"
```

### Clé API

```
codex mcp add example --url https://mcp.example.com/mcp --bearer-token-env-var EXAMPLE_API_KEY
```

Ou modifiez directement `~/.codex/config.toml` :

`config.toml`:

```
[mcp_servers.example]
url = "https://mcp.example.com/mcp"
bearer_token_env_var = "EXAMPLE_API_KEY"
```

Définissez `EXAMPLE_API_KEY` avec votre clé dans le shell qui lance Codex.

### Local

```
codex mcp add memory -- npx -y @modelcontextprotocol/server-memory
```

Ou modifiez directement `~/.codex/config.toml` :

`config.toml`:

```
[mcp_servers.memory]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-memory"]
```

Nécessite Node.js sur votre ordinateur.

### Gemini CLI

### Sans compte

```
gemini mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp
```

Cela l’ajoute au projet en cours. Ajoutez `-s user` pour l’utiliser partout.

### Compte requis

```
gemini mcp add --transport http notion https://mcp.notion.com/mcp
```

Puis, dans Gemini CLI, lancez `/mcp auth notion` pour vous connecter.

Cela l’ajoute au projet en cours. Ajoutez `-s user` pour l’utiliser partout.

### Clé API

```
gemini mcp add --transport http --header "Authorization: Bearer <YOUR_API_KEY>" example https://mcp.example.com/mcp
```

Cela l’ajoute au projet en cours. Ajoutez `-s user` pour l’utiliser partout.

### Local

```
gemini mcp add memory npx -- -y @modelcontextprotocol/server-memory
```

Cela l’ajoute au projet en cours. Ajoutez `-s user` pour l’utiliser partout.

### Tout autre client

### Sans compte

La plupart des clients acceptent cette forme. Certains nomment autrement le champ de l’URL : `serverUrl` dans Devin Desktop, `httpUrl` dans le fichier de réglages de Gemini CLI.

```
{
  "mcpServers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

Zed place les serveurs sous `context_servers` dans ses réglages. Cline a besoin de `"type": "streamableHttp"`, sinon il suppose SSE.

Votre client ne lance que des serveurs locaux ? Reliez-le avec `npx -y mcp-remote https://mcp.deepwiki.com/mcp`.

### Compte requis

La plupart des clients acceptent cette forme. Certains nomment autrement le champ de l’URL : `serverUrl` dans Devin Desktop, `httpUrl` dans le fichier de réglages de Gemini CLI.

```
{
  "mcpServers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

Zed place les serveurs sous `context_servers` dans ses réglages. Cline a besoin de `"type": "streamableHttp"`, sinon il suppose SSE.

Votre client ne lance que des serveurs locaux ? Reliez-le avec `npx -y mcp-remote https://mcp.notion.com/mcp`.

### Clé API

La plupart des clients acceptent cette forme. Certains nomment autrement le champ de l’URL : `serverUrl` dans Devin Desktop, `httpUrl` dans le fichier de réglages de Gemini CLI.

```
{
  "mcpServers": {
    "example": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

Zed place les serveurs sous `context_servers` dans ses réglages. Cline a besoin de `"type": "streamableHttp"`, sinon il suppose SSE.

Votre client ne lance que des serveurs locaux ? Reliez-le avec `npx -y mcp-remote https://mcp.example.com/mcp`.

### Local

La plupart des clients qui lancent des serveurs locaux acceptent cette forme :

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Zed place les serveurs sous `context_servers` dans ses réglages, avec les mêmes champs `command`, `args` et `env`.

Nécessite Node.js sur votre ordinateur.

## Connexion, clés API et serveurs locaux

### Connexion (OAuth)

La première fois que votre client se connecte, le serveur demande qui vous êtes. Votre client ouvre la page de connexion de l’éditeur dans un navigateur, vous y autorisez l’accès, et le client garde le jeton. Dans Claude Code, cela passe par `/mcp` et **Authenticate**, dans Cursor par **Needs authentication** dans ses réglages MCP, dans Codex par `codex mcp login` et dans Gemini CLI par `/mcp auth`.

Le jeton est émis pour l’URL du serveur lui-même, et votre client ne l’envoie qu’à elle : l’authentification MCP lie chaque jeton à un seul serveur (indicateurs de ressource OAuth, RFC 8707). C’est l’une des raisons pour lesquelles chaque configuration sur mcp.tc utilise l’URL du serveur lui-même, et pour lesquelles mcp.tc ne voit jamais vos identifiants.

### Clé API

Obtenez une clé auprès de l’éditeur. Les extraits placent un espace réservé comme `<YOUR_API_KEY>` dans l’en-tête attendu par le serveur, le plus souvent `Authorization: Bearer <YOUR_API_KEY>`. Remplacez-le dans votre propre configuration et gardez ce fichier hors des dépôts partagés. VS Code demande la clé la première fois et la stocke de façon sécurisée, et Codex la lit dans une variable d’environnement. Sur claude.ai et Claude Desktop, ajoutez la clé dans **Request headers** en créant le connecteur personnalisé. ChatGPT ne peut pas envoyer l’en-tête d’une clé.

Certains serveurs fonctionnent sans clé et en acceptent une pour un accès étendu. Leur badge indique **Compte facultatif**, leurs commandes omettent la clé, et la note sous les étapes nomme l’en-tête dans lequel l’envoyer.

### Serveurs locaux

Votre client lance un serveur local comme un programme sur votre ordinateur, avec la commande d’installation de sa page. La commande détermine ce que vous devez avoir installé :

- `npx` nécessite Node.js.
- `uvx` nécessite uv (Python).
- `pipx` nécessite pipx (Python).
- `docker` nécessite Docker.
- `dnx` nécessite .NET 10.

Un serveur local s’exécute avec les droits de votre compte utilisateur, donc lisez sa liste d’outils avant de l’ajouter. Les réglages dont il a besoin, clés comprises, sont des variables d’environnement, et les extraits les montrent comme espaces réservés. claude.ai et ChatGPT ne se connectent qu’à des serveurs distants, ils ne peuvent donc pas utiliser les serveurs locaux.

### Accès non confirmé

Un anneau gris et **Accès non confirmé** signifient que notre vérification n’a pas pu déterminer si le serveur demande un compte. Les étapes utilisent l’URL simple. Si le serveur demande des identifiants, la documentation de l’éditeur dit lesquels.

## Ce que fait un lien mcp.tc dans un client

Le lien mcp.tc est la page de la fiche, pas l’adresse d’un serveur. Un navigateur reçoit la page. Un client MCP qui s’y connecte reçoit à la place une erreur : HTTP 409 avec un message JSON-RPC qui indique l’URL du serveur (ou, pour un serveur local, sa commande d’installation) et la page. Certains clients affichent le message, ce qui vous permet d’y copier la bonne adresse ; Claude Code signale seulement « Failed to connect ». Voici la réponse qu’un client reçoit à `mcp.tc/i/deepwiki` (le message est toujours en anglais, la langue qu’attendent les clients) :

`HTTP 409, application/json`:

```
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32001,
    "message": "mcp.tc: this link is a page, not an MCP endpoint. Connect to DeepWiki directly with its own URL: https://mcp.deepwiki.com/mcp (no sign-in needed). Setup for each client: https://mcp.tc/i/deepwiki",
    "data": {
      "listing": "https://mcp.tc/i/deepwiki",
      "endpoint": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

`data.endpoint` contient l’URL du serveur, `data.command` la commande d’installation d’un serveur local et `data.listing` la page. Un lien non référencé répond 404, et une fiche retirée répond 410.

Pourquoi le lien ne renvoie-t-il pas votre client vers le serveur, ou ne relaie-t-il pas les requêtes ? Les SDK MCP actuels (TypeScript 1.32 et ultérieurs, Python 1.30 et ultérieurs) refusent d’être renvoyés vers un autre site, et de toute façon un jeton de connexion ne fonctionne qu’à l’URL du serveur lui-même. Relayer les requêtes rendrait aussi votre client dépendant de mcp.tc ; chaque lien mcp.tc n’est donc qu’une page.

## Dépannage

### Mon client affiche « this link is a page, not an MCP endpoint »

Vous avez ajouté le lien mcp.tc. Remplacez-le par l’URL indiquée dans ce message, ou copiez l’URL depuis l’encadré en haut de la fiche. Pour un serveur local, utilisez plutôt la commande d’installation.

### Le serveur ne se connecte pas

Si l’URL ajoutée commence par `https://mcp.tc/i/`, c’est le lien de la page : remplacez-la par l’URL du serveur indiquée sur la fiche. Sinon, vérifiez que l’URL correspond exactement à celle de la fiche, chemin compris : `https://mcp.deepwiki.com/mcp` et `https://mcp.deepwiki.com` sont des adresses différentes. Redémarrez le client après avoir modifié un fichier de configuration. Un badge **Dernière vérification échouée** sur la fiche signifie que nos vérifications quotidiennes échouent aussi : le problème vient peut-être de l’éditeur.

### Il me redemande sans cesse de me connecter, ou répond 401

Le serveur demande une authentification et votre client ne l’a pas terminée. Dans Claude Code, tapez `/mcp`, choisissez le serveur puis **Authenticate**. Dans Cursor, ouvrez les réglages MCP et utilisez le bouton à côté de **Needs authentication**. Dans Codex, lancez `codex mcp login` avec le nom du serveur, et dans Gemini CLI `/mcp auth`. Avec une clé API, vérifiez que vous avez remplacé l’espace réservé et que l’en-tête correspond à la documentation de l’éditeur.

### Un serveur local ne démarre pas

Lancez d’abord sa commande d’installation dans un terminal. Si elle échoue là, le client ne peut pas le démarrer non plus, et en général il manque l’environnement d’exécution : Node.js pour `npx`, uv pour `uvx`, Docker pour `docker`. Remplacez chaque espace réservé, comme `<YOUR_API_KEY>` ou `/path/to/allowed/dir`, par une vraie valeur.

### Mon client ne lance que des serveurs locaux

Reliez le serveur distant avec `npx -y mcp-remote` suivi de l’URL du serveur. La passerelle tourne sur votre ordinateur et nécessite Node.js.

### La fiche indique SSE

Le serveur utilise l’ancien transport SSE, que certains clients ne prennent plus en charge. Claude Code accepte `--transport sse`, VS Code `"type": "sse"`, et Codex a besoin de la passerelle `mcp-remote`. Les étapes de configuration de la fiche utilisent déjà la bonne option.

### Les outils d’un serveur ont changé après que je l’ai ajouté

Ouvrez sa fiche et regardez l’onglet **Historique**. Quand nous pouvons lire les outils du serveur, il liste ceux qui ont été ajoutés, retirés ou modifiés depuis notre première lecture, avec chaque description avant et après. Votre client utilise peut-être encore la liste que vous aviez approuvée : comparez-la avec ce qu’il affiche maintenant. Pour recevoir un e-mail au prochain changement, connectez-vous et appuyez sur **Suivre** sur la fiche.

### Une information de la fiche est erronée

Utilisez **Signaler cette fiche** sur sa page. Le texte est rédigé avec l’aide de l’IA à partir des métadonnées du serveur, des erreurs arrivent donc, et une personne lit chaque signalement.

---
Source : https://mcp.tc/fr/docs/connect. Version Markdown pour les agents d’IA (demandez `text/markdown` ou ajoutez `.md` à l’adresse). Vue d’ensemble du site : https://mcp.tc/llms.txt
