Saltar al contenido principal

Habilita la autenticación para tus apps con MCP usando Logto

Esta guía te guía paso a paso para integrar Logto con tu servidor MCP usando mcp-auth, permitiéndote autenticar usuarios y recuperar de forma segura su información de identidad utilizando el flujo estándar de OpenID Connect.

Aprenderás a:

  • Configurar Logto como el servidor de autorización para tu servidor MCP.
  • Configurar una herramienta “whoami” en tu servidor MCP para devolver los reclamos de identidad del usuario actual.
  • Probar el flujo con el MCP Inspector (cliente MCP).

Después de este tutorial, tu servidor MCP podrá:

  • Autenticar usuarios en tu tenant de Logto.
  • Devolver reclamos de identidad (sub, username, name, email, etc.) para la invocación de la herramienta "whoami".

Una vez completada la integración, puedes reemplazar el MCP Inspector con tu propio cliente MCP, como una aplicación web, para acceder a las herramientas y recursos expuestos por tu servidor MCP.

Requisitos previos​

  • Un tenant de Logto Cloud (o autogestionado)
  • Entorno Node.js o Python

Comprendiendo la arquitectura​

  • Servidor MCP: El servidor que expone herramientas y recursos a los clientes MCP.
  • Cliente MCP: Un cliente utilizado para iniciar el flujo de autenticación y probar la integración. Usaremos el MCP Inspector como cliente en esta guía.
  • Logto: Actúa como el proveedor de OpenID Connect (servidor de autorización) y gestiona las identidades de los usuarios.

Un diagrama de secuencia no normativo ilustra el flujo general del proceso:

nota:

Debido a que MCP está evolucionando rápidamente, el diagrama anterior puede no estar completamente actualizado. Por favor, consulta la documentación de mcp-auth para la información más reciente.

Configura la app en Logto​

  1. Inicia sesión en tu Consola de Logto.
  2. Ve a Aplicaciones → Crear aplicación → Crear app sin framework.
  3. Elige el tipo: Aplicación de una sola página.
  4. Rellena el nombre de la app y los demás campos requeridos, luego haz clic en Crear aplicación.
  5. Guarda y copia el ID de la app y el endpoint del emisor (Issuer endpoint).

Configura el servidor MCP​

Crea el proyecto e instala las dependencias​

mkdir mcp-server
cd mcp-server
uv init # O utiliza tu propia estructura de proyecto
uv add "mcp[cli]" starlette uvicorn mcpauth # O utiliza cualquier gestor de paquetes preferido

Configura la autenticación MCP con Logto​

Recuerda reemplazar <your-logto-issuer-endpoint> por el endpoint del emisor que copiaste anteriormente.

En 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)

Implementa la verificación de tokens​

Como vamos a verificar el token de acceso (Access token) y obtener la información del usuario, necesitamos implementar la verificación del token de acceso de la siguiente manera:

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,
    )

Implementa la herramienta "whoami"​

Ahora, vamos a implementar la herramienta "whoami" que devuelve los reclamos de identidad del usuario actual solicitando el endpoint userinfo con el token de acceso enviado por el cliente.

nota:

Estamos usando el transporte SSE para el ejemplo debido a la falta de soporte oficial para el transporte HTTP Streamable en la versión actual del SDK. Teóricamente, puedes usar cualquier transporte compatible con HTTP.

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:
    """
    Devuelve la información de identidad del usuario actual.
    """
    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(),  # Sirve metadatos OIDC para descubrimiento
        Mount('/', app=mcp.sse_app(), middleware=[bearer_auth]),
    ],
)

Ejecuta el servidor con:

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

Prueba la integración​

  1. Inicia el servidor MCP.

  2. Inicia el MCP Inspector.

    Debido a la limitación de la implementación actual del MCP Inspector, necesitamos usar la versión bifurcada de mcp-auth:

    git clone https://github.com/mcp-auth/inspector.git
    cd inspector
    npm install
    npm run dev

    Luego, abre la URL que aparece en la terminal.

  3. En el MCP Inspector:

    • Tipo de transporte: SSE
    • URL: http://localhost:3001/sse
    • OAuth Client ID: Pega tu App ID de Logto
    • Auth Params: {"scope": "openid profile email"}
    • Redirect URI: Esta URL debería autocompletarse. Cópiala.

  4. Busca la aplicación que creaste antes en la Consola de Logto, abre la página de detalles y pega el redirect URI en la sección Configuración / Redirect URIs. Guarda los cambios.

  5. De vuelta en el MCP Inspector, haz clic en Conectar. Esto debería redirigirte a la experiencia de inicio de sesión de Logto.

Después de completar el inicio de sesión, deberías ser redirigido de vuelta al MCP Inspector. Ve a Herramientas -> Listar herramientas -> whoami -> Ejecutar herramienta.

Deberías ver los reclamos del usuario, como:

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

El código completo del servidor MCP se puede encontrar en el repositorio mcp-auth/python.