WordPress 7.0 et l’IA : Abilities API, MCP et Client SDK expliqués

Avec WordPress 7.0, la plateforme franchit un cap décisif : elle devient nativement compatible avec les agents IA. Trois composants techniques forment cette nouvelle architecture : l’Abilities API, l’adaptateur MCP et l’AI Client SDK.

Pour les développeurs et lead tech d’agences, c’est le moment d’explorer ces outils avant qu’ils ne deviennent incontournables sur tous les projets clients.

Voici un guide technique complet, avec du code PHP concret et un tutoriel pour créer votre premier serveur MCP WordPress.

L’Abilities API : Un Registre Central Pour Toutes Les Fonctionnalités

L’Abilities API représente le socle technique de cette évolution. Introduite expérimentalement dans WordPress 6.9, elle est désormais intégrée au core de la version 7.0. Son principe ? Créer un registre unifié où chaque fonctionnalité (appelée « ability ») est déclarée de manière standardisée.

Chaque ability comprend :

• Un identifiant unique (namespace/nom)
• Un label et une description lisibles
• Des schémas JSON Schema pour valider les entrées et sorties
• Un callback d’exécution
• Un callback de permission

L’Abilities API transforme WordPress en plateforme composable : chaque fonctionnalité devient découvrable, réutilisable et sécurisée par défaut.

Fini les endpoints REST custom dispersés dans vos plugins. Fini les hooks fragmentés difficiles à maintenir. L’API centralise tout et gère automatiquement la validation des données ainsi que les contrôles d’accès.

Enregistrer Votre Première Ability

Voici comment déclarer une ability pour renouveler un abonnement client :

add_action( 'wp_abilities_api_init', 'register_my_abilities' );

function register_my_abilities(): void {
    wp_register_ability(
        'my-plugin/renew-subscription',
        array(
            'label'       => __( 'Renew Subscription', 'my-plugin' ),
            'description' => __( 'Renews a subscription for a provided customer.', 'my-plugin' ),
            'input_schema' => array(
                'type' => 'object',
                'properties' => array(
                    'customer_id' => array(
                        'type' => 'integer',
                        'description' => 'The customer ID'
                    ),
                    'plan' => array(
                        'type' => 'string',
                        'enum' => array( 'monthly', 'yearly' )
                    )
                ),
                'required' => array( 'customer_id', 'plan' )
            ),
            'output_schema' => array(
                'type' => 'object',
                'properties' => array(
                    'success' => array( 'type' => 'boolean' ),
                    'subscription_id' => array( 'type' => 'integer' ),
                    'expires_at' => array( 'type' => 'string', 'format' => 'date-time' )
                )
            ),
            'execute_callback'    => 'handle_subscription_renewal',
            'permission_callback' => 'can_manage_subscriptions'
        )
    );
}

function handle_subscription_renewal( array $input ): array {
    // Logique métier ici
    $subscription = renew_customer_subscription( $input['customer_id'], $input['plan'] );
    
    return array(
        'success'         => true,
        'subscription_id' => $subscription->id,
        'expires_at'      => $subscription->expires_at
    );
}

function can_manage_subscriptions(): bool {
    return current_user_can( 'manage_woocommerce' );
}

Une fois enregistrée, récupérez et exécutez l’ability simplement :

$ability = wp_get_ability( 'my-plugin/renew-subscription' );

if ( $ability ) {
    $result = $ability->execute( array(
        'customer_id' => 42,
        'plan'        => 'yearly'
    ) );
    
    if ( $result['success'] ) {
        // Traitement du résultat
    }
}

La validation des inputs selon le JSON Schema et la vérification des permissions se font automatiquement. Si le schéma n’est pas respecté ou si l’utilisateur n’a pas les droits, l’exécution échoue proprement.

L’Adaptateur MCP : WordPress Devient Un Serveur Pour Agents IA

Le Model Context Protocol (MCP), développé par Anthropic et documenté sur modelcontextprotocol.io, définit un standard d’interopérabilité entre applications et modèles IA. L’adaptateur MCP WordPress traduit automatiquement vos abilities en « tools » MCP.

Concrètement, un agent comme Claude peut :

• Découvrir toutes les abilities exposées par votre site WordPress
• Comprendre les paramètres requis grâce aux schémas JSON
• Exécuter des actions avec les autorisations appropriées
• Enchaîner plusieurs abilities dans des workflows complexes

Point clé : Avec l’adaptateur MCP, votre site WordPress devient pilotable par des agents IA externes. Un assistant Claude peut créer des articles, gérer des commandes WooCommerce ou modifier des paramètres ! tout cela via des appels standardisés et sécurisés.

Tutoriel : Créer Votre Premier Serveur MCP WordPress

Le repo WordPress/mcp-adapter sur GitHub contient tout le nécessaire. Voici les étapes pour l’installer et l’utiliser :

Étape 1 : Installation via Composer

composer require wordpress/mcp-adapter

