Maîtriser Claude Code de A à Z : CLAUDE.md, mémoire persistante, skills custom, agents parallèles, MCP et hooks — pour transformer Claude en collaborateur de développement sur mesure.
MCP (Model Context Protocol) est le protocole ouvert d'Anthropic qui permet à Claude de se connecter à des serveurs d'outils externes. GitHub, Notion, Slack, une base de données, une API interne — chaque intégration est un serveur MCP que Claude peut appeler comme il appelle ses outils natifs.
Un serveur MCP est un processus qui expose des outils à Claude via un protocole standardisé. Claude découvre les outils disponibles au démarrage et peut les invoquer comme n'importe quel outil natif.
Claude Code
│
├── Outils natifs (Read, Edit, Bash, Glob, Grep...)
│
└── Serveurs MCP
├── mcp-github (créer PRs, lire issues, commenter)
├── mcp-notion (lire/écrire des pages)
├── mcp-postgres (requêtes SQL directes)
└── mon-api-interne (outils custom)Les serveurs MCP se configurent dans settings.json — global (~/.claude/settings.json) ou projet (.claude/settings.json).
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
}
},
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost/mydb"
}
},
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/william/Documents"
]
}
}
}Claude lance ces processus au démarrage et communique avec eux via stdio.
# GitHub — issues, PRs, repos, code search
npx @modelcontextprotocol/server-github
# Filesystem — accès à des dossiers hors du projet courant
npx @modelcontextprotocol/server-filesystem /path/to/dir
# PostgreSQL — requêtes SQL en langage naturel
npx @modelcontextprotocol/server-postgres
# Brave Search — recherche web
npx @modelcontextprotocol/server-brave-search
# Fetch — lire des URLs web
npx @modelcontextprotocol/server-fetch
# Slack — messages, canaux
npx @modelcontextprotocol/server-slack
# Notion — pages, databases
npx @modelcontextprotocol/server-notionhq-mcpUne fois configuré, Claude utilise les outils MCP naturellement :
> ouvre un ticket GitHub pour le bug d'authentification qu'on vient de trouverClaude appelle l'outil create_issue du serveur GitHub avec le titre et la description générés depuis le contexte de la conversation.
> cherche dans la base de données tous les utilisateurs créés cette semaineClaude génère une requête SQL, l'exécute via le serveur MCP PostgreSQL, interprète les résultats.
> crée une page Notion avec le résumé du sprintClaude structure les informations de la conversation et les écrit dans Notion via MCP.
Pour des besoins spécifiques — API interne, outil propriétaire — on peut créer un serveur MCP custom.
npm install @modelcontextprotocol/sdk// mon-serveur-mcp.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import {
CallToolRequestSchema,
ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js'
const server = new Server(
{ name: 'mon-api-interne', version: '1.0.0' },
{ capabilities: { tools: {} } }
)
// Déclarer les outils disponibles
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: [
{
name: 'get_user',
description: 'Récupère un utilisateur par son ID depuis l\'API interne',
inputSchema: {
type: 'object',
properties: {
userId: { type: 'string', description: 'ID de l\'utilisateur' },
},
required: ['userId'],
},
},
{
name: 'list_orders',
description: 'Liste les commandes d\'un utilisateur',
inputSchema: {
type: 'object',
properties: {
userId: { type: 'string' },
limit: { type: 'number', default: 10 },
},
required: ['userId'],
},
},
],
}))
// Implémenter les outils
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params
if (name === 'get_user') {
const response = await fetch(`https://api.monapp.fr/users/${args.userId}`, {
headers: { Authorization: `Bearer ${process.env.API_KEY}` },
})
const user = await response.json()
return {
content: [{ type: 'text', text: JSON.stringify(user, null, 2) }],
}
}
if (name === 'list_orders') {
const response = await fetch(
`https://api.monapp.fr/users/${args.userId}/orders?limit=${args.limit ?? 10}`,
{ headers: { Authorization: `Bearer ${process.env.API_KEY}` } }
)
const orders = await response.json()
return {
content: [{ type: 'text', text: JSON.stringify(orders, null, 2) }],
}
}
throw new Error(`Outil inconnu : ${name}`)
})
// Démarrer le serveur
const transport = new StdioServerTransport()
await server.connect(transport)Configurer dans settings.json :
{
"mcpServers": {
"mon-api": {
"command": "node",
"args": ["/chemin/vers/mon-serveur-mcp.js"],
"env": {
"API_KEY": "sk-..."
}
}
}
}Maintenant Claude peut :
> cherche l'utilisateur 42 et liste ses 5 dernières commandesLes serveurs MCP peuvent aussi exposer des "resources" — du contenu que Claude peut lire sans appeler un outil.
import { ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js'
server.setRequestHandler(ListResourcesRequestSchema, async () => ({
resources: [
{
uri: 'config://app/env',
name: 'Variables d\'environnement',
mimeType: 'application/json',
},
],
}))
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
if (request.params.uri === 'config://app/env') {
return {
contents: [{
uri: 'config://app/env',
mimeType: 'application/json',
text: JSON.stringify(process.env, null, 2),
}],
}
}
})> liste les outils MCP disponibles dans cette sessionClaude liste tous les outils des serveurs MCP connectés avec leurs descriptions.
Si un serveur MCP ne répond pas :
# Tester le serveur manuellement
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node mon-serveur-mcp.js
# Voir les logs Claude Code
claude --mcp-debugDans settings.json, activer les logs :
{
"mcpServers": {
"mon-api": {
"command": "node",
"args": ["mon-serveur-mcp.js"],
"debug": true
}
}
}Les serveurs MCP tournent avec les permissions du processus Claude Code. Pour des serveurs qui accèdent à des ressources sensibles :
settings.json — utiliser des variables d'environnement.claude/settings.json) sont commités — ne jamais y mettre de secrets{
"mcpServers": {
"postgres": {
"env": {
"POSTGRES_CONNECTION_STRING": "${POSTGRES_DEV_URL}"
}
}
}
}${VAR} est remplacé par la variable d'environnement du shell au moment du lancement.
MCP ouvre Claude sur l'ensemble de votre stack. Le dernier chapitre couvre les hooks et settings.json — l'automatisation fine : ce qui se passe avant et après chaque outil, comment restreindre les permissions, comment personnaliser chaque aspect du comportement.