Tutoriel : connecter Claude, ChatGPT, Cursor à un serveur MCP

Vous avez trouvé un serveur MCP intéressant sur un registre public, ou vous venez de déployer le vôtre. Bonne nouvelle : le brancher sur un client IA prend quelques minutes. Mauvaise nouvelle : chaque client a son propre fichier de config, son propre format, son propre dossier. Ce tuto réunit les recettes exactes pour les huit principaux clients MCP en 2026, avec les chemins précis par OS et des blocs JSON copier-coller.

On prend comme exemple le serveur MCP public de Datacampus (https://datacampus.fr/mcp, transport Streamable HTTP) et le serveur filesystem officiel d’Anthropic (transport stdio). Adaptez les URLs et les binaires à votre cas.

Sommaire

Rappel express : ce qu’un client MCP doit savoir faire

MCP est un standard ouvert initié par Anthropic fin 2024. Le protocole repose sur JSON-RPC 2.0, avec trois transports définis par la spec :

• stdio — le client lance un processus local, lit et écrit sur stdin/stdout. Idéal pour les outils locaux (filesystem, git, sqlite).
• Streamable HTTP — transport HTTP unique endpoint avec support du streaming via Server-Sent Events. Remplace l’ancien transport HTTP+SSE déprécié depuis la révision 2025-03-26 de la spec. C’est le transport recommandé pour les serveurs distants.
• SSE (l’ancien) — encore supporté par certains clients pour la rétro-compatibilité, à éviter pour un nouveau déploiement.

Tableau de compatibilité 2026

Règle d’or. Le transport du serveur doit matcher ce que le client sait parler. Un serveur Streamable HTTP ne se branche pas sur un client qui n’attend que du stdio, et inversement. C’est la première source d’erreur en débogage.

Pour la théorie et les concepts, on a un article dédié : Qu’est-ce que MCP ?. Ici on va droit à la config.

1. Claude Desktop testé

Claude Desktop (l’application officielle d’Anthropic sur macOS, Windows et Linux) lit un fichier JSON unique au démarrage. Transport : stdio + HTTP. La clé racine attendue est mcpServers.

Emplacement du fichier par OS

• macOS — ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows — %APPDATA%\Claude\claude_desktop_config.json
• Linux — ~/.config/Claude/claude_desktop_config.json

Le plus simple pour l’ouvrir : menu Settings → Developer → Edit Config. Claude Desktop crée le fichier s’il n’existe pas et l’ouvre dans votre éditeur par défaut.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/pierre/Documents"
      ]
    },
    "datacampus": {
      "type": "http",
      "url": "https://datacampus.fr/mcp"
    }
  }
}

Deux formats dans le même fichier :

• stdio — on déclare command et args, optionnellement env pour passer des variables.
• HTTP distant — on déclare type: "http" et url. Pour un serveur protégé par auth, ajoutez un bloc headers avec votre token.

Vérifier la connexion

~ $ tail -f ~/Library/Logs/Claude/mcp*.log

Gotcha. JSON invalide = Claude Desktop ignore silencieusement tout le fichier, sans erreur visible. Valider avec jq . claude_desktop_config.json avant de redouter un bug exotique.

2. Claude Code CLI testé

La CLI officielle d’Anthropic. Transport : stdio + HTTP. Elle lit les serveurs MCP à trois niveaux, dans cet ordre de précédence :

1. Local — enregistré dans la config utilisateur, réservé au répertoire courant. Non partagé.
2. Project — fichier .mcp.json à la racine du projet, commité en Git pour partager avec l’équipe.
3. User — disponible dans tous vos projets, jamais partagé.

~/projet $ claude mcp add --transport http datacampus https://datacampus.fr/mcp --scope project
~/projet $ claude mcp add filesystem --scope user -- npx -y @modelcontextprotocol/server-filesystem ~/Documents
~/projet $ claude mcp list

{
  "mcpServers": {
    "datacampus": {
      "type": "http",
      "url": "https://datacampus.fr/mcp"
    }
  }
}

Tip. Le scope projet est validant : tous les développeurs qui ouvrent le repo avec Claude Code héritent des bons MCPs. Première ouverture = approbation manuelle requise, pour éviter l’exécution de code arbitraire depuis un repo non fiable.

3. ChatGPT testé

