Protocole Model Context (MCP)

Qu’est-ce que MCP ?

Le Protocole Model Context (MCP) permet à Cursor de se connecter à des outils externes et à des sources de données. Installez et gérez des serveurs MCP depuis la page Personnaliser, ou configurez-les dans mcp.json.

Pourquoi utiliser MCP ?

MCP connecte Cursor à des systèmes et à des données externes. Au lieu de devoir expliquer sans cesse la structure de votre projet, intégrez directement vos outils.

Créez des serveurs MCP dans n'importe quel langage capable d'écrire sur stdout ou d'exposer un point de terminaison HTTP : Python, JavaScript, Go, etc.

Parcourez les plugins officiels sur le Cursor Marketplace. Pour les plugins communautaires et les serveurs MCP, parcourez cursor.directory.

Fonctionnement

Les serveurs MCP exposent des capacités via le protocole et connectent Cursor à des outils externes ou à des sources de données.

Cursor prend en charge trois méthodes de transport :

Prise en charge du protocole et des extensions

Cursor prend en charge les fonctionnalités et extensions suivantes du protocole MCP :

Applications MCP

Cursor prend en charge l’extension MCP Apps. Les outils MCP peuvent renvoyer une interface utilisateur interactive, en plus de leur sortie standard.

Les MCP Apps reposent sur le principe d’amélioration progressive. Si un hôte ne peut pas afficher l’interface utilisateur de l’application, l’outil fonctionne tout de même via les réponses MCP habituelles.

Installation de serveurs MCP

Installation en un clic

Parcourez le Cursor Marketplace pour installer des plugins officiels en un clic depuis Personnaliser, ou configurez des serveurs personnalisés avec mcp.json. Pour les plugins communautaires et les serveurs MCP, parcourez cursor.directory. Cliquez sur « Ajouter à Cursor » sur une entrée du marketplace pour l’installer et vous authentifier via OAuth.

Les administrateurs d’équipe peuvent également distribuer des serveurs MCP via un marketplace d’équipe. Les serveurs distribués par l’équipe apparaissent dans Personnaliser, aux côtés des serveurs MCP personnels et de l’espace de travail.

Utilisation de mcp.json

Configurez des serveurs MCP personnalisés à l’aide d’un fichier JSON :

{  "mcpServers": {    "server-name": {      "command": "npx",      "args": ["-y", "mcp-server"],      "env": {        "API_KEY": "value"      }    }  }}

{  "mcpServers": {    "server-name": {      "command": "python",      "args": ["mcp-server.py"],      "env": {        "API_KEY": "value"      }    }  }}

// Serveur MCP utilisant HTTP ou SSE - s’exécute sur un serveur{  "mcpServers": {    "server-name": {      "url": "http://localhost:3000/mcp",      "headers": {        "API_KEY": "value"      }    }  }}

OAuth statique pour les serveurs distants

Pour les serveurs MCP qui utilisent OAuth, vous pouvez fournir des identifiants client OAuth statiques dans mcp.json plutôt que d’utiliser l’enregistrement dynamique des clients. Utilisez cette option lorsque :

• Le fournisseur MCP vous fournit un Client ID fixe (et éventuellement un Client Secret)
• Le fournisseur exige d’ajouter une URL de redirection à la liste blanche (p. ex. Figma, Linear)
• Le fournisseur ne prend pas en charge l’enregistrement dynamique des clients OAuth 2.0

Ajoutez un objet auth aux entrées de serveurs distants qui utilisent url :

{  "mcpServers": {    "oauth-server": {      "url": "https://api.example.com/mcp",      "auth": {        "CLIENT_ID": "your-oauth-client-id",        "CLIENT_SECRET": "your-client-secret",        "scopes": ["read", "write"]      }    }  }}

URL de redirection statique

Cursor utilise des URL de redirection OAuth fixes pour les serveurs MCP. Enregistrez le callback pour chaque interface depuis laquelle vos utilisateurs s’authentifient :

https://www.cursor.com/agents/mcp/oauth/callbackhttp://localhost:8787/callback

