Contrôler l'accès aux outils MCP avec FGA

L’autorisation à granularité fine va au-delà du simple contrôle d’accès fondé sur les permissions : elle permet de mettre en place des modèles d’autorisation sophistiqués qui reposent sur les relations entre les utilisateurs, les rôles, les groupes et les ressources. Ce démarrage rapide montre comment utiliser Auth0 FGA pour mettre en œuvre le contrôle d’accès basé sur les relations (ReBAC) dans les outils de votre serveur MCP. L’application d’exemple illustre cinq modèles d’autorisation :

Outils publics - Accessibles à tous les utilisateurs authentifiés, sans autorisation supplémentaire
Accès basé sur les rôles - Outils attribués à des rôles précis (admin, content_editor)
Appartenance à un groupe - Les utilisateurs héritent des autorisations de leurs groupes (gestionnaires, marketing)
Accès temporaire - Accès aux outils limité dans le temps, avec expiration automatique
Autorisations propres aux ressources - Contrôle à granularité fine des fonctionnalités des outils (p. ex., consultation de documents privés)

À la fin de ce démarrage rapide, vous disposerez d’un serveur MCP qui :

Authentifie les utilisateurs avec Auth0 OAuth 2.0
Utilise Auth0 FGA pour déterminer à quels outils chaque utilisateur peut accéder
Filtre dynamiquement la liste des outils en fonction des autorisations de l’utilisateur
Prend en charge des accès temporaires qui expirent automatiquement
Fournit des données différentes selon le rôle de l’utilisateur (documents publics ou privés)

Prerequisites

1. Create or log in to your Auth0 account

To continue with this quickstart, you need to have an Auth0 account.

2. Enable the Resource Parameter Compatibility Profile and Include Issuer in Authorization Responses

To use the resource parameter in your access tokens and the iss claim to identify your authorization server, you need to enable two toggles in the Auth0 Dashboard:

Navigate to Settings on the left sidebar.
Select Advanced in the top right corner.
Scroll down to the Settings section and enable the following toggles:
- Resource Parameter Compatibility Profile: Enables support for the resource parameter in authorization requests, allowing access tokens to be scoped to a specific API.
- Include Issuer in Authorization Responses: Includes the iss parameter identifying the authorization server in authorization responses, helping clients defend against mix-up attacks.

3. Install the Auth0 CLI

This guide uses Auth0 CLI to configure an Auth0 tenant for secure MCP tool access.

Follow the Auth0 CLI installation instructions.
Log in to your account with the Auth0 CLI:

auth0 login --scopes "read:client_grants,create:client_grants,delete:client_grants,read:clients,create:clients,update:clients,read:resource_servers,create:resource_servers,update:resource_servers,read:roles,create:roles,update:roles,update:tenant_settings,read:connections,update:connections"

Confirm you are in the correct tenant by double-checking the tenant domain in the terminal, or run the command below:

auth0 tenants list

If more than one tenant is configured, the default tenant will be indicated by an arrow.

4. Install jq

To simplify the process of interacting with the Auth0 CLI, we recommend installing jq. This will allow you to easily parse JSON responses from the CLI.

macOS
Linux
Windows

brew install jq

sudo apt-get install jq

choco install jq

Installez et configurez maintenant les dépendances de FGA :

1. Installer l'interface de ligne de commande FGA

This guide uses the OpenFGA CLI to manage authorization models and permissions.

Install the FGA CLI:

macOS
Linux
Windows

brew install openfga/tap/fga

Download the latest release from the OpenFGA CLI releases page and add it to your PATH.

# Example for Linux (replace version with latest)
wget https://github.com/openfga/cli/releases/download/v0.6.3/fga_0.6.3_linux_amd64.tar.gz
tar -xzf fga_0.6.3_linux_amd64.tar.gz
sudo mv fga /usr/local/bin/

Verify the installation:

fga version

2. Configurer Auth0 FGA ou OpenFGA

