Serveurs MCP dans Cursor

Problème : Cursor peut se connecter à des outils et données externes, mais la partie MCP reste floue jusqu'à ce que tu l'aies fait une fois. Quel fichier ? Quel format ? C'est pareil que Claude Code ?

Gain immédiat : Crée .cursor/mcp.json à la racine de ton projet et colle un premier serveur :

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

Redémarre Cursor. La recherche web est maintenant dans l'IDE.

Si tu choisis encore quels serveurs valent ton temps, commence par MCP Search Tools avant de les câbler dans Cursor. Lis cette page une fois que tu connais la catégorie de serveur que tu veux et que tu as besoin du format de config Cursor exact, des emplacements de fichiers et du schéma de déploiement. Si tu conçois ta propre intégration plutôt qu'installer une existante, lis Custom MCP Integrations.

Ce que sont vraiment les serveurs MCP dans Cursor

Les outils externes, les bases de données et les API se connectent toutes à l'IA de Cursor via le Model Context Protocol. Le comportement est identique entre Cursor, Claude Code et Claude Desktop parce que chacun parle le même format de transport.

Une fois un serveur chargé, Cursor peut faire les choses suivantes :

• Récupérer du contenu web et de la documentation
• Interroger des bases de données en anglais simple
• Piloter GitHub, Slack, et tout ce qui a une intégration
• Lancer des tâches navigateur pour les tests
• Atteindre n'importe quel service qui expose un serveur MCP

L'écosystème est partagé. N'importe quel serveur MCP construit pour Claude Desktop se glisse dans Cursor sans modification.

Configurer les serveurs MCP dans Cursor

Emplacements des fichiers de configuration

Il y a deux endroits valides :

Les configs de projet sont le bon choix pour les outils liés à un seul codebase, comme un serveur de base de données pour l'app que tu construis. Les configs globales conviennent aux outils qui appartiennent partout, comme la recherche web ou une intégration GitHub.

Configuration étape par étape

Méthode 1 : Configuration manuelle

1. Crée le fichier de config dans .cursor/mcp.json (projet) ou ~/.cursor/mcp.json (global)
2. Colle la configuration du serveur
3. Redémarre Cursor pour que les nouveaux serveurs soient récupérés
4. Teste en demandant à l'IA de lancer un outil du serveur

Méthode 2 : Palette de commandes

1. Ouvre la palette de commandes (Cmd+Shift+P sur Mac, Ctrl+Shift+P sur Windows)
2. Cherche "MCP" et sélectionne "View: Open MCP Settings"
3. Sous MCP Tools, clique "New MCP Server"
4. Cursor écrit le fichier mcp.json et l'ouvre pour édition

Format de configuration

La forme JSON correspond à ce qu'utilise Claude Desktop :

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

Un serveur MCP basé sur Python ressemble presque pareil :

{
  "mcpServers": {
    "python-server": {
      "command": "python",
      "args": ["path/to/server.py"],
      "env": {
        "DATABASE_URL": "postgresql://db-host/example_db"
      }
    }
  }
}

Configuration de serveur distant

Les serveurs basés sur HTTP sont aussi supportés :

{
  "mcpServers": {
    "remote-server": {
      "url": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

Pratique quand le serveur tourne sur une autre machine ou se cache derrière un service partagé.

Les meilleurs serveurs MCP pour Cursor

Ceux qui apportent le plus de valeur par ligne de config. Chacun se glisse directement dans .cursor/mcp.json :

Recherche web et documentation

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

Recherche web dans Cursor pour les lookups de documentation et la recherche rapide.

Intégration GitHub

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

Dépôts, issues, PRs et reviews sans quitter l'éditeur.

Accès base de données

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

Requêtes en langage naturel en entrée, schéma et résultats en sortie, pendant le code.

Automatisation navigateur

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

Couvre les tests navigateur, le scraping et les vérifications visuelles. Voir le guide d'automatisation navigateur pour les patterns plus avancés.

Opérations sur les fichiers

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/directory"
      ]
    }
  }
}

Lit et écrit des fichiers en dehors des répertoires que Cursor surveille déjà.

Mémoire et connaissances

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

Maintient un graphe de connaissances qui persiste entre les sessions.

Le catalogue complet de serveurs MCP a 50+ options supplémentaires.

Cursor vs Claude Code MCP

Les configs de serveur passent entre les deux outils avec presque aucune friction, puisque les deux parlent Model Context Protocol. Quelques différences subsistent quand même :

