Zugriff von Drittanbieter-AI-Agenten auf deinen MCP-Server ermöglichen

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

Du lernst, wie du:

• Logto als Autorisierungsserver für deinen MCP-Server konfigurierst.
• Ein „whoami“-Tool in deinem MCP-Server einrichtest, um die Identitätsansprüche des aktuellen Benutzers zurückzugeben.
• Den Ablauf mit einem Drittanbieter-AI-Agenten (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 den Aufruf des "whoami"-Tools zurückgeben.

Unterschied zwischen Drittanbieter-AI-Agent (MCP-Client) und deinem eigenen MCP-Client

Schauen wir uns ein Beispiel an. Stell dir vor, du bist Entwickler und betreibst einen MCP-Server zur Verwaltung von E-Mail-Zugriff und Automatisierung.

Offizielle E-Mail-App (Dein eigener MCP-Client)

• Du stellst eine offizielle E-Mail-App bereit, mit der Benutzer ihre E-Mails lesen und verwalten können.
• So funktioniert es: Die offizielle E-Mail-App verbindet sich mit deinem MCP-Server und verwendet Logto zur Authentifizierung der Benutzer. Wenn sich Alice anmeldet, erhält sie automatisch Zugriff auf ihre E-Mails, ohne dass zusätzliche Zustimmungsbildschirme erforderlich sind, da es sich um deine vertrauenswürdige App handelt.

Drittanbieter-AI-Agent (Drittanbieter-MCP-Client)

• Du baust ein Ökosystem rund um deinen MCP-Server auf, sodass ein anderer Entwickler „SmartMail AI“ (einen KI-Assistenten, der E-Mails zusammenfassen und automatisch Meetings planen kann) als Drittanbieter-Client integriert.
• So funktioniert es: SmartMail AI (Drittanbieter-MCP-Client) möchte über deinen MCP-Server auf Benutzere-Mails zugreifen. Wenn sich Alice mit ihrem Konto bei SmartMail AI anmeldet:
  • Ihr wird ein Zustimmungsbildschirm angezeigt, der um Erlaubnis bittet, dass SmartMail AI ihre E-Mails und ihren Kalender lesen darf.
  • Alice kann diesen Zugriff erlauben oder verweigern.
  • Nur die Daten, denen sie zustimmt, werden mit SmartMail AI geteilt, und SmartMail AI kann ohne erneute ausdrückliche Zustimmung auf keine weiteren Daten zugreifen.

Diese Zugriffskontrolle (Berechtigung) stellt die Sicherheit der Benutzerdaten sicher: Auch wenn dein MCP-Server alle Daten verwaltet, können Drittanbieter-Apps wie SmartMail AI nur auf das zugreifen, was der Benutzer ausdrücklich erlaubt hat. Sie können diesen Prozess nicht umgehen, da er durch deine Zugriffskontroll-Implementierung im MCP-Server erzwungen wird.

Zusammenfassung

Client-Typ	Beispiel	Zustimmung erforderlich?	Wer steuert es?
Offizielle E-Mail-App	Deine eigene E-Mail-App	Nein	Du (der Entwickler)
Drittanbieter-AI-Agent	SmartMail AI-Assistent	Ja	Ein anderer Entwickler

hinweis:

Wenn du deinen MCP-Server mit deinem eigenen AI-Agenten oder deiner eigenen App integrieren möchtest, siehe die Anleitung Authentifizierung für deine MCP-basierten Apps mit Logto aktivieren.

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. Der Drittanbieter-AI-Agent wird in dieser Anleitung als Client verwendet.
• 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.

Drittanbieter-AI-Agent einrichten

Um dem Drittanbieter-AI-Agenten den Zugriff auf deinen MCP-Server zu ermöglichen, musst du Folgendes einrichten:

1. Der Client sollte in der Lage sein, MCP-Anfragen zu stellen, um die vom MCP-Server bereitgestellten Tools aufzurufen.
2. Der Client sollte in der Lage sein, auf die Antwort 401 Unauthorized zu reagieren. Siehe Autorisierungsablauf-Schritte für weitere Details.
3. Nach erfolgreicher Authentifizierung sollte der Client in der Lage sein, Anfragen an den MCP-Server mit dem von Logto erhaltenen Zugangstoken zu stellen.

AI-Agent in Logto einrichten

Um dem Drittanbieter-AI-Agenten den Zugriff auf deinen MCP-Server zu ermöglichen, musst du eine Drittanbieter-App in Logto einrichten. Diese App repräsentiert den AI-Agenten und erhält die notwendigen Zugangsdaten für Authentifizierung und Autorisierung.

Entwicklern erlauben, Drittanbieter-Apps in Logto zu erstellen

Wenn du einen Marktplatz aufbaust oder Entwicklern erlauben möchtest, Drittanbieter-Apps in Logto zu erstellen, kannst du die Logto Management API nutzen, um Drittanbieter-Apps programmatisch zu erstellen. So können Entwickler ihre Anwendungen registrieren und die erforderlichen Zugangsdaten für die Authentifizierung erhalten.

Du musst einen eigenen Dienst hosten, um den Client-Registrierungsprozess zu verwalten. Dieser Dienst interagiert mit der Logto Management API, um Drittanbieter-Apps im Namen der Entwickler zu erstellen.

Alternativ kannst du Drittanbieter-Apps auch manuell in der Logto-Konsole erstellen, um dich mit dem Prozess vertraut zu machen.

Drittanbieter-App in Logto manuell erstellen

Du kannst eine Drittanbieter-App in der Logto-Konsole manuell für Testzwecke oder Ad-hoc-Integrationen erstellen. Das ist nützlich, wenn du die Integration schnell testen möchtest, ohne einen vollständigen Client-Registrierungsablauf zu implementieren.

1. Melde dich in deiner Logto-Konsole an.
2. Gehe zu Anwendungen → Anwendung erstellen → Drittanbieter-App -> OIDC.
3. Gib den App-Namen und andere erforderliche Felder ein und klicke dann auf Anwendung erstellen.
4. Klicke auf den Tab Berechtigungen, im Bereich Benutzer auf "Hinzufügen" klicken.
5. Im geöffneten Dialog -> Benutzerdaten -> wähle die Berechtigungen profile, email aus und klicke dann auf Speichern.
6. Konfiguriere in der Drittanbieter-App die Scopes, um die Berechtigungen openid profile email anzufordern.
7. Konfiguriere die Redirect-URI deiner Drittanbieter-Anwendung entsprechend. Denke daran, die Redirect-URI auch in Logto zu aktualisieren.

---

Unter der Haube ist eine Drittanbieter-App einfach ein Standard-OAuth 2.0 / OIDC-Client. Das bedeutet, dass du (oder der Drittanbieter-Entwickler) jede OAuth 2.0 / OIDC-Bibliothek oder jedes Framework verwenden kannst, um die Integration mit Logto vorzunehmen.

Falls du mit OAuth 2.0 oder OIDC nicht vertraut bist, kannst du mit einem unserer Schnellstart-Guides für „Traditionelle Web“-Anwendungen beginnen.

Einige Dinge, die du beachten solltest:

1. Logto erfordert derzeit, dass Drittanbieter-Apps „Traditionelle Web“-Anwendungen sind. Mit anderen Worten: Die App benötigt einen Backend-Server (oder Backend-for-Frontend), um das Client-Secret sicher zu speichern.
2. Die meisten unserer Schnellstart-Guides sind für First-Party-Apps geschrieben, du kannst sie aber trotzdem als Referenz für die Integration von Drittanbieter-Apps verwenden.
3. Der Hauptunterschied besteht darin, dass Drittanbieter-Apps einen Zustimmungsbildschirm (Consent screen) anzeigen, der die Benutzer um ausdrückliche Erlaubnis zum Zugriff auf ihre Daten bittet.

Weitere Informationen findest du in unseren Schnellstart-Guides.

Richte den MCP-Server ein

Projekt erstellen und Abhängigkeiten installieren

Python

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

Node.js

mkdir mcp-server
cd mcp-server
npm init -y
npm install @modelcontextprotocol/sdk express mcp-auth # Oder verwende einen beliebigen Paketmanager

MCP-Authentifizierung mit Logto konfigurieren

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

Python

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)