You’ll need an Auth0 FGA or OpenFGA store to manage fine-grained authorization for your MCP tools.Choose your FGA provider:

Auth0 FGA: Fully managed service at fga.dev. Best for production use.
OpenFGA: Self-hosted open-source option. Best for local development and testing.

Both options use the same authorization model and API. You can start with OpenFGA locally and migrate to Auth0 FGA for production.

The sample application includes a complete authorization model (fga/model.fga) and initial permission tuples (fga/tuples.yaml) that will be imported using the FGA CLI.

Configurer les paramètres du locataire

1. Promote the connection to a domain-level connection

To allow third-party clients like MCP Inspector to use a connection such as a username-and-password database or a social connection, you need to promote the connection to a domain-level connection. Learn more about configuring third-party applications.

List Your Connection

List your connections to get their IDs

auth0 api get connections

Choose Your Connections

From the list, identify which connections you want to use for the MCP server and copy the ID.

For the username-and-password database, look for the connection with the strategy auth0.
For the Google social connection, look for the connection with the strategy google-oauth2.

Upgrade the Connection to Domain-Level

For each of those specific connection IDs, run the following command to mark it as a domain-level connection. Replace YOUR_CONNECTION_ID with the actual ID (e.g., con_XXXXXXXXXXXXXXXX).

auth0 api patch connections/YOUR_CONNECTION_ID --data '{"is_domain_connection": true}'

Créer une API pour représenter votre serveur MCP

An MCP server is treated just like any other API in your Auth0 tenant, which means you can use the same access control, scoping, and authorization features. The API (also known as a Resource Server) represents your protected MCP Server. Run the following command to create an API in Auth0:

auth0 api post resource-servers --data '{
  "identifier": "http://localhost:3001/",
  "name": "MCP Tools API",
  "signing_alg": "RS256",
  "token_dialect": "rfc9068_profile_authz",
  "enforce_policies": true,
  "scopes": [
    {"value": "tool:whoami", "description": "Access the WhoAmI tool"},
    {"value": "tool:greet", "description": "Access the Greeting tool"}
  ]
}'

Note that rfc9068_profile_authz is used as the token dialect to include the permissions claim in the access token, which can be useful for the API to check user permissions without making additional calls. For more details on protecting APIs with Auth0, check our quickstarts.

Ce démarrage rapide utilise deux permissions OAuth à titre de démonstration : tool:greet et tool:whoami. L’outil get_datetime est public et ne nécessite aucune permission, tandis que get_documents utilise FGA pour gérer l’autorisation.

Configurer votre magasin FGA

Auth0 FGA
OpenFGA (Local)

Create an Auth0 FGA account

Create a store

In the Auth0 FGA dashboard, create a new store for your MCP server.

Generate API credentials

Navigate to Settings in your store.
In the Authorized Clients section, click + Create Client.
Give your client a name and select the following permissions:
- Read/Write model, changes, and assertions - To query authorization decisions
- Write and delete tuples - To import tuples (user permissions)
- Read and query - To import the authorization model
Click Create.
Save the credentials shown in the confirmation modal.

Configure environment variables

Set the following environment variables in your terminal. These will be used by the FGA CLI to connect to your store.

export FGA_API_URL='https://api.us1.fga.dev'
export FGA_STORE_ID='<your-store-id>'
export FGA_API_TOKEN_ISSUER='auth.fga.dev'
export FGA_API_AUDIENCE='https://api.us1.fga.dev/'
export FGA_CLIENT_ID='<your-client-id>'
export FGA_CLIENT_SECRET='<your-client-secret>'

Replace the placeholders with the credentials from the previous step. Note that FGA_API_URL may vary based on your region (e.g., api.eu1.fga.dev for Europe).

Install OpenFGA

Install OpenFGA using Homebrew or Docker:

Homebrew
Docker

brew install openfga

For other installation methods, see the OpenFGA releases page.

