Optimiser vos sites WordPress et PHP/Symfony pour les LLMs : Guide complet MCP, WebMCP et GEO

L’intelligence artificielle générative et les LLMs (Large Language Models) ne se contentent plus de répondre à des questions : ils deviennent des agents capables d’agir sur le web. Des assistants comme ChatGPT avec navigation, Perplexity ou les futurs navigateurs intégrant des IA peuvent désormais interagir directement avec vos sites : remplir des formulaires, passer des commandes, consulter des données.

Pour tirer parti de cette révolution, deux technologies clés émergent :

• MCP (Model Context Protocol) pour exposer vos données et actions en backend.
• WebMCP pour guider les agents dans l’interface utilisateur de votre site en temps réel.

Dans cet article, nous vous montrons comment implémenter ces protocoles sur WordPress, PHP natif et Symfony, tout en adoptant une stratégie GEO (Generative Engine Optimization) pour améliorer votre visibilité dans les moteurs de recherche basés sur l’IA.

1. Comprendre MCP et WebMCP : le duo gagnant

📌 À retenir : MCP = centre d’appels (toujours joignable). WebMCP = expert en magasin (présent uniquement quand l’utilisateur visite votre site).

Les deux protocoles sont complémentaires. Un site bien optimisé doit proposer les deux pour offrir une expérience fluide aux agents IA.

2. Pourquoi optimiser son site pour les LLMs ? L’enjeu du GEO

Le GEO (Generative Engine Optimization) désigne l’ensemble des techniques visant à optimiser un site pour qu’il soit correctement interprété et cité par les moteurs de réponse générative (Google SGE, Bing Chat, Perplexity, etc.).

Contrairement au SEO traditionnel (basé sur des mots-clés et des liens), le GEO mise sur :

• La structuration sémantique (balisage, schémas, fichiers d’aide à l’IA).
• L’exposition explicite des fonctionnalités via des protocoles comme MCP.
• La clarté des intentions (intents) pour que l’agent puisse agir sans ambiguïté.

En intégrant MCP et WebMCP, vous rendez votre site “machine-readable” et “machine-actionable”, ce qui augmente vos chances d’être utilisé directement par les assistants IA, donc plus de trafic et de conversions.

3. Implémenter MCP sur WordPress

WordPress bénéficie d’une solution officielle grâce à l’adaptateur MCP développé par l’équipe principale. Il repose sur la nouvelle Abilities API (introduite dans WP 6.9).

3.1. Installation du plugin MCP Adapter

1. Téléchargez le plugin depuis le dépôt GitHub : wordpress-mcp-adapter
2. Installez-le et activez-le dans votre admin WordPress.
3. Rendez-vous dans Outils → MCP pour vérifier que le serveur est bien détecté.

3.2. Configuration du client IA (exemple avec Claude Desktop)

Pour connecter Claude à votre site WordPress, vous devez configurer un serveur MCP. Deux modes sont possibles :

• En local (développement) : via WP-CLI (transport STDIO).
• En production : via un proxy Node.js (transport HTTP).

Configuration pour développement local (STDIO)

Dans le fichier de configuration de Claude Desktop (claude_desktop_config.json) :

json

{
  "mcpServers": {
    "wordpress": {
      "command": "wp",
      "args": ["mcp", "serve"],
      "env": {
        "WP_CLI_CONFIG_PATH": "/chemin/vers/wp-cli.yml"
      }
    }
  }
}

Assurez-vous que WP-CLI est installé et que la commande wp mcp serve est disponible (elle est ajoutée par le plugin).

Configuration pour site en ligne (HTTP)

Utilisez le package @wordpress/mcp-remote-proxy pour créer un pont sécurisé :

bash

npm install -g @wordpress/mcp-remote-proxy
mcp-remote-proxy --site https://monsite.com --key "votre_clé_api"

Le proxy expose un endpoint HTTP que votre client IA pourra interroger.

3.3. Exposer des capacités personnalisées

L’Abilities API vous permet d’enregistrer vos propres actions. Exemple : une capacité pour récupérer les produits WooCommerce.

Dans functions.php de votre thème (ou dans un plugin) :

php

add_action('init', function() {
    // Enregistrement d'une capacité "get_products"
    wp_register_ability('get_products', [
        'title'       => __('Récupérer les produits', 'txtdomain'),
        'description' => __('Liste les produits avec leurs prix et stocks.', 'txtdomain'),
        'callback'    => 'my_get_products_callback',
        'input_schema' => [
            'type'       => 'object',
            'properties' => [
                'limit' => [
                    'type'        => 'integer',
                    'description' => 'Nombre maximum de produits à retourner',
                    'default'     => 10,
                ],
            ],
        ],
        'output_schema' => [
            'type' => 'array',
            'items' => [
                'type'       => 'object',
                'properties' => [
                    'id'    => ['type' => 'integer'],
                    'name'  => ['type' => 'string'],
                    'price' => ['type' => 'string'],
                ],
            ],
        ],
        'meta' => [
            'mcp' => ['public' => true] // 🔥 Rend la capacité accessible via MCP
        ],
    ]);
});