Chez OpenAI, le support de MCP est arrivé progressivement en 2025. En 2026, ChatGPT supporte MCP via deux canaux : connectors custom dans l’UI web (plan Plus, Pro, Team, Enterprise), et API Responses pour les développeurs. Seul le transport Streamable HTTP est accepté, le stdio est hors-scope (l’app tourne chez OpenAI).

UI web — Connector custom

• Settings → Connectors → Add custom connector
• URL — https://datacampus.fr/mcp
• Auth — None, OAuth2 ou Bearer selon votre serveur

~ $ curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5",
    "tools": [{
      "type": "mcp",
      "server_label": "datacampus",
      "server_url": "https://datacampus.fr/mcp",
      "require_approval": "never"
    }],
    "input": "Liste les offres VPS de Datacampus"
  }'

Gotcha. Le support historique de ChatGPT s’est d’abord limité aux tools de type search et fetch en mode deep research. Les connectors custom couvrent désormais l’ensemble des tools exposés, mais vérifiez que votre plan le permet (Plus et au-delà).

4. Cursor natif

Cursor (IDE fork de VS Code) supporte MCP nativement. Transport : stdio + HTTP. Deux niveaux de config : projet (.cursor/mcp.json à la racine) ou global (~/.cursor/mcp.json). Le format est strictement aligné sur celui de Claude Desktop.

{
  "mcpServers": {
    "datacampus": {
      "url": "https://datacampus.fr/mcp"
    },
    "gitlab": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-gitlab"],
      "env": {
        "GITLAB_PERSONAL_ACCESS_TOKEN": "glpat_xxx"
      }
    }
  }
}

Activation : Settings → Cursor Settings → MCP & Integrations. Chaque serveur apparaît avec un toggle et la liste des tools disponibles. Point vert = OK, point rouge = relire les logs via Output → MCP Logs.

Tip. Pour les serveurs stdio qui prennent du temps à démarrer (genre npx qui résout un package la première fois), Cursor peut timeout. Préinstaller le package en global accelere la connexion.

5. Continue.dev natif

Continue (extension VS Code et JetBrains, open source) utilise un fichier config.yaml depuis la version 1.0 (l’ancien config.json reste supporté). Transport : stdio + HTTP. Fichier utilisateur : ~/.continue/config.yaml. Fichier projet : .continue/config.yaml à la racine du repo.

mcpServers:
  - name: datacampus
    type: streamable-http
    url: https://datacampus.fr/mcp
  - name: filesystem
    command: npx
    args:
      - "-y"
      - "@modelcontextprotocol/server-filesystem"
      - "/home/pierre/projects"

Gotcha. Le champ type: streamable-http est obligatoire pour un serveur HTTP distant. Sans lui, Continue tente un stdio par défaut et échoue silencieusement.

6. Cline testé

Cline (extension VS Code, open source) lit cline_mcp_settings.json. Transport : stdio + HTTP. Le fichier s’ouvre via l’icône MCP de la barre latérale, bouton Configure MCP Servers. Schéma identique à Claude Desktop.

{
  "mcpServers": {
    "datacampus": {
      "type": "http",
      "url": "https://datacampus.fr/mcp",
      "disabled": false,
      "autoApprove": []
    }
  }
}

7. Roo Code beta

Roo Code est un fork de Cline, plus orienté agents autonomes. Transport : stdio + HTTP. Configuration via la palette : Roo: Open MCP Settings. Fichier : mcp_settings.json. Schéma identique à Cline, avec un champ alwaysAllow pour les tools toujours autorisés.

{
  "mcpServers": {
    "datacampus": {
      "type": "http",
      "url": "https://datacampus.fr/mcp",
      "alwaysAllow": ["list_offerings", "get_company_info"]
    }
  }
}

Gotcha. Roo Code en mode agent autonome enchaîne les appels tools sans validation. Ne pas mettre un tool d’écriture (ex : write_file, delete_issue) dans alwaysAllow sans avoir testé longuement en dev.

8. Zed beta

Zed (éditeur natif Rust, macOS + Linux) gère les MCPs via les context servers. Transport : stdio principalement, HTTP en cours de stabilisation. Configuration dans ~/.config/zed/settings.json (ou ~/Library/Application Support/Zed/settings.json sur macOS selon l’installation).