Étape 2 : Activer l’adaptateur

add_action( 'plugins_loaded', function() {
    if ( class_exists( 'WordPress\MCP\Adapter' ) ) {
        $adapter = new WordPressMCPAdapter();
        $adapter->init();
    }
} );

Étape 3 : Configurer l’authentification

L’adaptateur utilise les Application Passwords de WordPress pour authentifier les requêtes MCP entrantes. Créez un mot de passe d’application pour l’agent IA :

// Dans le profil utilisateur WordPress :
// Utilisateurs > [Votre utilisateur] > Application Passwords
// Nom : "Claude Agent"
// Copiez le mot de passe généré

// L'agent utilisera ces credentials dans l'en-tête Authorization :
// Authorization: Basic base64(username:application_password)

Étape 4 : Exposer des abilities spécifiques

add_filter( 'mcp_exposed_abilities', function( $abilities ) {
    // Exposer uniquement certaines abilities via MCP
    return array_filter( $abilities, function( $ability_id ) {
        $allowed = array(
            'my-plugin/renew-subscription',
            'my-plugin/get-customer-info',
            'my-plugin/create-support-ticket'
        );
        return in_array( $ability_id, $allowed, true );
    }, ARRAY_FILTER_USE_KEY );
} );

Étape 5 : Tester avec un client MCP

Utilisez l’outil CLI fourni ou configurez Claude Desktop pour se connecter à votre serveur MCP WordPress. L’endpoint par défaut est /wp-json/mcp/v1/.

Cas D’Usage Concret : WooCommerce + MCP

La documentation WooCommerce MCP détaille comment exposer des actions e-commerce. Un agent IA peut alors :

• Consulter le stock en temps réel
• Créer ou modifier des commandes
• Gérer les remboursements
• Répondre aux questions clients avec accès aux données de leur compte

Pour les agences gérant des boutiques WooCommerce, cette intégration ouvre la porte à des chatbots de support véritablement autonomes. Plus besoin de développer des intégrations custom : l’agent accède aux données via les abilities standardisées.

AI Client SDK : Le Pont Côté Client

L’AI Client SDK complète l’architecture en fournissant une interface unifiée côté PHP et JavaScript. Dans WordPress 7.0, le package JavaScript est intégré nativement à Gutenberg.

Utilisation JavaScript Dans L’Éditeur

import { executeAbility } from '@wordpress/abilities';

async function translateBlockContent( blockId, targetLanguage ) {
    const block = wp.data.select( 'core/block-editor' ).getBlock( blockId );
    
    const result = await executeAbility( 'my-plugin/translate-content', {
        text: block.attributes.content,
        source_language: 'fr',
        target_language: targetLanguage
    } );
    
    if ( result.success ) {
        wp.data.dispatch( 'core/block-editor' ).updateBlockAttributes( blockId, {
            content: result.translated_text
        } );
    }
    
    return result;
}

Ce code permet d’ajouter un bouton « Traduire » dans la barre d’outils d’un bloc. L’ability gère la connexion au provider IA (OpenAI, Anthropic, ou autre) de manière transparente.

Utilisation PHP Pour Les Tâches Backend

use WordPressAIClient;

function generate_product_description( int $product_id ): string {
    $product = wc_get_product( $product_id );
    
    $client = new Client();
    
    $result = $client->execute_ability( 'core/generate-text', array(
        'prompt'     => sprintf( 
            'Génère une description SEO de 150 mots pour : %s', 
            $product->get_name() 
        ),
        'max_tokens' => 200,
        'provider'   => 'openai' // Configurable dans les options WP
    ) );
    
    return $result['text'] ?? '';
}

L’avantage ? Votre code reste agnostique du provider IA. Si demain le client veut passer d’OpenAI à Claude, un simple changement de configuration suffit, pas besoin de réécrire le code.

Tableau De Maturité Des Fonctionnalités

Où en sont ces trois piliers dans WordPress 7.0 ? Voici un état des lieux précis :

Composant	Statut WP 7.0	Stabilité API	Prêt pour Production
Abilities API	Core natif	Stable	Oui
MCP Adapter	Plugin → intégration progressive core	Beta	Avec précautions
AI Client SDK (JS)	Package Gutenberg natif	Stable	Oui
AI Client SDK (PHP)	Package Composer	Release Candidate	Projets pilotes
Providers IA intégrés	OpenAI, Anthropic	Stable	Oui

L’Abilities API et le SDK JavaScript sont suffisamment matures pour un déploiement en production. L’adaptateur MCP, lui, convient aux projets expérimentaux ou aux intranets d’entreprise où vous contrôlez l’environnement.

Bonnes Pratiques Pour Les Agences

Votre équipe technique doit se préparer dès maintenant. Quelques recommandations issues de retours terrain :

1. Créez des abilities réutilisables

Plutôt que de coder des fonctionnalités en dur, encapsulez-les dans des abilities. Un système de gestion de leads développé pour un client devient instantanément réutilisable et potentiellement accessible aux agents IA.

