MCP avec Laravel : connectez vos outils PHP aux agents IA en quelques lignes

Le Model Context Protocol (MCP) s'impose progressivement comme le standard de facto pour permettre aux LLM (Large Language Models) de communiquer avec des outils externes. Si l'écosystème JavaScript a été le premier à s'en emparer, le monde PHP n'est pas en reste. Un article récent de Nasrul Hazim Bin Mohamad sur DEV.to démontre comment implémenter un toolbox MCP générique avec Laravel, où les outils se déclarent d'eux-mêmes automatiquement.

Dans cet article, nous reprenons les grandes lignes de cette approche, l'analysons du point de vue d'un développeur PHP/Symfony, et explorons pourquoi ce type de pattern est structurant pour vos prochains projets orientés IA.

Qu'est-ce que le Model Context Protocol ?

MCP est un protocole open source initié par Anthropic pour standardiser la façon dont les agents IA interagissent avec des sources de données et des outils externes. Concrètement, il définit un contrat d'échange entre un LLM (comme Claude) et un serveur d'outils : le modèle peut lister les outils disponibles, les appeler avec des paramètres typés, et recevoir une réponse structurée.

L'intérêt est double :

• Côté LLM : il n'a plus besoin d'être entraîné spécifiquement sur vos APIs. Il découvre dynamiquement ce qu'il peut faire.
• Côté développeur : vous exposez vos fonctionnalités métier via un contrat standard, réutilisable par n'importe quel agent compatible MCP.

Pensez-y comme à une API REST, mais conçue pour être consommée par une intelligence artificielle plutôt que par un frontend.

Le pattern "auto-enregistrement" dans Laravel

L'approche présentée dans l'article source repose sur un mécanisme élégant : chaque outil MCP se déclare lui-même auprès d'un registre central, sans configuration manuelle. C'est le principe d'auto-découverte, bien connu dans l'écosystème Symfony avec les tags de services, appliqué ici au contexte MCP.

Voici le schéma général du pattern :

// Contrat commun à tous les outils MCP
interface McpTool
{
    public function name(): string;
    public function description(): string;
    public function inputSchema(): array;
    public function execute(array $input): mixed;
}

Chaque outil implémente cette interface et s'enregistre automatiquement via un Service Provider Laravel qui scanne les classes disponibles :

class McpToolboxServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->app->singleton(McpToolRegistry::class, function () {
            $registry = new McpToolRegistry();

            // Découverte automatique des outils
            foreach (config('mcp.tools') as $toolClass) {
                $registry->register(app($toolClass));
            }

            return $registry;
        });
    }
}

Le registre expose ensuite un endpoint HTTP qui liste les outils disponibles et délègue l'exécution selon le nom de l'outil demandé par le LLM.

// Réponse à une requête "tools/list" du protocole MCP
public function list(): array
{
    return array_map(fn(McpTool $tool) => [
        'name'        => $tool->name(),
        'description' => $tool->description(),
        'inputSchema' => $tool->inputSchema(),
    ], $this->tools);
}

L'avantage de cette architecture : ajouter un nouvel outil ne nécessite aucune modification du code existant. Il suffit de créer une classe, d'implémenter l'interface, et de la déclarer dans la configuration.

Ce que ça change pour vos projets PHP

Cette approche illustre un changement de paradigme important. Jusqu'ici, exposer une fonctionnalité métier à une IA passait souvent par du prompt engineering artisanal ou des intégrations ad hoc. Avec MCP, vous structurez votre code comme une librairie d'outils réutilisables, indépendante du modèle qui les consomme.

Quelques cas d'usage concrets pour une application PHP/Symfony :

• Outil de recherche : exposer une recherche Elasticsearch ou une requête Doctrine en tant qu'outil MCP, permettant à Claude de formuler des recherches en langage naturel.
• Outil de génération de rapport : un agent peut appeler votre service de génération PDF existant sans réécriture.
• Outil de validation métier : vos règles de validation complexes deviennent interrogeables par un LLM pour guider un utilisateur.

Dans un contexte Symfony, le pattern s'adapte naturellement avec l'injection de dépendances et les tags de services :

# services.yaml
_instanceof:
    App\Mcp\McpTool:
        tags: ['app.mcp_tool']

// Dans votre registre Symfony
public function __construct(
    #[TaggedIterator('app.mcp_tool')] iterable $tools
) {
    foreach ($tools as $tool) {
        $this->register($tool);
    }
}

Le résultat est identique : un registre dynamique, sans couplage fort entre les outils et le serveur MCP.

Points de vigilance avant de vous lancer

L'approche est séduisante, mais quelques points méritent attention avant d'exposer vos outils en production :

Sécurité et authentification : un serveur MCP expose des capacités potentiellement sensibles. Assurez-vous de mettre en place une authentification robuste (token, OAuth) avant tout déploiement. Le protocole ne définit pas de couche de sécurité native.

Validation des entrées : le inputSchema doit être strict. Un LLM peut générer des paramètres inattendus ; votre couche de validation doit être aussi rigoureuse que pour une API publique.

Idempotence et effets de bord : les agents IA peuvent appeler un outil plusieurs fois. Concevez vos outils comme des opérations idempotentes lorsque c'est possible, et documentez clairement les effets de bord dans la description de l'outil.

Observabilité : loggez chaque appel d'outil avec ses paramètres et sa durée. Déboguer un agent IA sans traces est particulièrement difficile.

Conclusion

L'article de Nasrul Hazim Bin Mohamad (à lire sur DEV.to) montre que PHP et Laravel sont parfaitement capables d'embrasser les standards de l'écosystème IA moderne. Le pattern de toolbox générique avec auto-enregistrement est une base solide pour construire des intégrations MCP maintenables.

Pour les équipes Symfony, la transposition est directe grâce au système de tags de services. L'essentiel est de traiter vos outils MCP comme des composants de première classe : bien définis, bien testés, et bien documentés — exactement comme vous le feriez pour n'importe quel service métier.

Le standard MCP est encore jeune, mais la direction est claire : les LLM vont de plus en plus interagir avec des systèmes existants via ce type de protocoles. Autant poser les bonnes fondations dès maintenant.