Commencer

Choisir un fournisseur compatible OAuth 2.1 ou OpenID Connect

La spécification MCP comporte certaines exigences spécifiques pour l'autorisation :

• OAuth 2.1 IETF DRAFT
• Métadonnées du serveur d'autorisation OAuth 2.0 (RFC 8414)
• Protocole d'enregistrement dynamique du client OAuth 2.0 (RFC 7591)

Bien que les deux derniers ne soient pas obligatoires, le premier est nécessaire pour garantir une implémentation sécurisée et conforme.

remarque

Dans le nouveau projet de spécification MCP, la RFC 8414 sera obligatoire pour les serveurs d'autorisation (fournisseurs). Nous mettrons à jour la documentation une fois le nouveau projet finalisé.

Vous pouvez consulter la liste des fournisseurs compatibles MCP pour vérifier si votre fournisseur est pris en charge.

Installer MCP Auth SDK

MCP Auth est disponible pour Python et TypeScript. Faites-nous savoir si vous avez besoin d'un support pour un autre langage ou framework !

Python

pip install mcpauth

Ou tout autre gestionnaire de paquets que vous préférez, comme pipenv ou poetry.

Node.js

npm install mcp-auth

Ou tout autre gestionnaire de paquets que vous préférez, comme pnpm ou yarn.

Initialiser MCP Auth

La première étape consiste à initialiser l'instance MCP Auth avec les métadonnées du serveur d'autorisation de votre fournisseur. Si votre fournisseur est conforme à l'une des spécifications suivantes :

• Métadonnées du serveur d'autorisation OAuth 2.0
• Découverte OpenID Connect

Vous pouvez utiliser la fonction intégrée pour récupérer les métadonnées et initialiser l'instance MCP Auth :

Python

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

mcp_auth = MCPAuth(
    server=fetch_server_config(
      '<auth-server-url>',
      type=AuthServerType.OIDC # ou AuthServerType.OAUTH
    )
)

Node.js

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

const mcpAuth = new MCPAuth({
  server: await fetchServerConfig('<auth-server-issuer>', { type: 'oidc' }), // ou 'oauth'
});

Si vous devez spécifier manuellement l'URL des métadonnées ou les points de terminaison, consultez Autres façons d'initialiser MCP Auth.

Monter le point de terminaison des métadonnées

Pour se conformer à la spécification MCP actuelle, MCP Auth monte le point de terminaison des métadonnées du serveur d'autorisation OAuth 2.0 (/.well-known/oauth-authorization-server) sur votre serveur MCP :

Python

from starlette.applications import Starlette

app = Starlette(routes=[
    mcp_auth.metadata_route(),
])

Node.js

import express from 'express';

const app = express();
app.use(mcpAuth.delegatedRouter());

Les URLs dans les métadonnées sont conservées telles quelles, de sorte que le rôle de serveur d'autorisation est entièrement délégué au fournisseur. Vous pouvez tester le point de terminaison des métadonnées en visitant /.well-known/oauth-authorization-server sur votre serveur MCP.

Pourquoi uniquement le point de terminaison des métadonnées ?

Vous pouvez voir que les SDK officiels fournissent un routeur d'authentification qui monte des points de terminaison d'autorisation comme /authorize, /token, etc. Voici pourquoi nous ne faisons pas cela :

1. Monter uniquement le point de terminaison des métadonnées vous permet de tirer parti de toutes les capacités de votre fournisseur sans "réinventer la roue" et sans injecter de complexité inutile dans votre serveur MCP.
2. Il y a également un effort en cours pour faire évoluer le rôle du serveur MCP vers un serveur de ressources et exiger les métadonnées des ressources protégées OAuth 2.0 (RFC 9728). Ce qui signifie que le serveur MCP ne gérera plus aucune logique d'autorisation (y compris le point de terminaison des métadonnées), mais servira uniquement de serveur de ressources qui s'appuie sur le fournisseur pour l'authentification et l'autorisation.

remarque

Nous mettrons à jour MCP Auth pour prendre en charge la nouvelle spécification MCP lorsqu'elle sera finalisée. En attendant, vous pouvez utiliser la version actuelle qui est compatible avec la spécification en vigueur.

Utiliser le middleware Bearer auth

Une fois l'instance MCP Auth initialisée, vous pouvez appliquer le middleware Bearer auth pour protéger vos routes MCP :

Python

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

mcp = FastMCP()
mcp_auth = MCPAuth(
  # Initialiser avec la configuration de votre serveur d'authentification
)
bearer_auth = mcp_auth.bearer_auth_middleware(
    "jwt", required_scopes=["read", "write"]
)

app = Starlette(routes=[
    mcp_auth.metadata_route(),
    Mount(
        "/",
        app=mcp.sse_app(),
        middleware=[Middleware(bearer_auth)],
    ),
])

Node.js

import express from 'express';
import { MCPAuth } from 'mcp-auth';

const app = express();
const server = new McpServer(/* ... */);
const mcpAuth = new MCPAuth({
  /* ... */
});

app.use(mcpAuth.bearerAuth('jwt', { requiredScopes: ['read', 'write'] }));

Dans l'exemple ci-dessus, nous avons spécifié le type de jeton jwt et requis les portées read et write. Cela validera automatiquement le JWT (JSON Web Token) et remplira un objet avec les informations de l'utilisateur authentifié.

info

Vous n'avez jamais entendu parler de JWT (JSON Web Token) ? Pas d'inquiétude, vous pouvez continuer à lire la documentation et nous l'expliquerons en temps voulu. Vous pouvez également consulter Auth Wiki pour une introduction rapide.

Pour plus d'informations sur la configuration de Bearer auth, consultez Configurer Bearer auth.

Récupérer les informations d'authentification dans votre implémentation MCP

Une fois le middleware Bearer auth appliqué, vous pouvez accéder aux informations de l'utilisateur (ou de l'identité) authentifié dans votre implémentation MCP :

Python

MCP Auth stockera les informations de l'utilisateur authentifié dans une variable de contexte après une authentification réussie une fois le middleware Bearer auth appliqué. Vous pouvez y accéder dans vos gestionnaires d'outils MCP comme ceci :

from mcp.server.fastmcp import FastMCP

mcp = FastMCP()
mcp_auth = MCPAuth(
  # Initialiser avec la configuration de votre serveur d'authentification
)

@mcp.tool()
def add(a: int, b: int):
    """
    Un outil qui additionne deux nombres.
    Les informations de l'utilisateur authentifié seront disponibles dans le contexte.
    """
    auth_info = mcp_auth.auth_info # Accéder aux informations d'authentification dans le contexte actuel
    if auth_info:
        print(f"Utilisateur authentifié : {auth_info.claims}")
    return a + b

Node.js

Le deuxième argument du gestionnaire d'outil contiendra l'objet authInfo, qui inclut les informations de l'utilisateur authentifié :

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

const server = new McpServer(/* ... */);
server.tool('add', { a: z.number(), b: z.number() }, async ({ a, b }, { authInfo }) => {
  // Vous pouvez maintenant utiliser l'objet `authInfo` pour accéder aux informations authentifiées
});

Prochaines étapes

Continuez la lecture pour découvrir un exemple de bout en bout sur la façon d'intégrer MCP Auth à votre serveur MCP, et comment gérer le flux d'authentification dans les clients MCP.