Zum Hauptinhalt springen

Authentifizierung für deine MCP-basierten Apps mit Logto aktivieren

Diese Anleitung führt dich durch die Integration von Logto mit deinem MCP-Server unter Verwendung von mcp-auth. Dadurch kannst du Benutzer authentifizieren und ihre Identitätsinformationen sicher über den standardmäßigen OpenID Connect-Flow abrufen.

Du lernst, wie du:

  • Logto als Autorisierungsserver für deinen MCP-Server konfigurierst.
  • Ein „whoami“-Tool in deinem MCP-Server einrichtest, das die Identitätsansprüche des aktuellen Benutzers zurückgibt.
  • Den Ablauf mit dem MCP Inspector (MCP-Client) testest.

Nach diesem Tutorial wird dein MCP-Server:

  • Benutzer in deinem Logto-Mandanten authentifizieren.
  • Identitätsansprüche (sub, username, name, email usw.) für die Ausführung des "whoami"-Tools zurückgeben.

Sobald die Integration abgeschlossen ist, kannst du den MCP Inspector durch deinen eigenen MCP-Client ersetzen, z. B. eine Webanwendung, um auf die vom MCP-Server bereitgestellten Tools und Ressourcen zuzugreifen.

Voraussetzungen​

  • Ein Logto Cloud (oder selbst gehosteter) Mandant
  • Node.js- oder Python-Umgebung

Architektur verstehen​

  • MCP-Server: Der Server, der Tools und Ressourcen für MCP-Clients bereitstellt.
  • MCP-Client: Ein Client, der den Authentifizierungsablauf initiiert und die Integration testet. Wir verwenden den MCP Inspector als Client in dieser Anleitung.
  • Logto: Dient als OpenID Connect-Anbieter (Autorisierungsserver) und verwaltet Benutzeridentitäten.

Ein nicht-normativer Sequenzdiagramm veranschaulicht den Gesamtablauf des Prozesses:

hinweis:

Da sich MCP schnell weiterentwickelt, ist das obige Diagramm möglicherweise nicht vollständig aktuell. Bitte konsultiere die mcp-auth Dokumentation für die neuesten Informationen.

App in Logto einrichten​

  1. Melde dich in deiner Logto-Konsole an.
  2. Gehe zu Anwendungen → Anwendung erstellen → App ohne Framework erstellen.
  3. Wähle den Typ: Single-Page-App.
  4. Fülle den App-Namen und andere erforderliche Felder aus und klicke dann auf Anwendung erstellen.
  5. Speichere und kopiere die App-ID und den Issuer-Endpunkt.

Richte den MCP-Server ein​

Projekt erstellen und Abhängigkeiten installieren​

mkdir mcp-server
cd mcp-server
uv init # Oder verwende deine eigene Projektstruktur
uv add "mcp[cli]" starlette uvicorn mcpauth # Oder verwende einen beliebigen Paketmanager

MCP-Authentifizierung mit Logto konfigurieren​

Denke daran, <your-logto-issuer-endpoint> durch den zuvor kopierten Aussteller-Endpunkt zu ersetzen.

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

Token-Überprüfung implementieren​

Da wir das Zugangstoken (Access token) überprüfen und Benutzerinformationen abrufen möchten, müssen wir die Überprüfung des Zugangstokens wie folgt implementieren:

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

Das "whoami"-Tool implementieren​

Nun implementieren wir das "whoami"-Tool, das die Identitätsansprüche (Claims) des aktuellen Benutzers zurückgibt, indem es den userinfo-Endpunkt mit dem vom Client gesendeten Zugangstoken (Access token) abfragt.

hinweis:

Wir verwenden für das Beispiel den SSE-Transport, da der Streamable HTTP-Transport in der aktuellen Version des SDKs noch nicht offiziell unterstützt wird. Theoretisch kannst du jeden HTTP-kompatiblen Transport verwenden.

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:
    """
    Gibt die Identitätsinformationen des aktuellen Benutzers zurück.
    """
    return (
        mcp_auth.auth_info.claims
        if mcp_auth.auth_info
        else {"error": "Nicht authentifiziert"}
    )

bearer_auth = Middleware(mcp_auth.bearer_auth_middleware(verify_access_token))
app = Starlette(
    routes=[
        mcp_auth.metadata_route(),  # Stellt OIDC-Metadaten für Discovery bereit
        Mount('/', app=mcp.sse_app(), middleware=[bearer_auth]),
    ],
)

Starte den Server mit:

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

Integration testen​

  1. Starte den MCP-Server.

  2. Starte den MCP Inspector.

    Aufgrund der Einschränkungen der aktuellen MCP Inspector-Implementierung müssen wir die geforkte Version von mcp-auth verwenden:

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

    Öffne dann die im Terminal angezeigte URL.

  3. Im MCP Inspector:

    • Transporttyp: SSE
    • URL: http://localhost:3001/sse
    • OAuth Client ID: Füge deine Logto App-ID ein
    • Auth Params: {"scope": "openid profile email"}
    • Redirect URI: Diese URL sollte automatisch ausgefüllt werden. Kopiere sie.

  4. Suche die zuvor erstellte Anwendung in der Logto-Konsole, öffne die Detailseite und füge die Redirect URI im Bereich Einstellungen / Redirect URIs ein. Speichere die Änderungen.

  5. Zurück im MCP Inspector, klicke auf Connect. Dies sollte dich zur Logto-Anmeldeerfahrung weiterleiten.

Nach Abschluss der Anmeldung solltest du zurück zum MCP Inspector weitergeleitet werden. Gehe zu Tools -> List Tools -> whoami -> Run Tool.

Du solltest Benutzeransprüche wie diese sehen:

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

Der vollständige MCP-Server-Code ist im Repository mcp-auth/python zu finden.