• Web et Cursor Agents : https://www.cursor.com/agents/mcp/oauth/callback
• Application de bureau : http://localhost:8787/callback

Lors de la configuration de l’application OAuth du fournisseur MCP, enregistrez les deux URL comme URI de redirection autorisées si les utilisateurs s’authentifient à la fois depuis le Web et l’application de bureau. Le serveur est identifié via le paramètre OAuth state ; ces URL de redirection fonctionnent donc pour tous les serveurs MCP.

Association avec l’interpolation de configuration

Les valeurs auth prennent en charge la même interpolation que les autres champs :

{  "mcpServers": {    "oauth-server": {      "url": "https://api.example.com/mcp",      "auth": {        "CLIENT_ID": "${env:MCP_CLIENT_ID}",        "CLIENT_SECRET": "${env:MCP_CLIENT_SECRET}"      }    }  }}

Utilisez des variables d’environnement pour l’ID client et le secret client plutôt que de les coder en dur.

Configuration des serveurs STDIO

Pour les serveurs STDIO (serveurs locaux en ligne de commande), configurez les champs suivants dans votre fichier mcp.json :

Utiliser l’API d’extension

Pour enregistrer des serveurs MCP par programmation, Cursor fournit une API d’extension permettant une configuration dynamique sans modifier les fichiers mcp.json. Cette API est particulièrement utile dans les environnements Enterprise et les flux de travail d’installation automatisés.

Emplacements de configuration

Interpolation de configuration

Utilisez des variables dans les valeurs de mcp.json. Cursor résout les variables dans les champs suivants : command, args, env, url et headers.

Syntaxe prise en charge :

• ${env:NAME} : variables d’environnement
• ${userHome} : chemin vers votre dossier personnel
• ${workspaceFolder} : racine du projet (le dossier qui contient .cursor/mcp.json)
• ${workspaceFolderBasename} : nom de la racine du projet
• ${pathSeparator} et ${/} : séparateur de chemin du système d’exploitation

Exemples

{  "mcpServers": {    "local-server": {      "command": "python",      "args": ["${workspaceFolder}/tools/mcp_server.py"],      "env": {        "API_KEY": "${env:API_KEY}"      }    }  }}

{  "mcpServers": {    "remote-server": {      "url": "https://api.example.com/mcp",      "headers": {        "Authorization": "Bearer ${env:MY_SERVICE_TOKEN}"      }    }  }}

Authentification

Les serveurs MCP utilisent des variables d’environnement pour s’authentifier. Transmettez les clés API et les tokens via la config.

Cursor prend en charge OAuth pour les serveurs qui l’exigent.

Contrôles d’administration Enterprise

La distribution des MCP et la politique MCP se configurent séparément. Les administrateurs d’équipe peuvent distribuer des serveurs MCP partagés. Les administrateurs Enterprise peuvent configurer la politique MCP.

Distribution des MCP d’équipe

Configurez les serveurs MCP d’équipe partagés dans Dashboard > Integrations & MCP. Ces serveurs sont accessibles aux agents cloud.

Pour rendre un serveur MCP d’équipe autonome existant disponible dans la fenêtre Agent, l’IDE et la CLI, sélectionnez Add to Team Marketplace sous Team MCP Servers. Cursor associe le serveur au marketplace d’équipe par défaut sans interrompre l’accès des agents cloud. Les membres de l’équipe peuvent ensuite l’installer et le configurer depuis Personnaliser.

L’association d’un serveur MCP à un marketplace ne l’installe pas et ne l’active pas pour tous les utilisateurs. Configurez Marketplace Access et les modes d’installation des plugins dans Dashboard > Plugins. Voir Migrer les MCP d’équipe existants pour connaître le processus complet.

Liste d’autorisation MCP

Les administrateurs Enterprise peuvent contrôler les serveurs MCP que les utilisateurs sont autorisés à exécuter depuis le tableau de bord Cursor. Ouvrez Paramètres d’équipe > Configuration MCP pour configurer les serveurs et outils que l’équipe est autorisée à exécuter. L’ajout à la liste d’autorisation approuve une configuration MCP. Il ne distribue pas et n’installe pas le serveur.