Start OpenFGA

Start the OpenFGA server:

Homebrew
Docker

openfga run

docker run -p 8080:8080 -p 8081:8081 -p 3000:3000 openfga/openfga run

The server will start on port 8080 by default. Leave this running in a separate terminal window.

Configure environment variables

Set the following environment variables in your terminal (in a different terminal from where OpenFGA is running):

export FGA_API_URL='http://localhost:8080'

The FGA_STORE_ID will be set after importing the model in the next section.

Application d’exemple

Commencez par télécharger ou cloner l’application d’exemple de ce Démarrage rapide. Cet exemple comprend un serveur MCP FastMCP intégrant Auth0 OAuth et Auth0 FGA en JavaScript/TypeScript.

Utiliser l'application d'exemple (recommandé)
Cloner le dépôt GitHub

Une fois le téléchargement terminé, extrayez les fichiers et ouvrez le projet dans l’IDE de votre choix.

Clonez le dépôt et accédez au dossier de l’application d’exemple :

git clone https://github.com/auth0-samples/auth0-ai-samples.git
cd auth0-ai-samples/auth-for-mcp/fastmcp-mcp-fga-js

Une fois le dépôt cloné, ouvrez le projet dans l’IDE de votre choix.

Installer les paquets

Installez les dépendances nécessaires :

npm install

Créer votre fichier d’environnement

From the root of your sample app directory, run the following command to create a new .env file with your Auth0 configuration:

DOMAIN=$(auth0 tenants list --json | jq -r '.[] | select(.active == true) | .name') \
&& touch .env \
&& echo "AUTH0_DOMAIN=${DOMAIN}" > .env \
&& echo "AUTH0_AUDIENCE=http://localhost:3001/" >> .env \
&& echo "PORT=3001" >> .env \
&& echo "MCP_SERVER_URL=http://localhost:3001" >> .env \
&& echo "" >> .env \
&& echo ".env file created with your Auth0 configuration:" \
&& cat .env

Next, add your FGA configuration to the .env file. The variables you need depend on which FGA provider you’re using:

Auth0 FGA
OpenFGA (Local)

Add the following to your .env file using the credentials from your Auth0 FGA store:

.env

# Auth0 FGA Configuration
FGA_API_URL=https://api.us1.fga.dev
FGA_STORE_ID=YOUR_STORE_ID
FGA_API_TOKEN_ISSUER=auth.fga.dev
FGA_API_AUDIENCE=https://api.us1.fga.dev/
FGA_CLIENT_ID=YOUR_CLIENT_ID
FGA_CLIENT_SECRET=YOUR_CLIENT_SECRET

Replace:

