Intégrations

Intégrations Claude Code : Serveurs MCP, IDE et CI/CD

Charles Krzentowski9 min read

Claude Code est puissant tout seul. Il lit vos fichiers, écrit du code, exécute des commandes. Mais pour l'instant, chaque fois que vous avez besoin qu'il connaisse quelque chose en dehors de votre projet — un schéma de base de données, une issue GitHub, une erreur Sentry — vous faites du copier-coller. Vous êtes l'intermédiaire.

Et si Claude pouvait simplement... aller chercher cette information lui-même ?

C'est exactement ce que font les serveurs MCP. Seulement 8% des setups dans notre analyse les configurent, mais ceux qui le font obtiennent 7.5/10 en moyenne. La raison est simple : les serveurs MCP éliminent la taxe du copier-coller qui mange la majorité du temps de session.

Mettons-en un en place maintenant. Vous l'aurez fonctionnel en moins de cinq minutes.

Votre premier serveur MCP : GitHub

MCP signifie Model Context Protocol. C'est un standard ouvert qui permet à Claude de communiquer avec des services externes via une interface structurée. Un serveur MCP est un petit programme qui tourne en arrière-plan et donne à Claude l'accès à des outils — comme chercher des issues, interroger des bases de données, ou lire de la documentation.

Commençons par le serveur MCP GitHub parce que la mise en place est ultra-simple et le bénéfice est immédiat.

Ajoutez ceci à votre .claude/settings.json :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_votre_token_ici"
      }
    }
  }
}

Vous aurez besoin d'un Personal Access Token GitHub. Allez dans GitHub > Settings > Developer Settings > Personal access tokens > Generate new token. Donnez-lui le scope repo.

Maintenant relancez Claude Code et essayez ceci :

> Liste mes 5 dernières pull requests

Claude ne vous demande rien à coller. Il appelle le serveur MCP GitHub, récupère vos PRs, et les affiche. Essayez maintenant :

> Quel est le statut de l'issue #42 ? Lis les commentaires aussi.

Claude récupère l'issue, lit la discussion, et a tout le contexte. Quand vous dites « travaille sur l'issue #42 », il sait vraiment ce que dit l'issue #42 — sans que vous copiiez la description dans le chat.

C'est tout l'intérêt de MCP : Claude obtient le contexte lui-même au lieu que vous fassiez le coursier.

Le serveur MCP base de données (celui qui change tout)

Si vous utilisez PostgreSQL, c'est le serveur MCP qui vous fera vous demander comment vous faisiez avant.

Ajoutez à .claude/settings.json :

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://dev:dev@localhost:5432/myapp_dev"
      }
    }
  }
}

Ce que ça débloque :

  • Claude lit vos vrais schémas de tables avant d'écrire des requêtes — plus de devinettes sur les noms de colonnes
  • Il peut exécuter des requêtes SELECT pour comprendre la forme des données
  • La génération de migrations devient précise parce que Claude voit le vrai schéma actuel
  • Les erreurs de noms de colonnes sont attrapées avant d'exécuter le code

Important : Utilisez un utilisateur base de données en lecture seule. Claude n'a pas besoin d'accès en écriture pour comprendre votre schéma :

CREATE USER claude_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE myapp_dev TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;

Essayez. Demandez à Claude : « Montre-moi le schéma de la table users. » Il interroge la base de données directement et vous donne les colonnes exactes, types et contraintes. Plus de « Je suppose que le schéma ressemble à ça. »

D'autres serveurs MCP qui valent la mise en place

Une fois que vous avez compris le principe, voici les autres serveurs qui méritent leur place :

Slack — chercher dans les conversations d'équipe

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-votre-token-bot"
      }
    }
  }
}

Vous travaillez sur une fonctionnalité discutée sur Slack la semaine dernière ? Au lieu de résumer la conversation vous-même, Claude la cherche directement.

Sentry — récupérer les rapports d'erreurs

{
  "mcpServers": {
    "sentry": {
      "command": "npx",
      "args": ["-y", "@sentry/mcp-server"],
      "env": {
        "SENTRY_AUTH_TOKEN": "votre_token_sentry",
        "SENTRY_ORG": "votre-org",
        "SENTRY_PROJECT": "votre-projet"
      }
    }
  }
}

