Model Context Protocol (MCP) pour Claude Code

MCP en 2026 : pourquoi le hype est réel, et où sont les pièges

MCP a gagné. Il y a un an, le débat sur r/ClaudeAI était de savoir si MCP allait déplacer les schémas de function-calling bespoke. C'est fait : OpenAI, Google, et maintenant la plupart des gros clients ont adopté le protocole. La spécification MCP est désormais le standard de fait, et il y a 300+ serveurs communautaires sur la liste awesome-mcp-servers.

Cela dit, livrer MCP en production expose des pièges que les tutos passent sous silence :

• →Chaque serveur MCP est un shell qui tourne sur votre machine. Un serveur communautaire depuis un repo GitHub aléatoire, c'est du code avec accès au filesystem. Traitez-le comme une extension navigateur — lisez le code, pinez la version, préférez les serveurs publiés par des vendors que vous connaissez déjà (ceux d'Anthropic, serveurs officiels GitHub/PostgreSQL/Slack).
• →Le scoping des credentials est la question opérationnelle la plus dure. Un serveur MCP GitHub avec un personal access token hérite de toutes vos permissions de repo. Créez des PAT scopés par serveur MCP ; ne réutilisez jamais votre token principal. C'est l'incident de prod le plus fréquent dans les threads Reddit que je suis.
• →Le bruit d'outils dégrade les performances du modèle. Chaque serveur MCP enregistré ajoute des descriptions d'outils à chaque prompt. Vingt serveurs activés = des milliers de tokens de métadonnées d'outils par requête, et une précision de sélection d'outil mesurablement moins bonne. Activez par projet, pas globalement. La config MCP projet-level de Claude Code existe pour cette raison.

Pour un point de départ honnête au-delà des pages marketing, l'annonce MCP d'Anthropic et le README du SDK TypeScript MCP donnent ensemble l'image franche de ce à quoi vous souscrivez.

Qu'est-ce que MCP ?

MCP est un protocole ouvert qui standardise la façon dont les assistants IA communiquent avec les sources de données et outils externes. Considérez-le comme l'USB de l'IA, un connecteur universel qui fonctionne avec tout.

Sans MCP

> What's the status of issue #432?

I don't have access to your issue tracker. 
Please check GitHub directly.

Avec MCP + serveur GitHub

> What's the status of issue #432?

Issue #432: "Fix authentication redirect loop"
Status: Open
Assignee: @developer
Labels: bug, high-priority
Last updated: 2 hours ago
Related PR: #445 (in review)

Claude peut maintenant interroger, créer et mettre à jour les issues GitHub directement.

Comment fonctionne MCP

Flux de données MCP :

Claude Code ⟷ Serveur MCP ⟷ Service externe

1. →Claude Code envoie des requêtes via le protocole MCP
2. →Le serveur MCP traduit les requêtes vers l'API du service externe
3. →Le service externe renvoie les données par la même chaîne

Les serveurs MCP peuvent fonctionner :

• →Localement (transport stdio), Scripts sur votre machine
• →À distance (transport HTTP), Services hébergés avec OAuth

Serveurs MCP intégrés

Claude Code inclut plusieurs serveurs MCP prêts à l'emploi :

Gérer les connexions MCP

Voir les serveurs actuels

claude mcp list

Sortie :

Configured MCP Servers:
  github (http) - https://api.github.com/mcp/ [authenticated]
  sentry (http) - https://mcp.sentry.dev/mcp [authenticated]
  filesystem (stdio) - local

Gestion interactive

> /mcp

Ouvre un menu interactif :

MCP Servers

[1] github (http) - authenticated
    Tools: get_issue, create_issue, list_repos...
    
[2] sentry (http) - authenticated
    Tools: get_issues, search_errors...
    
[3] filesystem (stdio) - connected
    Tools: read_file, write_file, list_directory...

[a] Add server  [r] Remove server  [s] Server status
[o] Re-authenticate  [Esc] Exit

Ajouter des serveurs MCP

Serveurs HTTP (distants)

La plupart des intégrations SaaS utilisent le transport HTTP avec OAuth :

# Intégration GitHub
claude mcp add github --transport http https://api.github.com/mcp/

# Suivi d'erreurs Sentry
claude mcp add sentry --transport http https://mcp.sentry.dev/mcp