{
  "context_servers": {
    "filesystem": {
      "command": {
        "path": "npx",
        "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/projects"],
        "env": {}
      }
    },
    "datacampus": {
      "url": "https://datacampus.fr/mcp"
    }
  }
}

Gotcha. Zed force le décodage UTF-8 strict sur les outputs stdio. Un serveur qui écrit des bytes non-UTF-8 sur stdout (logs colorés par exemple) fait tomber la connexion. Rediriger les logs vers stderr.

Tester un serveur MCP sans client

Avant d’accuser le client, vérifiez que votre serveur répond correctement. Deux méthodes officielles.

MCP Inspector

~ $ npx @modelcontextprotocol/inspector
~ $ npx @modelcontextprotocol/inspector npx -y @modelcontextprotocol/server-filesystem ~/Documents

curl direct en JSON-RPC 2.0

~ $ curl -X POST https://datacampus.fr/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-06-18",
      "capabilities": {},
      "clientInfo": {"name": "curl-test", "version": "1.0"}
    }
  }'

~ $ curl -X POST https://datacampus.fr/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'

Troubleshooting : les trois pannes les plus fréquentes

1. Transport mismatch

Symptôme — le serveur apparaît dans le client mais retourne immédiatement une erreur de connexion, ou ne remonte aucun tool.

Cause — le serveur ne parle que l’ancien transport SSE (déprécié) alors que le client attend du Streamable HTTP, ou l’inverse. Vérifier la version du serveur et celle du SDK côté client. En 2026, viser Streamable HTTP (spec 2025-03-26 ou plus récente) partout.

2. Authentification refusée

Symptôme — 401 ou 403 dans les logs. Pour un serveur HTTP protégé, la plupart des clients acceptent un bloc headers.

{
  "mcpServers": {
    "mon-serveur": {
      "type": "http",
      "url": "https://api.exemple.com/mcp",
      "headers": {
        "Authorization": "Bearer eyJhbGciOi..."
      }
    }
  }
}

3. Tool invisible malgré une connexion OK

Symptôme — le serveur est connecté, mais un tool attendu n’apparaît pas dans la liste, ou l’agent refuse de l’appeler. Causes possibles :

• Filtrage client — le client filtre par défaut certains tools jugés destructifs. Vérifier les permissions par tool dans l’UI (Claude Desktop : Settings → Developer → Tool permissions).
• Scope serveur — certains serveurs nécessitent une authentification pour déverrouiller des tools premium.
• Décision du modèle — le LLM choisit de ne pas appeler le tool. Réécrire le prompt en mentionnant explicitement l’outil, ou regarder la description retournée par tools/list. Une description vague = un tool jamais déclenché.

Et si vous voulez exposer votre propre serveur MCP ?

Brancher un MCP côté client, c’est cinq minutes. Construire et héberger le serveur qui expose vos données métier, c’est une autre histoire : authentification, scaling, logs, rétroactions à la spec qui bouge encore tous les trimestres.

Chez Datacampus, on héberge notre propre serveur MCP sur datacampus.fr/mcp (PHP pur, JSON-RPC 2.0, Streamable HTTP, cinq tools métier dont estimate_configuration qui calcule en direct le tarif et l’empreinte CO&sub2;/eau d’une configuration). Le retour d’exp est détaillé dans comment on a construit notre serveur MCP. On propose aussi des serveurs MCP sur mesure infogérés pour les entreprises qui veulent brancher leur ERP, CRM, GitLab, ou n’importe quelle source de données interne sur Claude ou ChatGPT sans s’occuper de l’infrastructure. VPS en France, 100 % open source, énergie renouvelable, mPUE 1,008 sur la zone immersion de notre datacenter Cassin1 au Futuroscope.

Pour l’IA locale (LLM tournant chez vous, sans appel à OpenAI ou Anthropic), on a aussi des serveurs d’inférence souverains bâtis sur l’APU AMD Ryzen AI Max+ 395 (CPU + NPU + iGPU avec 128 Go de mémoire unifiée — pas de GPU dédié énergivore), capables de faire tourner Llama 3 70B ou Mixtral 8x7B en local.

Envie d’exposer un MCP pour votre équipe ou vos clients ? Jetez un œil à la page MCP Datacampus, relisez les concepts dans notre intro MCP, ou écrivez-nous directement via le formulaire de contact. On répond vite, sans call center et sans sous-traitance.