YOUR_STORE_ID with your store ID from the Auth0 FGA dashboard
YOUR_CLIENT_ID with your client ID
YOUR_CLIENT_SECRET with your client secret
Update FGA_API_URL if your store is in a different region (e.g., https://api.eu1.fga.dev for Europe)

Add the following to your .env file:

.env

# OpenFGA Configuration
FGA_API_URL=http://localhost:8080
FGA_STORE_ID=YOUR_STORE_ID

Replace YOUR_STORE_ID with the store ID that will be generated when you import the authorization model in the next step.

If you haven’t run fga store import yet, you can leave FGA_STORE_ID empty for now and add it after the import completes.

Your complete .env file should look like this:

Auth0 FGA
OpenFGA (Local)

.env

AUTH0_DOMAIN=YOUR_TENANT.us.auth0.com
AUTH0_AUDIENCE=http://localhost:3001/
PORT=3001
MCP_SERVER_URL=http://localhost:3001

# Auth0 FGA Configuration
FGA_API_URL=https://api.us1.fga.dev
FGA_STORE_ID=YOUR_STORE_ID
FGA_API_TOKEN_ISSUER=auth.fga.dev
FGA_API_AUDIENCE=https://api.us1.fga.dev/
FGA_CLIENT_ID=YOUR_CLIENT_ID
FGA_CLIENT_SECRET=YOUR_CLIENT_SECRET

.env

AUTH0_DOMAIN=YOUR_TENANT.us.auth0.com
AUTH0_AUDIENCE=http://localhost:3001/
PORT=3001
MCP_SERVER_URL=http://localhost:3001

# OpenFGA Configuration
FGA_API_URL=http://localhost:8080
FGA_STORE_ID=YOUR_STORE_ID

Comprendre le modèle d’autorisation

The authorization model in this sample demonstrates how Auth0 FGA provides fine-grained access control using Relationship-Based Access Control (ReBAC).

Authorization Model Structure

The complete model is defined in fga/model.fga:

model
  schema 1.1

  type user

  # User groups
  type group
    relations
      define member : [user]

  # Roles can be linked to users or members of a user group
  type role
    relations
      define assignee : [user, group#member]

  type tool
    relations
      # Public access, role-based, and temporal access
      define can_use : [user:*, user, role#assignee, user with temporal_access, role#assignee with temporal_access]

      # Resource-specific permission for get_documents tool
      define can_view_private_documents : [role#assignee]

  # Temporal access condition
  condition temporal_access(grant_time: timestamp, grant_duration: duration, current_time: timestamp) {
    current_time < grant_time + grant_duration
  }

The model defines four authorization patterns:

1. Public Tools

Tools that are accessible to all authenticated users without requiring specific permissions.

# In fga/tuples.yaml
- user: user:*
  relation: can_use
  object: tool:get_datetime

The wildcard user:* means any authenticated user can use the get_datetime tool.

2. Role-Based Access

Tools are assigned to specific roles, and users with those roles can access the tools.

# In fga/tuples.yaml
# Admin role can use all tools
- user: role:admin#assignee
  relation: can_use
  object: tool:greet

- user: role:admin#assignee
  relation: can_use
  object: tool:whoami

- user: role:admin#assignee
  relation: can_use
  object: tool:get_documents

Users assigned the admin role automatically gain access to these tools.

3. Group Membership

Users inherit permissions through group membership. Groups are assigned to roles, creating a permission chain.

# In fga/tuples.yaml
# Managers group is assigned the admin role
- user: group:managers#member
  relation: assignee
  object: role:admin

# Marketing group is assigned the content_editor role
- user: group:marketing#member
  relation: assignee
  object: role:content_editor

Permission Chain: User → Group → Role → ToolWhen you add a user to the managers group, they automatically inherit all permissions of the admin role, including access to all tools.

4. Temporal Access

Time-limited access to tools that automatically expires after a specified duration.

// In fga/model.fga
condition temporal_access(grant_time: timestamp, grant_duration: duration, current_time: timestamp) {
  current_time < grant_time + grant_duration
}

// Tools can be assigned with temporal conditions
define can_use : [user:*, user, role#assignee, user with temporal_access, role#assignee with temporal_access]

When you grant temporal access (e.g., “20 seconds to use the greet tool”), FGA evaluates the condition on each request. Access is automatically revoked when the time expires.

5. Resource-Specific Permissions

Fine-grained permissions for specific features or data within tools.

# In fga/tuples.yaml
# Admin role can view private documents
- user: role:admin#assignee
  relation: can_view_private_documents
  object: tool:get_documents

The get_documents tool checks this permission separately to determine whether to return private documents. This allows the same tool to provide different data based on user permissions.Example:

Admin role: Sees all documents (public + private)
Content editor role: Sees only public documents

How Authorization Works

When a user connects to the MCP server:

The server authenticates the user with Auth0 (validates JWT token)
The server queries FGA to get all tools the user can access:
- Checks can_use relation for each tool
- Evaluates group memberships, role assignments, and temporal conditions
The server returns only authorized tools to the MCP client
When the user calls a tool like get_documents, the server checks can_view_private_documents to determine what data to return

This approach ensures that authorization decisions are centralized in FGA and can be updated dynamically without changing code.

Importer le modèle d’autorisation et les tuples

L’exemple comprend un modèle d’autorisation complet et des tuples d’autorisation initiaux qui définissent :

L’accès public à get_datetime pour tous les utilisateurs
Les attributions de rôles (admin, content_editor)
Les mappages de groupes vers des rôles (managers → admin, marketing → content_editor)
Les autorisations d’accès aux outils pour chaque rôle

Examiner le modèle d’autorisation

Le modèle d’autorisation est défini dans fga/model.fga. Il comprend des types pour les utilisateurs, les groupes, les rôles et les outils, ainsi qu’une condition d’accès temporelle.Les tuples initiaux sont définis dans fga/tuples.yaml et établissent les autorisations de base.

Importer le modèle et les tuples

À la racine du répertoire de votre application d’exemple, exécutez :

fga store import --file fga/store.fga.yaml

Cette commande permet de :

Créer un nouveau magasin FGA (si vous utilisez OpenFGA localement)
Téléverser le modèle d’autorisation à partir de fga/model.fga
Importer les tuples initiaux à partir de fga/tuples.yaml
Exécuter les tests définis dans fga/store.fga.yaml pour vérifier la configuration

Si vous utilisez OpenFGA, la sortie de la commande comprendra un identifiant de magasin. Copiez cet identifiant et ajoutez-le à votre fichier .env en tant que FGA_STORE_ID. Si vous utilisez Auth0 FGA avec un magasin existant, la commande mettra à jour votre magasin avec le nouveau modèle et les nouveaux tuples.

Vérifier l’importation

Si l’importation réussit, vous devriez obtenir une sortie semblable à celle-ci :

{
  "store": {
    "id": "01KB0NZZFAV9AX7SAPWY23KJAF",
    "name": "fastmcp-fga-example",
    "created_at": "2025-01-22T10:30:00Z",
    "updated_at": "2025-01-22T10:30:00Z"
  },
  "model": {
    "authorization_model_id": "01KED54TEMBDE753YBK7NT3DRZ"
  }
}

À la fin, les tests devraient indiquer que toutes les vérifications ont réussi, ce qui confirme que le modèle d’autorisation fonctionne correctement.

Si vous utilisez Auth0 FGA, vous pouvez consulter et gérer votre modèle d’autorisation dans le Dashboard Auth0 FGA. Le Dashboard offre un explorateur de modèle visuel et vous permet de consulter, d’ajouter et de supprimer des tuples en temps réel.

Exécuter le serveur MCP

Démarrez le serveur MCP :

npm run start

Le serveur démarrera sur le port 3001 (ou sur le port indiqué dans votre fichier .env). La console devrait afficher des messages indiquant que :

le serveur a bien démarré;
le client FGA a été initialisé;
le serveur est à l’écoute des connexions à l’adresse http://localhost:3001/mcp.

FastMCP Auth0 Example Server started
FGA client initialized for store: 01KB0NZZFAV9AX7SAPWY23KJAF
Server listening on http://localhost:3001/mcp

Laissez le serveur en cours d’exécution : vous en aurez besoin pour les tests des sections suivantes.

Gérer les autorisations des utilisateurs

The sample application includes helper scripts in the fga/ directory to make permission management easier. These scripts use the FGA CLI to add or remove authorization tuples dynamically.

Available Scripts

Add User to Group

Grant a user all permissions associated with a group (and its assigned role).Usage:

./fga/add-user-to-group.sh <user-email> <group-name>

Examples:

# Add user to managers group (grants admin role with full access)
./fga/add-user-to-group.sh user@example.com managers

# Add user to marketing group (grants content_editor role)
./fga/add-user-to-group.sh user@example.com marketing

What it does: Creates an FGA tuple that makes the user a member of the specified group. Since groups are assigned to roles, the user automatically inherits all role permissions.Available groups:

managers - Assigned to admin role (all tools + private documents)
marketing - Assigned to content_editor role (all tools, public documents only)

Remove User from Group

Revoke a user’s group membership and all associated permissions.Usage:

./fga/remove-user-from-group.sh <user-email> <group-name>

Example:

# Remove user from managers group
./fga/remove-user-from-group.sh user@example.com managers

What it does: Deletes the FGA tuple that grants group membership. The user immediately loses all permissions from that group’s role.

Grant Temporal Access

Provide time-limited access to a specific tool that automatically expires.Usage:

./fga/add-temporal-access.sh <user-email> <tool-name> <duration>

Examples:

# Grant 20-second access to the greet tool
./fga/add-temporal-access.sh user@example.com greet 20s

# Grant 1-hour access to the whoami tool
./fga/add-temporal-access.sh user@example.com whoami 1h

# Grant 5-minute access
./fga/add-temporal-access.sh user@example.com greet 5m

What it does: Creates an FGA tuple with a temporal condition. FGA evaluates the condition on each request and automatically denies access when the duration expires. No cleanup is needed.Supported durations: Use standard time notation (s for seconds, m for minutes, h for hours).Available tools: greet, whoami, get_documents

Public tools like get_datetime don’t need temporal access grants since they’re already accessible to all authenticated users.

Reset Tuples

Reset all tuples to the initial state defined in fga/tuples.yaml.Usage:

./fga/reset-tuples.sh

What it does: Deletes all existing tuples and reimports the default tuples from fga/tuples.yaml. Useful for returning to a clean state during testing.

This script removes all user assignments, including any custom permissions you’ve added. Use with caution.

Testing Permission Changes

After running any of these scripts, you need to reload the tools:

for MCP inspector: click ‘Clear’ in the MCP inspector tools panel and then ‘List Tools’
for other MCP clients: you might need to reconnect the MCP Client to see the updated tool list.

The server queries FGA on each connection to determine available tools.

You can also manage tuples directly in the Auth0 FGA Dashboard if you’re using Auth0 FGA. The dashboard provides a visual interface for viewing, adding, and removing authorization tuples in real-time.

Testing your MCP server

Now that your MCP server is up and running, you can test it by using tools like MCP Inspector.

Learn how to test your Auth0-powered MCP server

Tester les scénarios d’autorisation

Testez maintenant différents scénarios d’autorisation pour voir comment FGA contrôle l’accès aux outils. Vous devrez utiliser un client MCP comme MCP Inspector pour vous connecter à votre serveur.

Tester l’accès de base

Connectez-vous à votre serveur MCP avec vos informations d’identification d’utilisateur. Au départ, seul l’outil public devrait s’afficher.Outils attendus : get_datetimeOn constate ainsi que, sans attribution de rôle ni de groupe, les utilisateurs authentifiés n’ont accès qu’aux outils publics.

Accorder l’accès administrateur au moyen du groupe managers

Ajoutez votre utilisateur au groupe managers pour lui accorder les autorisations du rôle administrateur :

./fga/add-user-to-group.sh YOUR_EMAIL managers

Remplacez YOUR_EMAIL par l’adresse courriel que vous utilisez pour vous authentifier.Reconnectez-vous dans votre client MCP et vérifiez que tous les outils s’affichent maintenant.Outils attendus : get_datetime, greet, whoami, get_documentsAppelez l’outil get_documents et vérifiez que la réponse contient à la fois les documents publics et privés. On voit ainsi des autorisations propres aux ressources, fondées sur le rôle administrateur.

Dans MCP Inspector, vous devrez vous déconnecter puis vous reconnecter (ou actualiser la connexion) après avoir modifié les autorisations. Le serveur interroge FGA à chaque nouvelle connexion pour déterminer les outils disponibles.

Tester le rôle d’éditeur de contenu

Passez du rôle administrateur à celui d’éditeur de contenu en modifiant l’appartenance aux groupes :

./fga/remove-user-from-group.sh YOUR_EMAIL managers
./fga/add-user-to-group.sh YOUR_EMAIL marketing

Reconnectez-vous dans votre client MCP.Outils attendus : get_datetime, greet, whoami, get_documentsAppelez l’outil get_documents et vérifiez que seuls les documents publics s’affichent désormais (aucun document privé). On voit ainsi comment un même outil peut fournir des données différentes selon le rôle de l’utilisateur.Différence clé : les éditeurs de contenu ont accès aux mêmes outils que les administrateurs, mais ne disposent pas de l’autorisation can_view_private_documents.

Tester l’accès temporaire

Retirez toutes les appartenances aux groupes et accordez un accès limité dans le temps à un outil précis :

./fga/remove-user-from-group.sh YOUR_EMAIL marketing
./fga/add-temporal-access.sh YOUR_EMAIL greet 20s

Cette commande accorde un accès de 20 secondes à l’outil greet.Reconnectez-vous immédiatement dans votre client MCP.Outils attendus : get_datetime, greetAppelez l’outil greet pour vérifier qu’il fonctionne.Attendez 25 secondes, puis reconnectez-vous.Outils attendus : get_datetime (seulement)L’outil greet ne devrait plus apparaître. On constate ainsi que l’accès temporaire expire automatiquement, sans aucun nettoyage nécessaire.

L’accès temporaire est évalué en temps réel à chaque requête. Une fois la durée écoulée, FGA refuse automatiquement l’accès, même si le tuple existe toujours dans la base de données.

Prochaines étapes

Découvrez l’approche plus simple fondée sur les permissions dans Autorisation pour votre serveur MCP
Consultez la documentation d’Auth0 FGA pour en savoir plus sur la conception de modèles d’autorisation
Lisez la documentation d’OpenFGA pour découvrir des schémas de modélisation avancés et des pratiques exemplaires
Apprenez à tester votre serveur MCP avec MCP Inspector

Premiers pas

Guides

Exemples d’applications

Contrôler l'accès aux outils MCP avec FGA

Prerequisites

Configurer les paramètres du locataire

Créer une API pour représenter votre serveur MCP

Configurer votre magasin FGA

Application d’exemple

Installer les paquets

Créer votre fichier d’environnement

Comprendre le modèle d’autorisation

Authorization Model Structure

How Authorization Works

Importer le modèle d’autorisation et les tuples

Exécuter le serveur MCP

Gérer les autorisations des utilisateurs

Available Scripts

Testing Permission Changes

Testing your MCP server

Learn how to test your Auth0-powered MCP server

Tester les scénarios d’autorisation

Prochaines étapes

​Prerequisites

​Configurer les paramètres du locataire

​Créer une API pour représenter votre serveur MCP

​Configurer votre magasin FGA

​Application d’exemple

​Installer les paquets

​Créer votre fichier d’environnement

​Comprendre le modèle d’autorisation

​Authorization Model Structure

​How Authorization Works

​Importer le modèle d’autorisation et les tuples

​Exécuter le serveur MCP

​Gérer les autorisations des utilisateurs

​Available Scripts

​Testing Permission Changes

​Testing your MCP server

Learn how to test your Auth0-powered MCP server

​Tester les scénarios d’autorisation

​Prochaines étapes

Prerequisites

Configurer les paramètres du locataire

Créer une API pour représenter votre serveur MCP

Configurer votre magasin FGA

Application d’exemple

Installer les paquets

Créer votre fichier d’environnement

Comprendre le modèle d’autorisation

Authorization Model Structure

How Authorization Works

Importer le modèle d’autorisation et les tuples

Exécuter le serveur MCP

Gérer les autorisations des utilisateurs

Available Scripts

Testing Permission Changes

Testing your MCP server

Tester les scénarios d’autorisation

Prochaines étapes