Node.js

In whoami.js:

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

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

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:

Python

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

Node.js

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

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.

Python

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

Node.js

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

// MCP-Server erstellen und das whoami-Tool registrieren
const server = new McpServer({ name: 'WhoAmI', version: '0.0.0' });
server.tool('whoami', ({ authInfo }) => ({
  content: [
    { type: 'text', text: JSON.stringify(authInfo?.claims ?? { error: 'Nicht authentifiziert' }) },
  ],
}));

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

// SSE-Transport (wie in den SDK-Dokumenten)
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('Kein Transport für sessionId gefunden');
});

app.listen(3001);

Starte den Server mit:

node whoami.js

Integration testen

1. Starte den MCP-Server.
2. Starte den AI-Agenten.
3. Rufe im Client das whoami-Tool auf, um die Identitätsansprüche des aktuellen Benutzers abzurufen.
4. Der Client sollte auf die Antwort 401 Unauthorized reagieren und den Benutzer zur Authentifizierung an Logto weiterleiten.
5. Nach erfolgreicher Authentifizierung sollte der Client ein Zugangstoken erhalten und dieses für Anfragen an den MCP-Server verwenden.
6. Der Client sollte in der Lage sein, die Identitätsansprüche vom MCP-Server mit dem Zugangstoken abzurufen.

Python

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

Node.js

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