Activez l’authentification pour vos applications propulsées par MCP avec Logto

astuce:

Découvrez les solutions IA de Logto : authentification (Authentication) et autorisation (Authorization) pour les serveurs MCP, les agents IA et les applications.

Ce guide vous accompagne dans l’intégration de Logto avec votre serveur MCP en utilisant mcp-auth et le SDK officiel MCP v2, vous permettant d’authentifier les utilisateurs et de lire en toute sécurité leur identité vérifiée à partir du jeton d’accès.

Vous apprendrez à :

Configurer Logto comme serveur d’autorisation pour votre serveur MCP.
Mettre en place un outil “whoami” dans votre serveur MCP pour retourner les revendications d’identité de l’utilisateur courant.
Tester le flux avec VS Code (client MCP).

Après ce tutoriel, votre serveur MCP pourra :

Authentifier les utilisateurs dans votre tenant Logto.
Vérifier les jetons d’accès JWT émis par Logto (signature, émetteur, audience et expiration).
Retourner les revendications d’identité vérifiées (sub, iss, aud, etc.) lors de l’invocation de l’outil "whoami".

Une fois l’intégration terminée, vous pouvez remplacer VS Code par votre propre client MCP, tel qu’une application web, pour accéder aux outils et ressources exposés par votre serveur MCP.

Exemple de code:

Le code exemple complet et exécutable pour ce guide est disponible dans le dépôt mcp-auth/js :

whoami-express : le serveur "whoami" de ce guide, sur Node.js avec Express.
whoami : le même serveur construit avec fetch-native (web-standard Request / Response avec Hono), déployable sur Cloudflare Workers.

Prérequis

Un tenant Logto Cloud (ou auto-hébergé)
Environnement Node.js >= 20

Comprendre l’architecture

Serveur MCP : Le serveur qui expose des outils et des ressources aux clients MCP. Conformément à la dernière spécification MCP, il agit en tant que serveur de ressources OAuth 2.0 qui valide les jetons d’accès émis par Logto.
Client MCP : Un client utilisé pour initier le flux d’authentification et tester l’intégration. Nous utiliserons VS Code (avec le support MCP intégré) comme client dans ce guide.
Logto : Sert de fournisseur OpenID Connect (serveur d’autorisation), gère les identités des utilisateurs et émet des jetons d’accès JWT liés à l’audience pour votre serveur MCP.

Un diagramme de séquence non normatif illustre le déroulement global du processus :

remarque:

En raison de l’évolution rapide de MCP, le diagramme ci-dessus peut ne pas être entièrement à jour. Veuillez consulter la documentation mcp-auth pour les dernières informations.

Configurer l’application dans Logto

Votre client MCP doit être enregistré comme une application dans Logto pour initier le flux d’autorisation. Nous allons enregistrer VS Code comme client dans ce guide :

Connectez-vous à votre Console Logto.
Allez dans Applications → Créer une application → Créer une application sans framework.
Choisissez le type : Application native.
Renseignez le nom de l’application (par exemple, "VS Code") et les autres champs requis, puis cliquez sur Créer une application.
Dans la section Paramètres / URI de redirection, ajoutez les URI de redirection suivantes pour VS Code, puis enregistrez les modifications :
```
http://127.0.0.1
https://vscode.dev/redirect
```
Enregistrez et copiez l’ID de l’application et le point de terminaison de l’émetteur.

Configurer le serveur MCP

Nous allons utiliser le SDK officiel MCP v2 et mcp-auth pour créer un serveur MCP avec un outil "whoami" qui retourne les revendications d'identité de l'utilisateur actuel.

Créer le projet et installer les dépendances

mkdir mcp-server
cd mcp-server
npm init -y
npm pkg set type="module"
npm pkg set main="whoami.js"
npm pkg set scripts.start="node whoami.js"
npm install @modelcontextprotocol/server @modelcontextprotocol/express @modelcontextprotocol/node express mcp-auth

@modelcontextprotocol/server est le SDK MCP v2 principal, qui utilise les standards web Request / Response.
@modelcontextprotocol/express et @modelcontextprotocol/node l'adaptent à Express sur Node.js.
mcp-auth fournit le vérificateur de jeton et les métadonnées de découverte OAuth pour le SDK MCP.

remarque:

Le SDK MCP v2 et mcp-auth sont uniquement ESM et nécessitent Node.js >= 20.

Enregistrer le serveur MCP comme ressource API

La dernière spécification MCP exige que les jetons d’accès soient liés à la ressource pour laquelle ils sont émis (RFC 8707), et mcp-auth l'applique : la revendication aud du jeton doit correspondre à l'identifiant de ressource de votre serveur MCP. Dans Logto, cela se fait en créant une ressource API dont l'indicateur correspond à l'URL de votre serveur MCP :

Connectez-vous à votre Console Logto.
Allez dans Ressources API → Créer une ressource API.
Remplissez les détails, puis cliquez sur Créer une ressource API :
- Nom de l’API : Saisissez un nom, par exemple "Who am I".
- Identifiant de l’API : Saisissez http://localhost:3001/. Il doit correspondre à l'identifiant de ressource que nous allons configurer dans le serveur MCP.

Barre oblique finale dans l’indicateur de ressource:

Incluez toujours une barre oblique finale (/) dans l’indicateur de ressource. En raison d’un bug actuel dans le SDK officiel MCP, les clients utilisant le SDK ajouteront automatiquement une barre oblique finale aux identifiants de ressource lors de l’initiation des requêtes d’authentification. Si votre indicateur de ressource n’inclut pas la barre oblique, la validation de la ressource échouera pour ces clients.

Configurer MCP Auth avec Logto

