Habilite autenticação para seus apps com MCP usando Logto

Este guia mostra como integrar o Logto ao seu servidor MCP usando o mcp-auth, permitindo autenticar usuários e recuperar com segurança suas informações de identidade usando o fluxo padrão do OpenID Connect.

Você aprenderá a:

Configurar o Logto como servidor de autorização para seu servidor MCP.
Configurar uma ferramenta “whoami” em seu servidor MCP para retornar as reivindicações de identidade do usuário atual.
Testar o fluxo com o MCP Inspector (cliente MCP).

Após este tutorial, seu servidor MCP irá:

Autenticar usuários no seu tenant Logto.
Retornar reivindicações de identidade (sub, username, name, email, etc.) para a invocação da ferramenta "whoami".

Depois de concluir a integração, você pode substituir o MCP Inspector pelo seu próprio cliente MCP, como um aplicativo web, para acessar as ferramentas e recursos expostos pelo seu servidor MCP.

Pré-requisitos

Um tenant do Logto Cloud (ou auto-hospedado)
Ambiente Node.js ou Python

Entendendo a arquitetura

Servidor MCP: O servidor que expõe ferramentas e recursos para clientes MCP.
Cliente MCP: Um cliente usado para iniciar o fluxo de autenticação e testar a integração. Usaremos o MCP Inspector como cliente neste guia.
Logto: Atua como o provedor OpenID Connect (servidor de autorização) e gerencia as identidades dos usuários.

Um diagrama de sequência não normativo ilustra o fluxo geral do processo:

nota:

Devido à rápida evolução do MCP, o diagrama acima pode não estar totalmente atualizado. Consulte a documentação do mcp-auth para as informações mais recentes.

Configurar o app no Logto

Faça login no seu Logto Console.
Vá para Aplicativos → Criar aplicativo → Criar app sem framework.
Escolha o tipo: Aplicativo de página única.
Preencha o nome do app e outros campos obrigatórios, depois clique em Criar aplicativo.
Salve e copie o App ID e o Issuer endpoint.

Configurar o servidor MCP

Criar projeto e instalar dependências

Python
Node.js

mkdir mcp-server
cd mcp-server
uv init # Ou use sua própria estrutura de projeto
uv add "mcp[cli]" starlette uvicorn mcpauth # Ou use qualquer gerenciador de pacotes de sua preferência

mkdir mcp-server
cd mcp-server
npm init -y
npm install @modelcontextprotocol/sdk express mcp-auth # Ou use qualquer gerenciador de pacotes de sua preferência

Configurar autenticação MCP com Logto

Lembre-se de substituir <your-logto-issuer-endpoint> pelo endpoint do emissor que você copiou anteriormente.

Python
Node.js

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

Em whoami.js:

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

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

Implementar verificação de token

Como vamos verificar o token de acesso (Access token) e recuperar as informações do usuário, precisamos implementar a verificação do token de acesso conforme abaixo:

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,
  };
};

Implementar a ferramenta "whoami"

Agora, vamos implementar a ferramenta "whoami" que retorna as reivindicações de identidade do usuário atual, solicitando o endpoint userinfo com o token de acesso enviado pelo cliente.

nota:

Estamos usando o transporte SSE para o exemplo devido à falta de suporte oficial ao transporte HTTP Streamable na versão atual do SDK. Teoricamente, você pode usar qualquer transporte compatível com 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:
    """
    Retorna as informações de identidade do usuário atual.
    """
    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(),  # Serve metadados OIDC para descoberta
        Mount('/', app=mcp.sse_app(), middleware=[bearer_auth]),
    ],
)

Execute o servidor com:

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

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

// Crie o servidor MCP e registre a ferramenta 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' }) },
  ],
}));

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

// Transporte SSE (como na documentação do 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);

Execute o servidor com:

node whoami.js

Testar a integração

Inicie o servidor MCP
Inicie o MCP Inspector.

Devido à limitação da implementação atual do MCP Inspector, precisamos usar a versão bifurcada do mcp-auth:
```
git clone https://github.com/mcp-auth/inspector.git
cd inspector
npm install
npm run dev
```
Depois, abra a URL exibida no terminal.
No MCP Inspector:
- Transport Type: SSE
- URL: http://localhost:3001/sse
- OAuth Client ID: Cole seu App ID do Logto
- Auth Params: {"scope": "openid profile email"}
- Redirect URI: Esta URL deve ser preenchida automaticamente. Copie-a.
Encontre o aplicativo que você criou anteriormente no Logto Console, abra a página de detalhes e cole o redirect URI na seção Configurações / Redirect URIs. Salve as alterações.
De volta ao MCP Inspector, clique em Connect. Isso deve redirecionar você para a experiência de login do Logto.

Após concluir o login, você deve ser redirecionado de volta ao MCP Inspector. Vá para Tools -> List Tools -> whoami -> Run Tool.

Você deve ver as reivindicações do usuário, como:

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

Python
Node.js

O código completo do servidor MCP pode ser encontrado no repositório mcp-auth/python.

Pré-requisitos​

Entendendo a arquitetura​

Configurar o app no Logto​

Configurar o servidor MCP​

Criar projeto e instalar dependências​

Configurar autenticação MCP com Logto​

Implementar verificação de token​

Implementar a ferramenta "whoami"​

Testar a integração​