Comment créer un serveur MCP distant avec OAuth en Python : un exemple réel

Un serveur MCP local sur l'ordinateur portable d'un développeur, c'est facile. Un serveur MCP distant utilisé par toute une équipe depuis Claude, ChatGPT ou Cursor, où chaque personne se connecte avec son propre compte et où l'IA ne peut faire que ce que cette personne a le droit de faire, demande un peu plus de conception. Ce guide présente l'architecture que nous avons utilisée pour notre propre serveur en octobre 2026 : un serveur MCP Python qui connecte Claude à notre gestionnaire de tâches interne.

Vous découvrez MCP ? Commencez par qu'est-ce qu'un serveur MCP.

L'architecture

1. Votre application (ici une application Django) est le serveur d'autorisation OAuth : les personnes se connectent avec les comptes qu'elles ont déjà et approuvent l'accès.
2. Le serveur MCP est le serveur de ressources : il reçoit le token d'accès de l'utilisateur depuis l'application IA, le vérifie auprès du serveur d'autorisation, et seulement ensuite exécute l'outil.
3. L'application IA (Claude, ChatGPT, Cursor, Claude Code) découvre comment se connecter grâce aux métadonnées du serveur MCP, fait passer l'utilisateur par la page de connexion, puis appelle les outils avec le token.

Un choix de conception compte beaucoup : le serveur MCP ne transmet jamais le token de l'utilisateur à l'API interne de l'application. Il appelle l'application avec ses propres identifiants de service et indique pour quel utilisateur il agit, et c'est l'application qui applique les autorisations de cet utilisateur. Un token d'IA divulgué ne peut donc pas être réutilisé contre le reste de votre système.

Étape 1 : concevoir les outils avant d'écrire du code

Les outils sont ce que voit l'IA : concevez-les comme un produit.

• Peu nombreux et précis : notre serveur compte 11 outils, comme search_tasks, summarize_tasks, create_tasks et add_comment.
• Marquez les outils en lecture seule comme tels, pour que les applications IA puissent les traiter différemment des outils qui modifient des données.
• Renvoyez des résultats compacts (identifiants, titres, statut, liens), pas des lignes entières de la base de données.
• Permettez aux outils d'écriture de travailler par lots, avec des limites (nous autorisons 1 à 50 tâches par appel), pour que l'IA ne boucle pas des centaines de fois.
• Rédigez des descriptions claires : l'IA choisit les outils en les lisant.

Étape 2 : le serveur MCP en Python

Nous avons utilisé le SDK Python officiel (le package mcp) avec le transport Streamable HTTP, servi sur /mcp. Voici une version simplifiée de la configuration :

from mcp.server.mcpserver import MCPServer
from mcp.server.auth.settings import AuthSettings
from mcp.types import ToolAnnotations

READ_ONLY = ToolAnnotations(read_only_hint=True, open_world_hint=False)

mcp = MCPServer(
    name="tasks",
    token_verifier=IntrospectionVerifier(),   # checks tokens with your OAuth server
    auth=AuthSettings(
        issuer_url="https://app.example.com",
        resource_server_url="https://mcp.example.com/mcp",
        required_scopes=["tasks:read"],
    ),
)

@mcp.tool(annotations=READ_ONLY)
async def search_tasks(query: str, overdue: bool = False) -> list[dict]:
    """Search tasks the signed-in person can see."""
    user = current_user()                      # from the verified token
    return await app_api.search(user, query=query, overdue=overdue)

Vérifiez les noms exacts dans la documentation actuelle du SDK, car les SDK évoluent vite.

Étape 3 : connexion OAuth et scopes

• Serveur d'autorisation : notre application utilise django-oauth-toolkit pour émettre les tokens et répondre aux requêtes d'introspection de token. N'importe quel serveur OAuth 2 de confiance peut remplir ce rôle.
• Découverte : le serveur MCP publie des métadonnées de ressource protégée. Quand une application IA appelle /mcp sans token, elle reçoit une réponse 401 qui pointe vers ces métadonnées, puis de là vers votre page de connexion.
• Scopes : nous utilisons tasks:read pour tout ce qui ne fait que lire et tasks:write pour tout ce qui modifie des données. Une personne peut se connecter avec un accès en lecture seule.
• Vérification des tokens : le serveur MCP vérifie chaque token auprès du serveur d'autorisation, y compris pour qui il a été émis, avant l'exécution de tout outil.

Étape 4 : le déployer

• Packagez le serveur dans un petit conteneur Docker doté d'un endpoint de health check.
• Placez-le derrière HTTPS (nginx, Caddy ou un load balancer cloud) et désactivez la mise en tampon des réponses pour le chemin MCP, sinon les réponses en streaming resteront bloquées.
• L'URL publique annoncée par le serveur doit correspondre exactement à l'URL que les personnes saisissent dans leur application IA.
• Vérifiez que les pare-feu, les CDN ou les protections anti-bots n'empêchent pas les serveurs du fournisseur d'IA d'atteindre vos endpoints de connexion et de métadonnées : c'est la raison la plus fréquente de l'échec d'un bouton « Connect ».

Étape 5 : tester avant de connecter de vrais utilisateurs

Nous testons le serveur MCP de bout en bout face à une fausse version en mémoire de l'application, et le côté application a ses propres tests pour OAuth, les autorisations et l'API interne. Avant le lancement, vérifiez à la main : un appel sans token renvoie une 401 avec le lien vers les métadonnées, un token en lecture seule est refusé pour les outils d'écriture, et un utilisateur ne peut pas voir les données privées d'un autre utilisateur.

Étape 6 : le connecter dans Claude, ChatGPT ou Cursor

• Claude (équipe) : un propriétaire ajoute un connecteur personnalisé avec l'URL du serveur MCP ; chaque personne clique sur Connect et se connecte.
• Claude Code : claude mcp add --transport http tasks https://mcp.example.com/mcp, puis connectez-vous.
• Autres applications : la plupart des applications compatibles MCP permettent d'ajouter l'URL d'un serveur MCP distant ; consultez leur documentation.

Erreurs fréquentes

• Donner à l'IA un seul outil puissant du type « exécuter n'importe quelle requête » au lieu de quelques outils sûrs et précis.
• Utiliser une seule clé API partagée par tout le monde, si bien qu'on ne peut plus savoir qui a fait quoi.
• Transmettre directement les tokens des utilisateurs aux systèmes internes.
• Pas de logs : vous devez toujours pouvoir répondre à la question « qui a demandé à l'IA de modifier ceci, et quand ? »

Comment UnlockLive peut vous aider

Nous créons et exploitons des serveurs MCP distants pour des CRM, des bases de données, des ERP et des API internes, avec connexion par utilisateur, scopes, journalisation et tests. Découvrez notre service de développement de serveurs MCP, la checklist de sécurité MCP et l'étude de cas de notre propre serveur. Dites-nous quel système vous voulez connecter.