Déclarez votre serveur MCP comme une ressource protégée : son identifiant de ressource et le serveur d’autorisation auquel il fait confiance. N’oubliez pas de remplacer <your-logto-issuer-endpoint> par l’endpoint de l’émetteur que vous avez copié précédemment (trouvé dans la page de détails de l’application sous Endpoints & Credentials, par exemple https://my-project.logto.app/oidc).

Dans whoami.js :

import { MCPAuth } from 'mcp-auth';

const authIssuer = '<your-logto-issuer-endpoint>';

const mcpAuth = new MCPAuth({
  protectedResourceMetadata: {
    // L’identifiant de la ressource ; doit correspondre à l’indicateur de ressource API enregistré dans Logto
    resource: 'http://localhost:3001/',
    // Le serveur d’autorisation de confiance pour ce serveur MCP
    authorizationServer: { issuer: authIssuer, type: 'oidc' },
  },
});

Les métadonnées du serveur d’autorisation sont récupérées à la demande lors du premier besoin et mises en cache par la suite. L’instance MCPAuth vérifie les jetons d’accès JWT avec le JWKS de Logto — la signature, l’émetteur, l’audience et l’expiration sont tous appliqués. Aucune vérification manuelle des jetons n’est nécessaire.

Implémenter l’outil "whoami"

Implémentons maintenant l’outil "whoami" qui retourne les revendications d'identité de l'utilisateur actuel à partir du jeton d’accès vérifié. Utilisez getAuthInfo pour lire les informations d’authentification que mcp-auth a vérifiées à partir du contexte du callback de l’outil.

import { McpServer } from '@modelcontextprotocol/server';
import { getAuthInfo } from 'mcp-auth';

// Fonction usine pour créer une instance de serveur MCP
// Chaque requête obtient sa propre instance de serveur, gardant les requêtes isolées
const createMcpServer = () => {
  const mcpServer = new McpServer({
    name: 'WhoAmI',
    version: '0.0.0',
  });

  // Ajoute un outil au serveur qui retourne les informations de l’utilisateur actuel
  mcpServer.registerTool(
    'whoami',
    {
      description: 'Obtenir les informations de l’utilisateur actuel',
    },
    (context) => {
      const { claims } = getAuthInfo(context);
      return {
        content: [{ type: 'text', text: JSON.stringify(claims) }],
      };
    }
  );

  return mcpServer;
};

Connecter le serveur

Enfin, servez les documents de découverte OAuth (RFC 9728 / RFC 8414) pour que les clients MCP puissent trouver votre serveur d’autorisation, et protégez l’endpoint MCP avec le middleware Bearer auth du SDK.

import {
  createMcpExpressApp,
  mcpAuthMetadataRouter,
  requireBearerAuth,
} from '@modelcontextprotocol/express';
import { toNodeHandler } from '@modelcontextprotocol/node';
import { createMcpHandler } from '@modelcontextprotocol/server';

const PORT = 3001;

// Le handler MCP utilise les standards web Request / Response ; `toNodeHandler` l’adapte à Express
const mcpNodeHandler = toNodeHandler(createMcpHandler(createMcpServer));

const app = createMcpExpressApp();

// Sert les documents de découverte OAuth (`/.well-known/...`), publics par conception
app.use(mcpAuthMetadataRouter(await mcpAuth.getAuthMetadataOptions()));

app.all(
  '/',
  // Nécessite un jeton Bearer valide ; les infos d’authentification vérifiées sont transmises au handler via `req.auth`
  requireBearerAuth(mcpAuth.getBearerAuthOptions()),
  // `createMcpExpressApp` applique `express.json()`, qui vide le flux de requête, donc le
  // corps analysé est transmis explicitement
  async (request, response) => mcpNodeHandler(request, response, request.body)
);

app.listen(PORT);

Lancez le serveur avec :

npm start

Tester l’intégration

Démarrez le serveur MCP :
```
npm start
```
Connectez VS Code à votre serveur MCP :
1. Appuyez sur Command + Shift + P (macOS) ou Ctrl + Shift + P (Windows / Linux) pour ouvrir la palette de commandes.
2. Tapez MCP: Add Server... et sélectionnez-le.
3. Choisissez HTTP comme type de serveur.
4. Entrez l’URL du serveur MCP : http://localhost:3001/
5. Lorsque le flux OAuth démarre, VS Code demande l’ID client : collez l’ID de l’application que vous avez copié précédemment.
6. Comme il s’agit d’un client public sans secret d’application, appuyez simplement sur Entrée pour passer le secret.
7. Terminez le flux de connexion dans votre navigateur.
Après la connexion, exécutez l’outil whoami dans VS Code.

Vous devriez voir les revendications vérifiées du jeton d’accès, telles que :

{
  "iss": "https://my-project.logto.app/oidc",
  "sub": "user_XXXX",
  "aud": "http://localhost:3001/",
  "client_id": "<your-app-id>"
}

Pour aller plus loin

Votre serveur MCP vérifie désormais les jetons d’accès entrants. Pour la suite, découvrez comment il peut appeler en toute sécurité vos API métier en aval au nom des utilisateurs, sans transfert de jeton ni perte de contexte utilisateur :

Comment un serveur MCP appelle votre API au nom des utilisateurs : une stratégie de jeton en production

Prérequis​

Comprendre l’architecture​

Configurer l’application dans Logto​

Configurer le serveur MCP​

Créer le projet et installer les dépendances​

Enregistrer le serveur MCP comme ressource API​

Configurer MCP Auth avec Logto​

Implémenter l’outil "whoami"​

Connecter le serveur​

Tester l’intégration​

Pour aller plus loin​