# Gestion de projet Linear
claude mcp add linear --transport http https://mcp.linear.app/mcp

# Notion (avec authentification par en-tête)
claude mcp add notion --transport http-stream https://mcp.notion.so/mcp

Après l'ajout, Claude Code ouvre un navigateur pour l'authentification OAuth.

Serveurs Stdio (locaux)

Les serveurs locaux s'exécutent en tant que scripts :

# Via npx
claude mcp add my-server npx -y @modelcontextprotocol/server-filesystem /path/to/dir

# Via Python
claude mcp add my-db-server python /path/to/mcp_server.py

# Via Node.js
claude mcp add custom-tools node /path/to/server.js

Avec des variables d'environnement

claude mcp add my-server -e API_KEY=secret -e DB_URL=postgres://... npx my-mcp-server

Intégrations MCP populaires

GitHub

claude mcp add github --transport http https://api.github.com/mcp/

Outils disponibles :

• →get_issue / create_issue / update_issue
• →get_pull_request / create_pull_request
• →list_repos / search_code
• →get_file_contents / create_or_update_file

Utilisation :

> Create an issue for the login bug we discussed

Created issue #543: "Login fails when session expires"
Labels: bug
Assignee: @me

Sentry

claude mcp add sentry --transport http https://mcp.sentry.dev/mcp

Outils disponibles :

• →get_sentry_issues - Récupérer les issues d'erreur
• →search_sentry_errors - Rechercher par requête
• →get_issue_details - Détails d'erreur approfondis

Utilisation :

> Show me the most frequent errors this week

Top Sentry Issues (last 7 days):
1. TypeError: Cannot read 'map' of undefined
   - 342 events, 89 users affected
   - File: src/components/List.tsx:45
   
2. NetworkError: Failed to fetch
   - 156 events, 45 users affected
   - File: src/api/client.ts:23

PostgreSQL

claude mcp add postgres npx -y @modelcontextprotocol/server-postgres \
  "postgresql://user:pass@localhost:5432/mydb"

Outils disponibles :

• →query - Exécuter des requêtes de lecture
• →list_tables - Afficher le schéma de la base
• →describe_table - Structure d'une table

Utilisation :

> Show me users who signed up this month

Executing: SELECT * FROM users WHERE created_at >= '2026-01-01'

Results (23 rows):
id | email              | plan    | created_at
---+--------------------+---------+------------
 1 | alice@example.com  | pro     | 2026-01-02
 2 | bob@example.com    | free    | 2026-01-03
...

Filesystem

claude mcp add docs-fs npx -y @modelcontextprotocol/server-filesystem /path/to/docs

Accédez aux fichiers en dehors de votre répertoire de travail actuel.

Memory (stockage persistant)

claude mcp add memory npx -y @modelcontextprotocol/server-memory

Stockez et récupérez des données entre les sessions :

> Remember that the API key rotates every 30 days

Stored: api_key_rotation -> "30 days"

# Session ultérieure :
> When does the API key rotate?

Retrieved: The API key rotates every 30 days.

Configurer MCP dans les paramètres

Paramètres utilisateur

Configuration MCP globale dans ~/.claude/settings.json :

{
  "mcpServers": {
    "github": {
      "transport": "http",
      "url": "https://api.github.com/mcp/"
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/docs"],
      "env": {}
    },
    "custom-db": {
      "command": "python",
      "args": ["/path/to/db_server.py"],
      "env": {
        "DATABASE_URL": "postgresql://localhost/mydb"
      }
    }
  }
}

Paramètres du projet

MCP spécifique au projet dans .claude/settings.json :

{
  "mcpServers": {
    "project-db": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}

Utilisez ${VAR} pour référencer les variables d'environnement.

Permissions MCP

Contrôlez quels outils MCP Claude peut utiliser :

# Autoriser tous les outils d'un serveur
claude config add permissions.allow "mcp__github__*"

# Autoriser des outils spécifiques
claude config add permissions.allow "mcp__github__get_issue"
claude config add permissions.allow "mcp__github__create_issue"

# Interdire les opérations destructrices
claude config add permissions.deny "mcp__github__delete_repo"
claude config add permissions.deny "mcp__postgres__query" # bloquer toutes les requêtes DB

Voir Claude Code Permissions : modes Deny, Allow et Ask expliqués.

Créer des serveurs MCP personnalisés

Quand les serveurs existants ne répondent pas à vos besoins, construisez le vôtre.

Template serveur (TypeScript)

// server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-custom-server",
  version: "1.0.0",
});