2. Pensez schémas dès la conception

Les JSON Schemas ne sont pas optionnels. Un schéma bien défini garantit que les données entrantes sont valides, documente l’API automatiquement, et permet aux agents IA de comprendre comment utiliser vos abilities.

3. Granularité des permissions

N’exposez jamais une ability sans permission_callback. Créez des capabilities WordPress dédiées pour contrôler finement qui (humain ou agent) peut exécuter quoi. Si vous travaillez sur des sites e-commerce, la logique multi-agents demande une attention particulière aux droits d’accès.

4. Logs et audit trail

Chaque exécution d’ability via MCP doit être loggée. En cas de problème, vous devez pouvoir retracer quelle action a été déclenchée, par quel agent, avec quels paramètres.

Une ability bien conçue documente elle-même son usage grâce aux schémas JSON, c’est du code auto-documenté par design.

Perspectives : Vers Des Sites WordPress Autonomes

Ces trois composants posent les bases d’une transformation profonde. Imaginez un site e-commerce où un agent IA :

• Analyse les tendances de vente via abilities de reporting
• Ajuste automatiquement les prix selon la demande
• Génère des descriptions produits optimisées SEO
• Répond aux tickets support avec accès au contexte client

Ce n’est plus de la science-fiction. Les avancées récentes dans les APIs de modèles IA combinées à cette infrastructure WordPress rendent ces scénarios réalisables aujourd’hui.

Le Developer Blog WordPress (make.wordpress.org/ai) publie régulièrement des mises à jour sur l’avancement du merge core. Suivez les AI Contributor Meetings pour rester informé des évolutions.

WordPress 7.0 avec PHP 8.3 recommandé apporte aussi des améliorations de performance qui profitent à l’exécution des abilities. Le gain de vitesse sur les validations JSON Schema atteint 15-20% par rapport à PHP 8.1.

FAQ

L’Abilities API remplace-t-elle l’API REST WordPress ?

Non, elle la complète. L’API REST reste le standard pour les opérations CRUD classiques. L’Abilities API cible les actions complexes et composables, particulièrement celles destinées à être consommées par des agents IA ou des workflows automatisés.

Faut-il mettre à jour tous nos plugins pour WordPress 7.0 ?

Pas immédiatement. Les plugins existants continuent de fonctionner. L’adoption de l’Abilities API est optionnelle mais recommandée pour les nouvelles fonctionnalités, surtout si vous prévoyez des intégrations IA.

L’adaptateur MCP est-il sécurisé pour un site en production ?

Oui, à condition de configurer correctement l’authentification via Application Passwords et de limiter les abilities exposées. Évitez d’exposer des abilities sensibles (suppression de données, modifications de configuration) sans contrôles stricts.

Quel provider IA est recommandé avec l’AI Client SDK ?

OpenAI et Anthropic sont officiellement supportés. Le choix dépend de vos besoins : GPT-4 excelle en génération de texte long, Claude en analyse de documents. Le SDK permet de changer de provider sans modifier votre code applicatif.

Comment débugger une ability qui ne s’exécute pas ?

Vérifiez d’abord le permission_callback, c’est la cause la plus fréquente. Activez ensuite WP_DEBUG et consultez les logs. L’Abilities API logue les erreurs de validation de schéma dans debug.log.

Peut-on utiliser l’Abilities API sans intégration IA ?

Absolument. L’API est utile indépendamment de l’IA : elle structure votre code, facilite la réutilisation entre plugins, et documente automatiquement vos fonctionnalités. L’IA est un bonus, pas un prérequis.

Quelle est la différence entre une ability et un hook WordPress ?

Un hook est un point d’extension pour modifier un comportement existant. Une ability est une unité fonctionnelle autonome, avec entrées/sorties définies, validations automatiques et contrôle d’accès intégré. Les abilities sont découvrables et documentées par design.

L’adaptateur MCP fonctionne-t-il avec d’autres IA que Claude ?

Oui. Le protocole MCP est un standard ouvert. Tout client compatible MCP peut interagir avec votre serveur WordPress, y compris des agents custom développés avec LangChain, AutoGen ou d’autres frameworks.

Comment migrer des endpoints REST existants vers des abilities ?

Identifiez les endpoints qui encapsulent une logique métier complexe. Extrayez cette logique dans une ability, puis faites pointer l’endpoint REST vers l’exécution de l’ability. Vous conservez la rétrocompatibilité tout en bénéficiant de l’architecture abilities.

WordPress 7.0 est-il compatible avec les hébergements mutualisés classiques ?

Oui pour les fonctionnalités de base. L’adaptateur MCP nécessite PHP 8.2+ et des connexions WebSocket ou SSE selon la configuration, vérifiez avec votre hébergeur. Les hébergements WordPress managés (Kinsta, WP Engine) supportent généralement ces prérequis.