Image de couverture : Serveur MCP sous Laravel : le schéma d'un outil ne vaut pas une autorisation
IA & Ingénierie

Serveur MCP sous Laravel : le schéma d'un outil ne vaut pas une autorisation

5 min de lecture
49 vues
Sébastien Muler

Votre assistant IA peut-il rembourser n'importe quelle facture ?

Imaginez un outil refund_invoice exposé à un assistant via MCP. Son schéma d'entrée est propre : un identifiant de facture, un motif. Le client IA sait donc construire l'appel. Mais rien, dans ce schéma, ne dit quel utilisateur a le droit de rembourser quelle facture. Ce sont deux décisions distinctes, et seule la seconde protège vos données.

Cet article détaille un pattern de conception en trois frontières pour les outils MCP en écriture, dans une application Laravel. Il s'inspire de An MCP Tool Schema Is Not an Authorization Check: A Laravel Design Pattern, publié sur dev.to.

Qui est responsable de quoi dans MCP

La spécification des outils MCP place côté serveur la validation des entrées, le contrôle d'accès, la limitation de débit et l'assainissement des sorties. Elle recommande aussi que le client demande une confirmation pour les opérations sensibles.

Cette répartition est saine, mais elle a une conséquence : la confirmation affichée dans l'interface de chat est un confort pour l'utilisateur, pas une garantie. Un client mal écrit, compromis ou simplement bogué peut sauter cette étape. Votre application doit donc se comporter comme si aucune confirmation n'avait jamais eu lieu.

Un outil MCP est facile à appeler, et c'est précisément pour cela qu'un outil capable d'écrire (rembourser, supprimer, modifier) mérite plus de rigueur qu'un outil en lecture seule.

Trois frontières, trois décisions

1. Protéger le point d'entrée

La première barrière est classique : authentifier l'appelant à la frontière HTTP et limiter le débit. Une URL difficile à deviner n'est pas une protection.

Sous Laravel, cela passe par les middlewares d'authentification et de throttling placés sur la route qui reçoit les appels d'outils. Le choix du guard dépend de votre client et de votre déploiement : jeton d'API, OAuth ou autre.

Route::post('/mcp', McpController::class)
    ->middleware(['auth:sanctum', 'throttle:mcp']);

2. Valider les arguments réellement reçus

Le schéma d'entrée annoncé par votre serveur est une aide pour le client, pas un contrat que quelqu'un vérifie à votre place. Un appelant malveillant ou défaillant peut envoyer une charge utile différente de celle que le schéma décrit.

Traitez donc les arguments comme n'importe quelle entrée externe : type, plage, longueur, contraintes métier, le tout vérifié côté serveur.

$data = Validator::make($arguments, [
    'invoice_id' => ['required', 'integer', 'exists:invoices,id'],
    'reason'     => ['required', 'string', 'max:500'],
])->validate();

Cette étape répond à la question : la requête est-elle bien formée ? Elle ne répond pas à : a-t-on le droit de l'exécuter ?

3. Autoriser l'action sur l'enregistrement précis

C'est la frontière que le schéma ne peut jamais couvrir. Une facture existe, son identifiant est valide, mais appartient-elle à un client que cet utilisateur peut gérer ? Son état permet-il un remboursement ? Le montant dépasse-t-il le plafond de ce rôle ?

Sous Laravel, les policies et les gates sont faites pour cela. On charge la ressource, puis on autorise l'action sur cette ressource, avant toute écriture.

$invoice = Invoice::findOrFail($data['invoice_id']);

$this->authorize('refund', $invoice);

$invoice->refund($data['reason']);

La policy refund porte la logique métier : appartenance au bon tenant, rôle de l'utilisateur, statut de la facture. Cette logique est la même que celle de votre interface web classique. Autant la réutiliser plutôt que d'en écrire une version parallèle pour MCP, qui finirait par diverger.

Ce que ce découpage change concrètement

Séparer la validation syntaxique de l'autorisation métier évite plusieurs erreurs courantes :

  • croire qu'un identifiant valide implique un droit d'accès ;
  • dupliquer des règles de permission dans chaque outil, avec le risque d'en oublier une ;
  • s'appuyer sur la confirmation du client comme dernier rempart.

Quelques réflexes complémentaires pour les outils en écriture :

  • appliquer l'autorisation dans la couche qui exécute l'action, pas seulement dans le contrôleur MCP, pour qu'un autre point d'entrée ne la contourne pas ;
  • journaliser qui a demandé quoi, sur quelle ressource, avec quel résultat ;
  • renvoyer des erreurs sobres, qui ne révèlent pas l'existence d'enregistrements auxquels l'appelant n'a pas accès ;
  • tester explicitement les cas de refus : un utilisateur sans droit, une ressource d'un autre tenant, un statut incompatible.

Conclusion

Un schéma d'outil MCP décrit comment appeler. Il ne dit jamais qui a le droit d'appeler, ni sur quoi. Protéger le point d'entrée, valider les arguments, puis autoriser l'action sur la ressource ciblée : ces trois décisions restent séparées, et seule la troisième empêche un assistant, ou celui qui le pilote, de toucher à ce qui ne le concerne pas.

Si vous exposez déjà des outils à un assistant IA, relisez ceux qui écrivent des données et posez-vous une question simple : où, dans le code, vérifie-t-on le droit sur cet enregistrement précis ? Si la réponse est « dans le schéma », il reste du travail.

Ce que ça change pour vous

Brancher un assistant IA sur vos outils internes ne remplace pas la gestion des droits d'accès : elle doit exister dans l'application elle-même. Une demande qui semble correcte ne prouve pas que la personne derrière a le droit de la faire. Avant de confier à un assistant des actions sensibles comme un remboursement ou une suppression, demandez à votre prestataire où ces vérifications sont faites et comment elles sont testées.

Partager cet article

Et votre site, il vaut quoi ?

Vitesse, accessibilité, référencement technique. Le rapport est écrit pour un dirigeant, pas pour un développeur. Gratuit, sans inscription.

Tester mon site