Tu utilises l'IA pour coder. Tu lui poses des questions, tu colles des logs d'erreur, tu la laisses écrire une fonction ou deux. Elle répond avec ce qu'elle sait — c'est-à-dire ce qu'elle a appris pendant l'entraînement, figé dans le temps comme un mammouth dans la glace. Elle ne peut pas vérifier ta base de données. Elle ne peut pas ouvrir ton GitHub. Elle ne peut pas chercher si cette lib que tu t'apprêtes à installer a été abandonnée depuis 2023. Ton IA vit dans une boîte. 😼

La boîte, c'est le problème. Une IA qui ne peut pas toucher à ton infrastructure réelle n'est qu'un canard en plastique très éloquent.

Ça a changé en novembre 2024 quand Anthropic a sorti MCP (Model Context Protocol) — un standard pour connecter les outils IA à des services externes. Imagine des ports USB pour ton IA : tu branches un ' serveur ' (un petit programme en arrière-plan), et d'un coup ton agent IA peut interroger des bases de données, gérer des issues GitHub, chercher sur le web, ou piloter un navigateur. En mars 2026, le registre officiel des serveurs MCP en liste des milliers. La plupart sont des démos. Certains sont cassés. Cinq comptent vraiment au quotidien.

Je vais te les présenter un par un, avec des instructions d'installation que tu peux copier-coller en moins de cinq minutes.

Avant de commencer : où se trouvent les configs MCP

Les serveurs MCP fonctionnent avec n'importe quel client compatible MCP — Claude Code, Claude Desktop, Cursor, Windsurf, Cline. Je donne les exemples pour Claude Code, mais le format de config est quasi identique partout.

Ton fichier de config se trouve ici :

# Claude Code (niveau projet)
.mcp.json

# Claude Code (global)
~/.claude.json

# Claude Desktop
~/Library/Application Support/Claude/claude_desktop_config.json  # macOS
~/.config/Claude/claude_desktop_config.json                       # Linux

Chaque serveur suit le même schéma :

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@package/server-name"],
      "env": {
        "API_KEY": "your-key-here"
      }
    }
  }
}

npx lance un paquet Node.js sans l'installer globalement. Le flag -y passe la confirmation automatiquement. C'est tout le cérémonial. Passons aux choses sérieuses.

1. PostgreSQL — parle à ta base de données en français

Ce que ça fait : Ton IA lit le schéma de ta base de données (la structure — tables, colonnes, types), exécute des requêtes SQL (le langage des bases de données), et renvoie des résultats réels. Fini le copier-coller depuis ton terminal vers le chat.

Pourquoi ça t'intéresse : La moitié du développement, c'est ' vérifier la base, comprendre les données, écrire une requête '. Ce serveur transforme tout ça en conversation.

Config :

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@localhost:5432/mydb"
      ]
    }
  }
}

Tu dis : ' Montre-moi tous les utilisateurs inscrits cette semaine qui n'ont jamais rien acheté. ' Claude exécute du vrai SQL sur ta base. Des vraies données reviennent. Tu dis : ' Crée un index pour accélérer ça. ' Claude analyse le plan d'exécution et construit le bon index.

Le serveur expose trois outils : query (exécuter du SQL en lecture seule), list_tables, et describe_table.

Sécurité : Crée un utilisateur en lecture seule. Ne file jamais tes identifiants admin à un outil automatisé :

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

Verdict : Premier serveur que j'installe sur chaque projet. Économise 30+ minutes par jour d'archéologie copier-coller. 😸

2. GitHub — les repos sans le navigateur

Ce que ça fait : Intégration GitHub complète — issues, pull requests (PR — des propositions de modifications de code), recherche de code, opérations sur les fichiers. Le tout via ton agent IA.

Pourquoi ça t'intéresse : Alterner entre terminal, chat et GitHub tue la concentration. Ce serveur te garde au même endroit.

Config :

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

Tu as besoin d'un personal access token — récupère-le sur github.com/settings/tokens. Scopes nécessaires : repo, read:org, read:user.

Maintenant tu peux dire : ' Crée une issue pour le bug de timeout du login avec la stack trace que je viens de te montrer. ' Ou : ' Review la PR #47 et commente les problèmes de sécurité. ' Claude lit le diff, analyse le code, poste de vrais commentaires de review sur GitHub.

Outils clés : create_issue, list_pull_requests, search_code, create_branch, get_file_contents. Plus d'une douzaine au total.

Coup de maître : Combine ça avec le serveur Postgres. ' Vérifie les logs d'erreur dans la base, trouve le code correspondant sur GitHub, crée une issue avec les deux. ' Un prompt. Trois outils. Zéro onglet de navigateur. 😹

Verdict : Deuxième serveur que j'installe. L'interface web de GitHub est bien pour naviguer. Pour bosser, c'est plus rapide.

3. Filesystem — accès fichiers contrôlé avec garde-fous

Ce que ça fait : Donne à ton agent IA l'accès pour lire, écrire, chercher et gérer des fichiers — mais uniquement dans les répertoires que tu autorises explicitement. Il ne peut pas aller fouiner dans tes clés SSH ou tes fichiers .env.

Config :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/home/user/projects",
        "/home/user/documents"
      ]
    }
  }
}

Liste plusieurs répertoires — le serveur restreint l'accès uniquement à ces chemins. Il bloque les tentatives de traversée de chemin (des trucs du genre ../../etc/passwd).