Vous déboguez une erreur en production ? Claude récupère la stack trace exacte, le nombre d'utilisateurs affectés et la fréquence de l'erreur depuis Sentry. Plus besoin de screenshotter des rapports d'erreurs et de les coller dans le chat.

Context7 — documentation en temps réel

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  }
}

Celui-ci est discrètement très utile. Au lieu de se fier aux données d'entraînement (qui peuvent être obsolètes), Claude récupère la documentation actuelle pour la version exacte de la bibliothèque que vous utilisez. Particulièrement pratique pour les bibliothèques qui évoluent vite comme Next.js, React ou Prisma où l'API change entre les versions.

Filesystem — accéder à des fichiers hors de votre projet

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/Users/vous/projets/libs-partagees",
        "/Users/vous/projets/design-system"
      ]
    }
  }
}

Vous travaillez dans un monorepo ? Besoin que Claude référence votre design system en éditant une fonctionnalité ? Le serveur filesystem lui donne accès à des répertoires en dehors du projet courant.

Intégration IDE : rejoindre Claude là où vous codez

VS Code

La façon la plus rapide de démarrer :

  1. Installez l'extension Claude Code depuis le marketplace VS Code
  2. Ouvrez votre projet
  3. Appuyez sur Cmd+Shift+P (Mac) ou Ctrl+Shift+P (Windows/Linux) et tapez « Claude »
  4. Sélectionnez « Claude Code: Open Panel »

L'extension VS Code donne à Claude accès à vos fichiers ouverts, sortie du terminal, erreurs TypeScript, avertissements ESLint — tout sans copier-coller.

JetBrains (IntelliJ, WebStorm, PyCharm)

Ouvrez le terminal intégré dans votre IDE JetBrains et lancez claude. Il fonctionne dans le panneau terminal avec accès complet à votre projet. Le plugin JetBrains (actuellement en bêta) ajoute des suggestions inline et un panneau de chat dans l'IDE.

Terminal avec tmux

Si vous vivez dans le terminal, ce pattern fonctionne bien — Claude dans un volet, votre éditeur dans l'autre :

tmux new-session -d -s dev
tmux split-window -h
tmux send-keys -t dev:0.1 'claude' Enter
tmux attach -t dev

Vous codez à gauche, Claude tourne à droite. Même répertoire de projet, zéro changement de contexte.

CI/CD : Claude review chaque PR automatiquement

C'est là que Claude Code passe d'outil personnel à infrastructure d'équipe.

Revue de PR automatisée avec GitHub Actions

Créez .github/workflows/claude-review.yml :

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Claude Code Review
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Revois cette pull request. Vérifie :
            1. Problèmes de sécurité (injection SQL, XSS, secrets exposés)
            2. Problèmes de performance (requêtes N+1, index manquants)
            3. Gestion d'erreurs manquante
            4. Lacunes dans la couverture de tests

            Poste ta revue en commentaire de PR avec des sections CRITIQUE et INFORMATIONNEL.

Chaque PR reçoit une revue approfondie avant qu'un humain n'y jette un œil. Les problèmes mécaniques sont attrapés automatiquement, pour que vos reviewers humains puissent se concentrer sur l'architecture et les décisions de design.

Triage d'issues automatisé

name: Issue Triage
on:
  issues:
    types: [opened]

jobs:
  triage:
    runs-on: ubuntu-latest
    permissions:
      issues: write
    steps:
      - uses: actions/checkout@v4

      - name: Triage Issue
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Analyse cette issue GitHub. En te basant sur le codebase :
            1. Identifie quels fichiers sont probablement affectés
            2. Estime la complexité (triviale / modérée / complexe)
            3. Suggère des labels pertinents
            4. S'il s'agit d'un bug, essaie d'identifier la cause racine

            Poste ton analyse en commentaire.

Les nouvelles issues sont analysées automatiquement — fichiers affectés identifiés, complexité estimée, labels suggérés. Votre équipe passe moins de temps à trier et plus de temps à construire.

Mode headless pour le scripting

Claude Code peut tourner en mode non-interactif pour l'automatisation personnalisée :

# Exécuter un prompt unique et quitter
claude -p "Lance la suite de tests et rapporte les échecs" --output-format json

# Envoyer de l'entrée via pipe
echo "Explique l'architecture de ce projet" | claude -p --output-format text

# Utiliser dans un script
RESULT=$(claude -p "Vérifie s'il y a des commentaires TODO dans src/" --output-format json)
echo "$RESULT" | jq '.output'

