Model Context Protocol (MCP) pour Claude Code : guide complet

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