Outils : read_file, write_file, create_directory, list_directory, move_file, search_files, read_multiple_files.

Qui en a besoin : Principalement les utilisateurs de Claude Desktop. Claude Code a déjà un accès fichier intégré, donc ce serveur est redondant. Mais pour Claude Desktop — où l'IA ne peut sinon pas toucher à tes fichiers du tout — c'est indispensable. Le sandboxing de répertoires (restreindre l'accès à des dossiers spécifiques) est une vraie bonne feature de sécurité.

Verdict : Passe-le si tu utilises Claude Code. Installe-le immédiatement si tu utilises Claude Desktop.

4. Brave Search — données web en temps réel

Ce que ça fait : Recherche web via l'API Brave Search. Ton IA cherche en direct au lieu de deviner à partir de ses données d'entraînement.

Pourquoi ça t'intéresse : ' Quel est le prix actuel d'un Hetzner CAX11 ? ' ' Cette lib est encore maintenue ? ' ' C'est quoi la dernière version de Next.js ? ' Ces questions ont besoin de réponses en temps réel. Les données d'entraînement ne savent pas ce qui s'est passé mardi dernier.

Config :

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_your_key_here"
      }
    }
  }
}

Récupère une clé API gratuite sur brave.com/search/api. Tier gratuit : 2 000 requêtes/mois, 1 requête/seconde. Pour un dev solo, c'est largement suffisant. Le tier payant commence à 5 $/mois pour 20 000 requêtes si tu crames la limite gratuite.

Deux outils : brave_web_search (recherche web générale avec pagination) et brave_local_search (recherche de commerces locaux).

Utilisation maligne : Valide les suggestions d'architecture de ton IA avant de t'engager. ' Cherche les problèmes connus avec Prisma 6.x et PostgreSQL 17 ' est un excellent check de santé mentale avant de te retrouver trois jours dans une implémentation.

Verdict : Comble la plus grosse lacune de l'IA pour le code — l'incapacité de vérifier ce qui est vrai maintenant. 😼

5. Puppeteer — automatisation du navigateur par la conversation

Ce que ça fait : Contrôle un navigateur headless (un navigateur Chromium qui tourne de manière invisible, sans fenêtre). Ton IA navigue sur des pages, prend des captures d'écran, clique sur des boutons, remplit des formulaires, extrait du contenu de sites rendus en JavaScript.

Config :

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

Pas de clés API. Pas de configuration. Puppeteer télécharge Chromium automatiquement.

Outils : puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate (exécuter du JavaScript dans la page).

Dis : ' Va sur localhost:3000, screenshot la page de login, dis-moi si elle s'affiche correctement. ' Puis : ' Remplis les identifiants de test et soumets. ' Claude navigue, remplit les champs, clique sur soumettre, screenshot le résultat.

Je l'utilise pour les tests de régression visuelle — ' Navigue sur chaque route et screenshot-la ' me donne un snapshot visuel que Claude peut comparer avec les layouts attendus. Pas de setup Playwright, pas de framework de test. Juste ' va regarder la page '.

Attention : Ça lance un vrai navigateur. Chaque instance bouffe 200-500 Mo de RAM. Ne le laisse pas tourner sur un laptop à la RAM comptée. Le serveur nettoie automatiquement quand tu fermes ton client MCP.

Verdict : Le serveur le plus fun de cette liste. Automatiser un navigateur en langage naturel, c'est sincèrement jouissif. Indispensable pour le frontend et le web scraping. 😸

La config complète — copie et colle

Les cinq serveurs, un seul fichier :

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://mcp_readonly:password@localhost:5432/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/home/user/projects"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_xxx"
      }
    },
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Remplace les valeurs par tes vrais identifiants. Sauvegarde dans .mcp.json à la racine de ton projet ou ~/.claude.json pour un accès global.

En trouver d'autres (et savoir quand s'arrêter)

Le registre officiel se trouve sur github.com/modelcontextprotocol/servers. mcpservers.org liste les serveurs communautaires. Jette un œil si t'es curieux.

Mais résiste à l'envie d'installer 15 serveurs ' au cas où '. Chacun est un processus qui tourne. Chacun ajoute du temps de démarrage. Chacun est une surface d'attaque — un point d'entrée potentiel pour des problèmes de sécurité. 80 % des développeurs ont besoin de deux ou trois serveurs, max.

T'es dangereux maintenant

Tu as commencé avec une IA qui vivait dans une boîte de texte. Maintenant t'en as une qui interroge ta base de données, gère ton GitHub, cherche sur le web en direct, et pilote un navigateur. Le protocole en dessous — JSON-RPC (un format de messages simple) sur stdio (entrée/sortie standard, la façon dont les programmes se parlent) — est ennuyeux. Les protocoles ennuyeux qui marchent, c'est exactement ce dont on avait besoin.

Ces cinq serveurs couvrent 90 % des besoins d'un dev solo. Tout le reste dans le répertoire MCP, c'est soit de l'outillage de niche pour des cas spécifiques, soit une démo qui cassera dès que tu en dépendras pour de vrai. Commence par Postgres et GitHub. Ajoute Brave Search quand tu as besoin de données en temps réel. Ajoute Puppeteer quand tu veux te sentir en 2030.

La boîte est ouverte. Ton IA a des mains maintenant. Essaie de ne rien lui laisser casser d'important. 😹