function my_get_products_callback($args) {
    $products = wc_get_products(['limit' => $args['limit']]);
    return array_map(function($product) {
        return [
            'id'    => $product->get_id(),
            'name'  => $product->get_name(),
            'price' => $product->get_price(),
        ];
    }, $products);
}

Désormais, un agent IA pourra appeler l’outil get_products directement depuis WordPress.

4. Implémenter MCP sur un site PHP / Symfony

Si vous développez une application maison avec PHP ou Symfony, vous pouvez créer votre propre serveur MCP en implémentant le protocole.

4.1. Principes de base du protocole MCP

MCP utilise JSON-RPC 2.0 sur différents transports (stdio, HTTP, WebSocket). Un serveur MCP expose :

• Une méthode tools/list pour lister les outils disponibles.
• Une méthode tools/call pour exécuter un outil spécifique.

4.2. Implémentation minimale en PHP natif (stdio)

Créez un script mcp_server.php :

php

#!/usr/bin/env php
<?php
// Lit l'entrée standard
while ($line = fgets(STDIN)) {
    $request = json_decode($line, true);
    if (!$request) continue;

    $method = $request['method'] ?? '';
    $id = $request['id'] ?? null;

    if ($method === 'tools/list') {
        $response = [
            'jsonrpc' => '2.0',
            'id'      => $id,
            'result'  => [
                'tools' => [
                    [
                        'name'        => 'get_users',
                        'description' => 'Récupère la liste des utilisateurs',
                        'inputSchema' => [
                            'type'       => 'object',
                            'properties' => [
                                'role' => ['type' => 'string'],
                            ],
                        ],
                    ],
                    [
                        'name'        => 'send_email',
                        'description' => 'Envoie un email',
                        'inputSchema' => [
                            'type'       => 'object',
                            'properties' => [
                                'to'      => ['type' => 'string'],
                                'subject' => ['type' => 'string'],
                                'body'    => ['type' => 'string'],
                            ],
                            'required' => ['to', 'subject', 'body'],
                        ],
                    ],
                ],
            ],
        ];
    } elseif ($method === 'tools/call') {
        $params = $request['params'];
        $tool = $params['name'];
        $args = $params['arguments'];

        // Exécution de l'outil
        switch ($tool) {
            case 'get_users':
                $result = my_get_users($args['role'] ?? null);
                break;
            case 'send_email':
                $result = my_send_email($args['to'], $args['subject'], $args['body']);
                break;
            default:
                $response = [
                    'jsonrpc' => '2.0',
                    'id'      => $id,
                    'error'   => ['code' => -32601, 'message' => 'Tool not found'],
                ];
                fwrite(STDERR, json_encode($response) . "\n");
                continue 2;
        }

        $response = [
            'jsonrpc' => '2.0',
            'id'      => $id,
            'result'  => $result,
        ];
    } else {
        $response = [
            'jsonrpc' => '2.0',
            'id'      => $id,
            'error'   => ['code' => -32601, 'message' => 'Method not found'],
        ];
    }

    fwrite(STDOUT, json_encode($response) . "\n");
}

Rendez le script exécutable et configurez votre client IA pour lancer php mcp_server.php.

4.3. Implémentation avec Symfony (service HTTP)

Pour une API REST exposée via HTTP, utilisez un contrôleur Symfony.

php

// src/Controller/McpController.php
namespace App\Controller;

use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Annotation\Route;

class McpController
{
    #[Route('/mcp', name: 'mcp_endpoint', methods: ['POST'])]
    public function handle(Request $request): JsonResponse
    {
        $payload = json_decode($request->getContent(), true);
        $method = $payload['method'] ?? '';
        $id = $payload['id'] ?? null;

        if ($method === 'tools/list') {
            return $this->json([
                'jsonrpc' => '2.0',
                'id' => $id,
                'result' => [
                    'tools' => [
                        [
                            'name' => 'symfony_cache_clear',
                            'description' => 'Vider le cache Symfony',
                            'inputSchema' => ['type' => 'object', 'properties' => []],
                        ],
                        // autres outils
                    ],
                ],
            ]);
        }

        if ($method === 'tools/call') {
            $tool = $payload['params']['name'];
            $args = $payload['params']['arguments'];
            // Logique d'appel...
            return $this->json([
                'jsonrpc' => '2.0',
                'id' => $id,
                'result' => ['status' => 'ok'],
            ]);
        }

        return $this->json([
            'jsonrpc' => '2.0',
            'id' => $id,
            'error' => ['code' => -32601, 'message' => 'Method not found'],
        ], 400);
    }
}

N’oubliez pas de protéger cet endpoint (par exemple avec une clé API) pour éviter les abus.

5. Préparer son site pour WebMCP (frontend)

WebMCP est une proposition de standard pour navigateur. Même si son adoption n’est pas encore massive, vous pouvez dès maintenant préparer votre site.

5.1. Rendre l’interface compréhensible par les agents