Utilisez la liste d’autorisation MCP pour définir les serveurs approuvés :

• Les entrées de commande approuvent les serveurs MCP stdio locaux selon un motif de commande.
• Les entrées d’URL approuvent les serveurs MCP HTTP/SSE distants selon un motif d’URL.
• Les listes d’autorisation d’outils limitent les outils d’un serveur approuvé pouvant s’exécuter automatiquement. Laissez une liste d’autorisation d’outils vide pour autoriser tous les outils de ce serveur.

Contrôle réseau

Les URL MCP distantes sont limitées au motif d’URL configuré.

Les serveurs MCP locaux basés sur des commandes utilisent leur propre mode réseau :

• Tout autoriser : autoriser l’accès au réseau sortant.
• Liste d’autorisation : autoriser uniquement les destinations répertoriées.
• Tout refuser : bloquer l’accès au réseau sortant.
• Sans sandbox : exécuter sans sandboxing des commandes ni du réseau.

Extensions MCP des utilisateurs

Les administrateurs peuvent autoriser les utilisateurs à configurer leurs propres serveurs MCP en dehors des conventions de commandes ou d’URL définies par les administrateurs. Pour les MCP utilisateur qui ne correspondent pas à une convention définie par un administrateur, la liste de refus réseau des MCP utilisateur peut bloquer les destinations réseau correspondantes.

Utiliser MCP dans le chat

Cursor utilise automatiquement les outils MCP répertoriés dans Available Tools lorsque nécessaire. Cela inclut le mode Plan. Demandez un outil précis par son nom ou décrivez ce dont vous avez besoin. Activez ou désactivez les serveurs MCP depuis Personnaliser dans la barre latérale.

Approbation des outils

Par défaut, Cursor demande votre approbation avant d'utiliser des outils MCP. Cliquez sur la flèche à côté du nom de l'outil pour afficher les arguments.

Mode d’exécution

MCP utilise les mêmes modes d’exécution que les commandes du terminal. Par exemple, en mode révision automatique, les outils MCP figurant dans la liste d’autorisation s’exécutent immédiatement, tandis que tous les autres sont soumis au classificateur.

Réponse de l’outil

Cursor affiche la réponse dans le chat, avec des vues déroulantes pour les arguments et les réponses :

Images en contexte

Les serveurs MCP peuvent renvoyer des images (captures d’écran, diagrammes, etc.) sous forme de chaînes encodées en base64 :

const RED_CIRCLE_BASE64 = "/9j/4AAQSkZJRgABAgEASABIAAD/2w...";// ^ base64 complet, tronqué pour plus de lisibilitéserver.tool("generate_image", async (params) => {  return {    content: [      {        type: "image",        data: RED_CIRCLE_BASE64,        mimeType: "image/jpeg",      },    ],  };});

Voir cet exemple de serveur pour plus de détails sur l’implémentation. Cursor ajoute les images renvoyées au chat. Si le modèle prend en charge les images, il les analyse.

Considérations de sécurité

Lors de l’installation de serveurs MCP, respectez les bonnes pratiques de sécurité suivantes :

• Vérifier la source : installez uniquement des serveurs MCP provenant de développeurs et de dépôts fiables
• Passer en revue les autorisations : vérifiez aux données et aux API auxquelles le serveur pourra accéder
• Limiter les clés API : utilisez des clés API restreintes disposant uniquement des autorisations nécessaires
• Auditer le code : pour les intégrations critiques, examinez le code source du serveur

N’oubliez pas que les serveurs MCP peuvent accéder à des services externes et exécuter du code en votre nom. Assurez-vous toujours de comprendre ce que fait un serveur avant de l’installer.

Exemples concrets

Pour découvrir MCP en pratique :

• Intégration Xcode — Connectez Cursor à Xcode 26.3+ pour les builds, les tests, les aperçus SwiftUI et la recherche dans la documentation Apple
• Guide de développement Web — Intégrez Linear, Figma et des outils de navigateur à votre flux de travail de développement

FAQ