MCP Tool Search dans Claude Code charge les outils en lazy-loading et réduit l'utilisation du contexte de 95%. Cursor tire chaque outil configuré au démarrage de session.

Les packages de serveurs restent les mêmes des deux côtés. Une config écrite pour Claude Desktop tourne dans Cursor, et l'inverse est vrai aussi.

Résolution de problèmes des serveurs MCP dans Cursor

Serveur qui ne se charge pas

Symptôme : Le serveur MCP n'apparaît jamais parmi les outils disponibles.

Correction :

1. Vérifie le JSON (une virgule en trop est le coupable habituel)
2. Quitte Cursor complètement et relance, pas juste rechargé la fenêtre
3. Ouvre le panneau Output et cherche les erreurs MCP

Authentification échouée

Symptôme : Le serveur se charge, mais les appels API reviennent avec des erreurs d'auth.

Correction : Vérifie que les variables d'environnement sont bien définies :

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

Le pattern ${env:VAR_NAME} tire depuis les variables d'environnement système pour que les secrets n'atterrissent jamais en dur dans le code.

Commande npx introuvable

Symptôme : Le serveur plante avec une erreur "command not found".

Correction : Confirme que Node.js est installé et que npx est dans ton PATH. Certains systèmes ont besoin du chemin absolu :

{
  "mcpServers": {
    "server-name": {
      "command": "/usr/local/bin/npx",
      "args": ["-y", "@modelcontextprotocol/server-name"]
    }
  }
}

Problèmes de connexion au serveur distant

Symptôme : Un serveur basé sur HTTP refuse de se connecter.

Correction :

1. Confirme que le processus serveur tourne et est joignable
2. Vérifie les règles de pare-feu autour du port
3. Assure-toi que l'URL porte le bon protocole (http vs https)

Prochaines étapes

Un court chemin pour faire grandir ton setup MCP Cursor :

1. Commence simplement : Connecte Brave Search pour un accès web instantané
2. Ajoute des outils de développement : GitHub et les serveurs de base de données accélèrent le vrai travail
3. Essaie l'automatisation : Lance l'automatisation navigateur pour les tests
4. Construis le tien : Livre un serveur personnalisé pour les API internes
5. Parcours tout : La liste complète des serveurs MCP a le reste

Les serveurs MCP transforment Cursor d'un éditeur fermé en un environnement de développement câblé. Commence par un serveur. Prouve la valeur. Ajoute-en au fur et à mesure que le workflow le demande.

Trois stacks MCP vraiment utiles

L'erreur que font la plupart des équipes, c'est d'ajouter dix serveurs parce qu'elles peuvent. Le meilleur choix est de construire une stack par travail.

1. Stack ingénierie produit

Utilise ça quand tu construis des fonctionnalités d'app de bout en bout :

• GitHub MCP pour le contexte dépôt et PR
• Postgres MCP pour les vérifications de schéma et données
• Brave Search ou recherche de docs style Context7 pour les références actuelles
• Playwright MCP pour la vérification navigateur

Ça donne à Cursor assez de surface pour lire du code, inspecter des données, vérifier des docs et valider le comportement UI sans transformer la session en spam d'outils.

2. Stack contenu et SEO

Utilise ça quand tu livres des pages lourdes en contenu :

• GitHub MCP pour le contenu du dépôt et les diffs
• Search MCP pour la recherche de concurrents ou de sources
• Filesystem MCP pour travailler sur des dossiers de contenu en dehors du workspace actuel

Bon pour les équipes qui écrivent des landing pages, des docs, des changelogs ou des articles de blog où le travail n'est pas juste "écrire du texte" mais aussi comparer les chevauchements, mettre à jour les liens internes et garder le dépôt organisé.

3. Stack débogage

Utilise ça quand le problème est difficile à reproduire depuis le code seul :

• GitHub MCP pour l'historique des changements
• Playwright MCP pour reproduire l'état UI
• Database MCP si le bug a une odeur de données

La clé, c'est pas le nombre de serveurs. C'est si les outils correspondent à la surface de défaillance que tu investigues.

Ce qu'il ne faut pas faire

Les setups MCP dans Cursor déraillent de quelques façons répétées :

Le bon setup n'est pas le plus grand. C'est le plus petit ensemble d'outils qui rend un vrai workflow radicalement meilleur.

Sources :

• Cursor MCP Documentation
• How to Add MCP Server to Cursor