Les agents IA naviguent en analysant le DOM. Pour les aider, utilisez des attributs de données stables et des microformats.

Exemple pour un formulaire de contact :

html

<form data-webmcp-form="contact" id="contact-form">
    <input type="text" name="name" data-webmcp-field="name" placeholder="Votre nom" />
    <input type="email" name="email" data-webmcp-field="email" placeholder="Email" />
    <textarea name="message" data-webmcp-field="message"></textarea>
    <button type="submit" data-webmcp-action="submit">Envoyer</button>
</form>

Ces attributs data-webmcp-* n’affectent pas l’apparence, mais fournissent des points d’ancrage sémantiques pour les agents.

5.2. Ajouter un manifeste WebMCP

Dans l’en-tête de vos pages, incluez un bloc JSON décrivant les intentions de la page.

html

<script type="application/json" id="webmcp-manifest">
{
  "spec": "webmcp/0.1",
  "intents": [
    {
      "id": "search_products",
      "description": "Rechercher un produit",
      "inputs": [
        { "name": "query", "type": "string", "required": true }
      ],
      "ui": {
        "selectors": {
          "form": "#searchform",
          "query": "input[name='s']",
          "submit": "button[type='submit']"
        }
      }
    }
  ]
}
</script>

5.3. Utiliser l’API JavaScript (pour les sites dynamiques)

Quand le standard WebMCP sera implémenté dans les navigateurs, vous pourrez enregistrer des outils directement via JavaScript.

javascript

if ("modelContext" in navigator) {
  navigator.modelContext.provideContext({
    tools: [{
      name: "addToCart",
      description: "Ajouter un produit au panier",
      inputSchema: {
        type: "object",
        properties: {
          productId: { type: "integer" },
          quantity: { type: "integer", default: 1 }
        },
        required: ["productId"]
      },
      execute: ({ productId, quantity }) => {
        // Appel à votre fonction panier existante
        return window.myAddToCart(productId, quantity);
      }
    }]
  });
}

Cette approche est idéale pour les sites avec beaucoup d’interactions JavaScript, comme ceux construits avec React ou Vue.js.

6. Le fichier llms.txt : un standard pour guider les IA

Proposé par des acteurs comme Answer.AI, le fichier llms.txt (placé à la racine du site) permet de fournir des instructions directes aux LLMs qui scraperaient votre site.

Exemple de llms.txt pour un site WordPress :

text

# Bienvenue sur Blue Web

## À propos
Blue Web est une agence spécialisée dans la création de sites performants (WordPress, Symfony).

## Documentation MCP
- Serveur MCP : /mcp (endpoint JSON-RPC)
- Documentation : /docs/mcp

## WebMCP
- Manifeste principal : /webmcp/manifest.json

## Sitemaps
- Sitemap XML : /sitemap.xml

## Informations supplémentaires
Notre site utilise des cookies... (etc.)

Certains moteurs de recherche génératifs (comme You.com) commencent à utiliser ce fichier pour enrichir leur compréhension des sites.

7. Cas d’usage concrets

FAQ

Q : MCP et WebMCP sont-ils concurrents ?
R : Non, ils sont complémentaires. MCP est orienté backend, WebMCP est orienté frontend.

Q : Puis-je utiliser WebMCP sans MCP ?
R : Oui, si vous souhaitez seulement guider les agents sur votre interface. Mais pour des actions persistantes ou en arrière-plan, MCP est indispensable.

Q : Quels navigateurs supportent WebMCP ?
R : Actuellement en aperçu anticipé dans Chrome. Firefox et Safari travaillent sur des implémentations similaires (mais pas encore standardisées).

Q : Le GEO remplace-t-il le SEO ?
R : Non, le GEO vient en complément. Un bon SEO reste nécessaire pour le classement traditionnel. Le GEO améliore l’exploitation de votre contenu par les IA.

Q : Comment tester mon implémentation MCP ?
R : Utilisez des clients comme Claude Desktop, Continue.dev, ou l’outil en ligne de commande mcp-cli.

Q : Existe-t-il un risque de sécurité avec MCP ?
R : Oui, si vous exposez des actions sensibles. Authentifiez toujours vos endpoints MCP et limitez les outils selon les droits des utilisateurs.

Conclusion

L’essor des agents IA transforme la manière dont les utilisateurs interagissent avec le web. En adoptant MCP et WebMCP, vous offrez à ces agents une interface claire et efficace pour exploiter vos services. Que vous soyez sur WordPress, PHP natif ou Symfony, les solutions existent et sont à votre portée.

N’attendez pas que la vague passe : préparez vos sites dès maintenant pour l’ère du GEO et des LLMs. Commencez par intégrer un manifeste WebMCP, ajoutez des attributs sémantiques, et exposez vos premières capacités MCP.

Prêt à passer à l’action ? Contactez Blue Web pour un audit de votre site et une mise en conformité avec les nouveaux standards de l’IA.

Article rédigé par l’équipe technique de Blue Web – Mars 2026