C'est la brique de base pour des étapes CI/CD personnalisées, des hooks de pre-commit, et tout workflow où vous voulez que Claude fasse un job spécifique et rapporte le résultat.

Gardez vos tokens en sécurité

Les serveurs MCP tournent avec vos credentials. Prenez ça au sérieux.

Ne commitez jamais de tokens dans settings.json. Utilisez des références à des variables d'environnement à la place :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Utilisez des credentials en lecture seule partout où c'est possible. Claude a rarement besoin d'accès en écriture à votre base de données ou GitHub.

Scopez à ce dont vous avez besoin. Ne connectez pas une base de données de production — utilisez dev ou staging.

Revoyez le code des serveurs MCP. Ce sont des packages npm qui tournent avec vos credentials. Vérifiez la source, préférez les packages officiels, et fixez les versions.

Le setup complet

Voici le settings.json complet pour un projet bien intégré — permissions, serveurs MCP et hooks qui travaillent ensemble :

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git *)",
      "Read",
      "Glob",
      "Grep"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force*)"
    ]
  },
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DEV_DATABASE_URL}"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": ".claude/hooks/pre-tool-guard.sh"
      }
    ]
  }
}

Accès au schéma base de données, issues GitHub et PRs, documentation en temps réel, gardes de sécurité, et permissions sensées. C'est un environnement de développement connecté, pas un chatbot isolé.

Pour aller plus loin

Avec les intégrations en place, Claude Code arrête d'être un outil dans lequel vous collez du contexte et commence à être un outil qui va chercher son propre contexte. Les prochaines étapes :

  • Patterns de workflow — subagents, orchestration de revue de code, et les stratégies de débogage des power users
  • Optimisation des coûts — les serveurs MCP ajoutent de la consommation de tokens, alors ces stratégies gardent votre facture sous contrôle
  • Évaluer votre setup pour voir comment vos intégrations se comparent aux meilleures configurations

Questions fréquentes

Combien de serveurs MCP puis-je exécuter en même temps ?

Il n'y a pas de limite stricte, mais chaque serveur est un processus séparé qui utilise de la mémoire et du CPU. En pratique, 3-5 c'est le sweet spot. Au-delà, le temps de démarrage augmente et le contexte de Claude se remplit de descriptions d'outils. Commencez par les serveurs qui vous épargnent le plus de copier-coller — typiquement base de données et GitHub.

Les serveurs MCP fonctionnent-ils avec le plan Max, ou seulement l'API ?

Les deux. Les serveurs MCP tournent localement sur votre machine quel que soit le mode de facturation. La seule différence de coût : les appels d'outils MCP génèrent des tokens supplémentaires (descriptions, entrées, sorties), ce qui compte plus avec la tarification API au token qu'avec le plan Max forfaitaire.

Puis-je écrire mon propre serveur MCP ?

Oui, et c'est plus simple que vous ne le pensez. Un serveur MCP communique via stdio en JSON-RPC. Le package @modelcontextprotocol/sdk fournit des helpers TypeScript :

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

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

server.setRequestHandler("tools/list", async () => ({
  tools: [{ name: "my_tool", description: "Does something useful", inputSchema: { type: "object" } }]
}));

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

Il existe aussi des SDKs pour Python, Go et Rust.

L'intégration GitHub Actions est-elle sûre ?

L'action officielle anthropics/claude-code-action tourne dans un environnement CI sandboxé. Elle ne peut accéder qu'à ce que vous accordez via les permissions GitHub Actions (contents: read, pull-requests: write). Stockez votre clé API Anthropic comme secret GitHub, jamais en dur. Le principal risque est le coût — une action incontrôlée sur un repo actif peut générer de gros frais API. Mettez des alertes de dépenses et limitez les événements qui déclenchent l'action.

Pourquoi utiliser MCP plutôt que dire à Claude de lancer des commandes shell ?

Les commandes shell fonctionnent, mais elles sont fragiles. Avec un serveur MCP PostgreSQL, Claude appelle query("SELECT * FROM users LIMIT 5") — il n'a pas besoin de trouver votre chaîne de connexion psql, de gérer l'authentification, ou de parser une sortie tabulaire. MCP donne à Claude un accès typé et structuré à vos outils. Moins d'erreurs, résultats plus fiables, et vous pouvez donner un accès en lecture à la base de données sans donner un accès shell complet.