// Define tools
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "get_weather",
      description: "Get weather for a city",
      inputSchema: {
        type: "object",
        properties: {
          city: { type: "string", description: "City name" }
        },
        required: ["city"]
      }
    }
  ]
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
  
  if (name === "get_weather") {
    const weather = await fetchWeather(args.city);
    return {
      content: [{ type: "text", text: JSON.stringify(weather) }]
    };
  }
  
  throw new Error(`Unknown tool: ${name}`);
});

// Start server
const transport = new StdioServerTransport();
await server.connect(transport);

Template serveur (Python)

# server.py
import json
import sys
from mcp.server import Server, stdio_transport

server = Server("my-python-server")

@server.list_tools()
async def list_tools():
    return [
        {
            "name": "analyze_logs",
            "description": "Analyze application logs",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "Log file path"},
                    "pattern": {"type": "string", "description": "Search pattern"}
                },
                "required": ["path"]
            }
        }
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "analyze_logs":
        result = analyze_logs(arguments["path"], arguments.get("pattern"))
        return {"content": [{"type": "text", "text": json.dumps(result)}]}
    
    raise ValueError(f"Unknown tool: {name}")

if __name__ == "__main__":
    stdio_transport.run(server)

Enregistrer votre serveur

claude mcp add my-server node /path/to/server.js
# ou
claude mcp add my-server python /path/to/server.py

Registre de serveurs MCP

Trouvez des serveurs construits par la communauté dans le registre MCP :

Serveurs officiels :

• →@modelcontextprotocol/server-filesystem
• →@modelcontextprotocol/server-postgres
• →@modelcontextprotocol/server-sqlite
• →@modelcontextprotocol/server-memory
• →@modelcontextprotocol/server-fetch

Serveurs communautaires :

• →Intégration Slack
• →Intégration Jira
• →Services AWS
• →Gestion Docker
• →Opérations Kubernetes

Installation depuis npm :

claude mcp add slack npx -y mcp-server-slack

Authentification

Flux OAuth (serveurs HTTP)

Les serveurs HTTP utilisent généralement OAuth :

1. →

   Ajoutez le serveur :

   claude mcp add github --transport http https://api.github.com/mcp/
   

2. →

   Claude Code ouvre le navigateur pour l'authentification

3. →

   Après autorisation, les tokens sont stockés de manière sécurisée

4. →

   Ré-authentifiez si nécessaire :

   > /mcp
   Select server > [o] Re-authenticate
   

Clés API (serveurs Stdio)

Passez les clés API via l'environnement :

claude mcp add weather -e WEATHER_API_KEY=abc123 npx weather-mcp-server

Ou dans les paramètres :

{
  "mcpServers": {
    "weather": {
      "command": "npx",
      "args": ["weather-mcp-server"],
      "env": {
        "WEATHER_API_KEY": "${WEATHER_API_KEY}"
      }
    }
  }
}

Définissez la variable d'environnement :

export WEATHER_API_KEY=abc123

Débogage MCP

Vérifier le statut du serveur

claude mcp list

Affiche l'état de connexion de chaque serveur.

Voir les logs du serveur

claude --verbose

Affiche les communications MCP :

[MCP] Connecting to github...
[MCP] github: authenticated
[MCP] Calling tool: get_issue(number=432)
[MCP] Response received (245 bytes)

Tester le serveur localement

# Tester un serveur stdio directement
echo '{"method":"tools/list"}' | node /path/to/server.js

Problèmes courants

Le serveur ne se connecte pas :

• →Vérifiez que le chemin de la commande est correct
• →Vérifiez que les dépendances sont installées
• →Vérifiez les variables d'environnement

Authentification expirée :

• →Utilisez /mcp > Re-authenticate
• →Ou supprimez et réajoutez le serveur

Échec des appels d'outils :

• →Vérifiez les logs du serveur pour les erreurs
• →Vérifiez que le schéma d'entrée correspond
• →Vérifiez les limites de taux de l'API

MCP en pratique

