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

Ce guide vous accompagne dans l’intégration de Logto avec votre serveur MCP en utilisant mcp-auth, vous permettant d’authentifier les utilisateurs et de récupérer en toute sécurité leurs informations d’identité via le flux standard OpenID Connect.

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 actuel.
Tester le flux avec le MCP Inspector (client MCP).

Après ce tutoriel, votre serveur MCP pourra :

Authentifier les utilisateurs dans votre tenant Logto.
Retourner les revendications d’identité (sub, username, name, email, etc.) lors de l’appel de l’outil "whoami".

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

Prérequis

Un tenant Logto Cloud (ou auto-hébergé)
Un environnement Node.js ou Python

Comprendre l’architecture

Serveur MCP : Le serveur qui expose des outils et des ressources aux clients MCP.
Client MCP : Un client utilisé pour initier le flux d’authentification et tester l’intégration. Nous utiliserons le MCP Inspector comme client dans ce guide.
Logto : Sert de fournisseur OpenID Connect (serveur d’autorisation) et gère les identités des utilisateurs.

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 informations les plus récentes.

Configurer l’application dans Logto

Connectez-vous à votre Console Logto.
Allez dans Applications → Créer une application → Créer une application sans framework.
Choisissez le type : Application monopage.
Renseignez le nom de l’application et les autres champs requis, puis cliquez sur Créer une application.
Enregistrez et copiez l’ID de l’application et le point de terminaison de l’émetteur.

Configurer le serveur MCP

Créer le projet et installer les dépendances

Python
Node.js

mkdir mcp-server
cd mcp-server
uv init # Ou utilisez votre propre structure de projet
uv add "mcp[cli]" starlette uvicorn mcpauth # Ou utilisez le gestionnaire de paquets de votre choix

mkdir mcp-server
cd mcp-server
npm init -y
npm install @modelcontextprotocol/sdk express mcp-auth # Ou utilisez le gestionnaire de paquets de votre choix

Configurer l’authentification MCP avec Logto

N'oubliez pas de remplacer <your-logto-issuer-endpoint> par l’endpoint de l’émetteur que vous avez copié précédemment.

Python
Node.js

Dans whoami.py :

from mcpauth import MCPAuth
from mcpauth.config import AuthServerType
from mcpauth.utils import fetch_server_config

auth_issuer = '<your-logto-issuer-endpoint>'
auth_server_config = fetch_server_config(auth_issuer, type=AuthServerType.OIDC)
mcp_auth = MCPAuth(server=auth_server_config)

Dans whoami.js :

import { MCPAuth, fetchServerConfig } from 'mcp-auth';

const authIssuer = '<your-logto-issuer-endpoint>';
const mcpAuth = new MCPAuth({
  server: await fetchServerConfig(authIssuer, { type: 'oidc' }),
});

Implémenter la vérification du jeton

Puisque nous allons vérifier le jeton d’accès (Access token) et récupérer les informations utilisateur, nous devons implémenter la vérification du jeton d’accès comme suit :

Python
Node.js

import requests
from mcpauth.types import AuthInfo

def verify_access_token(token: str) -> AuthInfo:
    endpoint = auth_server_config.metadata.userinfo_endpoint
    response = requests.get(
        endpoint,
        headers={"Authorization": f"Bearer {token}"},
    )
    response.raise_for_status()
    data = response.json()
    return AuthInfo(
        token=token,
        subject=data.get("sub"),
        issuer=auth_server_config.metadata.issuer,
        claims=data,
    )

const verifyToken = async (token) => {
  const { userinfoEndpoint, issuer } = mcpAuth.config.server.metadata;
  const response = await fetch(userinfoEndpoint, {
    headers: { Authorization: `Bearer ${token}` },
  });
  if (!response.ok) throw new Error('Token verification failed');
  const userInfo = await response.json();
  return {
    token,
    issuer,
    subject: userInfo.sub,
    claims: userInfo,
  };
};

Implémenter l’outil "whoami"

Implémentons maintenant l’outil "whoami" qui retourne les revendications d’identité de l’utilisateur courant en interrogeant l’endpoint userinfo avec le jeton d’accès envoyé par le client.