Workflow : correction automatisée de bugs

Combinez Sentry + GitHub + votre codebase :

> Find the most critical Sentry error and create a fix

[Querying Sentry...]
Found: TypeError in src/components/UserList.tsx:45
"Cannot read property 'map' of undefined"

[Analyzing code...]
Issue: `users` can be null when API fails

[Creating fix...]
Added null check and loading state

[Creating GitHub issue...]
Created #234: "Fix UserList crash on API failure"

[Creating PR...]
Created PR #235 with the fix

Workflow : développement basé sur la base de données

> Add a "last_login" field to the users table

[Querying schema via MCP...]
Current users table: id, email, name, created_at

[Generating migration...]
Created: migrations/20260112_add_last_login.sql

[Updating models...]
Modified: src/models/User.ts
Modified: src/types/user.ts

[Updating tests...]
Modified: tests/user.test.ts

Ready to run: npm run migrate

Workflow : synchronisation multi-plateforme

> Update all platforms with the new release

[Checking GitHub...]
Latest tag: v2.3.0

[Updating Linear...]
Marked related issues as completed

[Posting to Slack...]
Sent release announcement to #releases

[Updating Notion...]
Added release notes to documentation

Release v2.3.0 synchronized across all platforms.

Bonnes pratiques de sécurité MCP

1. Principe du moindre privilège

N'activez que les serveurs dont vous avez besoin :

# Bien : intégration spécifique
claude mcp add github --transport http ...

# À éviter : exposer le système de fichiers entier
claude mcp add fs npx server-filesystem /

2. Utilisez des variables d'environnement pour les secrets

Ne codez jamais les identifiants en dur :

{
  "mcpServers": {
    "db": {
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"  // Bien
        // "DATABASE_URL": "postgres://user:pass@..." // Mal
      }
    }
  }
}

3. Restreignez les permissions des outils

Bloquez les opérations destructrices :

claude config add permissions.deny "mcp__github__delete_*"
claude config add permissions.deny "mcp__postgres__query" # si lecture seule nécessaire

4. Auditez l'utilisation MCP

Examinez ce que Claude accède :

claude --verbose 2>&1 | grep "\[MCP\]"

Voir Claude Code Best Practices : sécurité, performance et équipes.

Points clés à retenir

1. →

   MCP étend la portée de Claude : Connectez-vous à n'importe quel service externe ou source de données.

2. →

   Deux types de transport : HTTP pour les SaaS avec OAuth, stdio pour les scripts locaux.

3. →

   Facile à ajouter : claude mcp add gère la configuration.

4. →

   Construisez le vôtre : Les SDK TypeScript et Python rendent la création de serveurs personnalisés simple.

5. →

   La sécurité compte : Utilisez les permissions pour contrôler quels outils Claude peut accéder.

Approfondissement : Cours MCP Avancés

Contenu du Cours "Introduction to MCP" (Skilljar)

Le cours officiel Anthropic couvre les fondamentaux :

• →Architecture client-serveur MCP
• →Protocole de communication (JSON-RPC 2.0)
• →Types de capacités : Resources, Tools, Prompts
• →Cycle de vie d'une connexion MCP
• →Installation et configuration de base

Contenu du Cours "MCP Advanced Topics"

Les sujets avancés incluent :

• →Serveurs MCP personnalisés : Créer vos propres serveurs pour des cas d'usage spécifiques
• →Gestion des erreurs : Stratégies de retry, timeouts, fallbacks
• →Sécurité : Authentification, autorisation, sandboxing
• →Performance : Mise en cache des résultats, connexions persistantes
• →Multi-serveurs : Orchestrer plusieurs serveurs MCP simultanément

Serveurs MCP Populaires à Connaître

📚 Allez plus loin : Découvrez notre guide complet de l'API Claude pour comprendre l'écosystème technique complet.

Maîtrisez les interactions API

MCP ouvre la porte aux intégrations API. Apprenez à travailler efficacement avec les API dans vos prompts.

Dans notre Module 5, Travailler avec les API, vous apprendrez :

• →Le prompting pour les interactions API
• →La gestion de l'authentification dans les prompts
• →Les patterns de gestion d'erreurs
• →La construction de workflows propulsés par les API

→ Explorer le Module 5 : Travailler avec les API