remarque:

Nous utilisons le transport SSE pour l’exemple en raison de l’absence de prise en charge officielle du transport HTTP Streamable dans la version actuelle du SDK. Théoriquement, vous pouvez utiliser n’importe quel transport compatible HTTP.

Python
Node.js

from mcp.server.fastmcp import FastMCP
from starlette.applications import Starlette
from starlette.routing import Mount
from starlette.middleware import Middleware

mcp = FastMCP("WhoAmI")

@mcp.tool()
def whoami() -> dict:
    """
    Retourne les informations d'identité de l'utilisateur courant.
    """
    return (
        mcp_auth.auth_info.claims
        if mcp_auth.auth_info
        else {"error": "Not authenticated"}
    )

bearer_auth = Middleware(mcp_auth.bearer_auth_middleware(verify_access_token))
app = Starlette(
    routes=[
        mcp_auth.metadata_route(),  # Sert les métadonnées OIDC pour la découverte
        Mount('/', app=mcp.sse_app(), middleware=[bearer_auth]),
    ],
)

Lancez le serveur avec :

uvicorn whoami:app --host 0.0.0.0 --port 3001

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import express from 'express';

// Créer le serveur MCP et enregistrer l’outil whoami
const server = new McpServer({ name: 'WhoAmI', version: '0.0.0' });
server.tool('whoami', ({ authInfo }) => ({
  content: [
    { type: 'text', text: JSON.stringify(authInfo?.claims ?? { error: 'Not authenticated' }) },
  ],
}));

// Application Express & middleware MCP Auth
const app = express();
app.use(mcpAuth.delegatedRouter());
app.use(mcpAuth.bearerAuth(verifyToken));

// Transport SSE (comme dans la documentation du SDK)
const transports = {};
app.get('/sse', async (_req, res) => {
  const transport = new SSEServerTransport('/messages', res);
  transports[transport.sessionId] = transport;
  res.on('close', () => delete transports[transport.sessionId]);
  await server.connect(transport);
});
app.post('/messages', async (req, res) => {
  const sessionId = String(req.query.sessionId);
  const transport = transports[sessionId];
  if (transport) await transport.handlePostMessage(req, res, req.body);
  else res.status(400).send('No transport found for sessionId');
});

app.listen(3001);

Lancez le serveur avec :

node whoami.js

Tester l’intégration

Démarrez le serveur MCP.
Démarrez le MCP Inspector.

En raison des limitations de l’implémentation actuelle du MCP Inspector, nous devons utiliser la version forkée de mcp-auth :
```
git clone https://github.com/mcp-auth/inspector.git
cd inspector
npm install
npm run dev
```
Ensuite, ouvrez l’URL affichée dans le terminal.
Dans le MCP Inspector :
- Type de transport : SSE
- URL : http://localhost:3001/sse
- OAuth Client ID : Collez votre App ID Logto
- Paramètres Auth : {"scope": "openid profile email"}
- Redirect URI : Cette URL devrait être remplie automatiquement. Copiez-la.
Retrouvez l’application que vous avez créée précédemment dans la Console Logto, ouvrez la page de détails et collez l’URI de redirection dans la section Paramètres / URIs de redirection. Enregistrez les modifications.
Retournez dans le MCP Inspector et cliquez sur Connecter. Vous devriez être redirigé vers l’expérience de connexion Logto.

Après avoir terminé la connexion, vous devriez être redirigé vers le MCP Inspector. Allez dans Outils -> Lister les outils -> whoami -> Exécuter l’outil.

Vous devriez voir les revendications utilisateur, telles que :

{
  "sub": "user_XXXX",
  "username": "alice",
  "name": "Alice Smith",
  "email": "[email protected]"
}

Python
Node.js

Le code complet du serveur MCP est disponible dans le dépôt mcp-auth/python.

Prérequis​

Comprendre l’architecture​

Configurer l’application dans Logto​

Configurer le serveur MCP​

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

Configurer l’authentification MCP avec Logto​

Implémenter la vérification du jeton​

Implémenter l’outil "whoami"​

Tester l’intégration​