MCP : Connecter et relier WordPress à une IA (CODEX CLI)

Vous utilisez WordPress et vous avez entendu parler du protocole MCP. Sachez qu’il est possible de connecter votre site à une IA comme Codex CLI afin qu’elle puisse analyser vos contenus, rechercher des informations, proposer des optimisations SEO ou même créer des brouillons directement depuis votre blog.

Dans ce tutoriel, vous allez découvrir concrètement comment relier WordPress à une IA grâce au MCP, étape par étape. Même si vous débutez avec ce protocole, vous apprendrez à mettre en place une connexion fonctionnelle et à exploiter tout le potentiel de l’intelligence artificielle sur votre propre site web.

• Transformer votre IA en assistant capable de travailler avec les données réelles de votre site WordPress.
• Gagner du temps sur l’analyse de contenu et la recherche d’opportunités SEO pour votre blog.
• Comprendre comment faire dialoguer WordPress et une intelligence artificielle de façon sécurisée grâce au protocole MCP.

Comment relier votre site WordPress à Codex CLI

Lorsque l’on découvre le protocole MCP (Model Context Protocol), une question revient presque immédiatement :

« Concrètement, qu’est-ce que cela peut m’apporter pour mon site WordPress ? »

• C’est précisément ce que nous allons voir dans ce tutoriel.

À la fin de ce cours, vous saurez comment connecter un site WordPress à une intelligence artificielle grâce au protocole MCP afin que l’IA puisse consulter vos articles, analyser votre contenu, créer des brouillons, effectuer des audits SEO ou encore vous assister dans l’administration de votre site.

Si vous savez déjà utiliser WordPress, vous possédez la plus grande partie des compétences nécessaires. Alors ouvrez votre terminal et découvrons ensemble comment faire dialoguer WordPress et une IA.

Comprendre ce que nous allons construire

Avant d’installer quoi que ce soit, il est important de comprendre le principe général. Imaginons que votre IA soit un stagiaire extrêmement intelligent. Ce stagiaire peut rédiger du contenu, analyser votre SEO ou corriger du code.

Le problème est qu’il ne connaît absolument rien de votre site.

Il ne peut pas :

• voir vos articles ;
• consulter vos pages ;
• lire vos catégories ;
• accéder à vos statistiques ;
• modifier vos contenus.

Pour lui donner accès à ces informations, il faut créer un pont de communication.

• C’est exactement le rôle du protocole MCP.

Le schéma simplifié ressemble à ceci :

L’IA ne parle pas directement à WordPress. Elle dialogue avec un serveur MCP qui lui fournit des outils sécurisés pour interagir avec votre site.

👉 Tout comprendre au protocole MCP.

Ce dont vous aurez besoin

Pour suivre ce tutoriel, vous devez disposer :

• d’un site WordPress
• d’un ordinateur Windows, Linux ou macOS
• de Node.js installé
• de Codex CLI installé
• d’un accès administrateur à WordPress

Si vous avez déjà suivi le tutoriel précédent sur l’installation d’un serveur MCP, vous possédez déjà la majorité des prérequis.

Pourquoi utiliser MCP avec WordPress ?

Avant de passer à la pratique, voyons quelques cas d’utilisation réels.

Une fois la connexion établie, vous pourrez demander à l’IA :

Analyse les 50 derniers articles de mon blog et trouve les sujets qui manquent.

ou encore :

Vérifie si mes balises H1 sont cohérentes.

ou même :

Crée un brouillon de 1500 mots sur le sujet du maillage interne.

L’IA pourra alors récupérer les informations directement depuis WordPress au lieu de travailler à l’aveugle. C’est toute la différence.

Étape 1 : créer le projet MCP

Nous allons créer un dossier dédié à notre serveur MCP WordPress.

Dans votre terminal, tapez :

mkdir wordpress-mcp
cd wordpress-mcp

Ce dossier contiendra tout le code de notre passerelle.

Initialisez ensuite un projet Node.js :

npm init -y

Cette commande crée un fichier package.json. C’est lui qui décrit votre projet JavaScript, ses dépendances et son mode de fonctionnement.

Pour utiliser les imports modernes avec import, ajoutez la ligne suivante dans package.json :

"type": "module"

Si votre fichier contient déjà plusieurs propriétés, cela peut donner quelque chose comme ceci :

{
  "name": "wordpress-mcp",
  "version": "1.0.0",
  "type": "module",
  "description": "",
  "main": "index.js",
  "scripts": {
    "start": "node server.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "commonjs"
}

Le point important ici est "type": "module". Sans cette ligne, Node.js risque de ne pas comprendre les imports que nous allons utiliser.

Étape 2 : installer les dépendances

Nous avons besoin de trois éléments.

1. Le SDK MCP, qui permet de créer un vrai serveur compatible avec Codex CLI.
2. axios, qui sert à interroger facilement l’API REST de WordPress.  
3. zod, qui permet de décrire proprement les paramètres attendus par nos outils MCP.

Installez-les avec :

npm install @modelcontextprotocol/sdk axios zod

À ce stade, votre projet contient tout ce qu’il faut pour créer un serveur MCP local.

Attention : Un simple script qui interroge WordPress avec Axios n’est pas un serveur MCP. Pour que Codex CLI puisse dialoguer avec lui, le programme doit rester actif et répondre au protocole MCP via le transport stdio.

Dit autrement, afficher du JSON dans le terminal, ce n’est pas suffisant. Codex attend une vraie poignée de main, appelée handshake. Si le script se ferme immédiatement, Codex affichera une erreur du type :

MCP startup failed: handshaking with MCP server failed

C’est normal : il attend un serveur, pas un script jetable.

Étape 3 : créer le fichier server.js

Créez maintenant un fichier nommé :

server.js

Dans ce fichier, nous allons construire notre serveur MCP.

Voici une première version complète :

import axios from "axios";
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

// Remplacez cette URL par celle de votre propre site.
const WORDPRESS_URL = "https://votresite.fr";

// Création du serveur MCP.
// C'est lui que Codex CLI va lancer et interroger.
const server = new McpServer({
  name: "wordpress-mcp",
  version: "1.0.0"
});

// Premier outil MCP : récupérer les derniers articles WordPress.
server.registerTool(
  "liste_articles_wordpress",
  {
    title: "Lister les articles WordPress",
    description: "Récupère les derniers articles publiés sur le site WordPress.",
    inputSchema: z.object({
      nombre: z
        .number()
        .min(1)
        .max(20)
        .default(5)
        .describe("Nombre d'articles à récupérer, entre 1 et 20.")
    })
  },
  async ({ nombre }) => {
    const response = await axios.get(`${WORDPRESS_URL}/wp-json/wp/v2/posts`, {
      params: {
        per_page: nombre,
        _fields: "id,date,link,title,excerpt"
      }
    });

    const articles = response.data.map((post) => ({
      id: post.id,
      date: post.date,
      titre: post.title.rendered,
      lien: post.link,
      extrait: post.excerpt.rendered.replace(/<[^>]*>/g, "")
    }));

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(articles, null, 2)
        }
      ]
    };
  }
);

// Transport stdio.
// Codex CLI communique avec le serveur par l'entrée/sortie standard.
const transport = new StdioServerTransport();

// Connexion du serveur MCP au transport.
await server.connect(transport);

Ce code est plus qu’un simple appel Axios. Il crée réellement un serveur MCP compatible avec Codex CLI.

Comprendre le code simplement

Prenons quelques instants pour décortiquer ce fichier.

La ligne suivante importe Axios :

import axios from "axios";

Axios sert à envoyer des requêtes HTTP. Dans notre cas, il va demander à WordPress :

Peux-tu me donner les derniers articles ?

Ensuite, nous importons zod :

import { z } from "zod";

Zod permet de décrire ce que l’outil accepte comme paramètre. Par exemple, notre outil accepte un nombre d’articles à récupérer. Ce nombre doit être compris entre 1 et 20.

Puis nous importons les deux éléments essentiels du MCP :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

• McpServer permet de créer le serveur.
• StdioServerTransport permet à Codex CLI de communiquer avec lui depuis le terminal.

Ensuite, cette partie crée le serveur :

const server = new McpServer({
  name: "wordpress-mcp",
  version: "1.0.0"
});

Vous pouvez voir cela comme la carte d’identité de votre serveur MCP.

Enfin, cette partie déclare un outil :

server.registerTool(...)

Un outil MCP est une action que l’IA peut utiliser. Ici, l’action consiste à récupérer les derniers articles WordPress.

Étape 4 : tester le serveur sans Codex

Avant de connecter Codex CLI, il est utile de vérifier que le serveur ne plante pas.

Lancez :

node server.js

Si tout va bien, il ne doit rien afficher et ne doit pas revenir immédiatement au prompt.

• C’est normal.

Votre serveur attend qu’un client MCP lui parle. Comme aucun client n’est connecté ici, il reste simplement ouvert.

Pour l’arrêter, utilisez : Ctrl + C

Si vous voyez une erreur, lisez-la tranquillement. Les erreurs les plus fréquentes sont une dépendance manquante, une faute dans l’import ou une URL WordPress incorrecte.

Étape 5 : déclarer le serveur MCP dans Codex CLI

Maintenant que le serveur existe, il faut l’ajouter dans Codex CLI.

Depuis le dossier wordpress-mcp, tapez dans votre terminal :

codex mcp add wordpress -- node server.js

Cette commande signifie :

Codex, ajoute un serveur MCP nommé wordpress. Pour le lancer, utilise la commande node server.js.

Vérifiez ensuite que le serveur est bien enregistré :

codex mcp list

Vous devriez voir apparaître :

Pour afficher les détails :

codex mcp get wordpress

Vous devriez obtenir quelque chose de proche de ceci :

C’est bon signe. Codex sait maintenant comment lancer votre serveur MCP WordPress.

Étape 6 : lancer Codex CLI

Vous pouvez maintenant démarrer Codex depuis le dossier /wordpress-mcp :

codex

Dans Codex, posez une question simple :

Peux-tu utiliser l'outil WordPress pour lister les 5 derniers articles du site ?

Codex va vous demander l’autorisation d’utiliser le serveur MCP :

Après acceptation, Codex va détecter l’outil MCP disponible, l’appeler, récupérer les données WordPress, puis vous répondre.

À ce stade, vous venez de connecter WordPress à une IA grâce au MCP : le serveur est actif et Codex peut dialoguer avec lui.

Étape 7 : ajouter un outil pour lire un article précis

Lister des articles, c’est pratique. Mais lire un article complet, c’est encore plus intéressant.

Ajoutons un deuxième outil dans server.js, juste avant la partie :

const transport = new StdioServerTransport();

Ajoutez ce code :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

server.registerTool(
  "lire_article_wordpress",
  {
    title: "Lire un article WordPress",
    description: "Récupère le contenu complet d'un article WordPress à partir de son identifiant.",
    inputSchema: z.object({
      id: z
        .number()
        .describe("Identifiant WordPress de l'article à lire.")
    })
  },
  async ({ id }) => {
    const response = await axios.get(`${WORDPRESS_URL}/wp-json/wp/v2/posts/${id}`, {
      params: {
        _fields: "id,date,link,title,content"
      }
    });

    const post = response.data;

    const article = {
      id: post.id,
      date: post.date,
      titre: post.title.rendered,
      lien: post.link,
      contenu: post.content.rendered.replace(/<[^>]*>/g, "")
    };

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(article, null, 2)
        }
      ]
    };
  }
);

Ce nouvel outil permet à Codex de demander le contenu d’un article précis.

Par exemple, vous pourrez écrire dans codex :

Lis l’article WordPress numéro 123 et propose 5 améliorations SEO.

L’IA ne devine plus le contenu. Elle le récupère depuis votre site, puis travaille dessus.

Étape 8 : créer un mini-outil d’audit SEO

Nous allons maintenant ajouter un troisième outil plus pédagogique : un mini-audit SEO.

L’idée ici n’est pas de remplacer un outil professionnel. L’objectif est de montrer comment MCP peut donner à l’IA une capacité d’analyse concrète.

Ajoutez ce bloc dans server.js :

server.registerTool(
  "audit_seo_articles",
  {
    title: "Audit SEO simple des articles WordPress",
    description: "Analyse rapidement les derniers articles WordPress pour repérer les contenus potentiellement trop courts.",
    inputSchema: z.object({
      nombre: z
        .number()
        .min(1)
        .max(20)
        .default(5)
        .describe("Nombre d'articles à analyser.")
    })
  },
  async ({ nombre }) => {
    const response = await axios.get(`${WORDPRESS_URL}/wp-json/wp/v2/posts`, {
      params: {
        per_page: nombre,
        _fields: "id,link,title,content"
      }
    });

    const audit = response.data.map((post) => {
      const contenuTexte = post.content.rendered.replace(/<[^>]*>/g, "");
      const nombreCaracteres = contenuTexte.length;

      let remarque = "Contenu correct à analyser plus en détail.";

      if (nombreCaracteres < 1500) {
        remarque = "Article probablement trop court : il mériterait peut-être d'être enrichi.";
      }

      return {
        id: post.id,
        titre: post.title.rendered,
        lien: post.link,
        longueur: `${nombreCaracteres} caractères`,
        remarque
      };
    });

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(audit, null, 2)
        }
      ]
    };
  }
);

Ce code récupère les derniers articles, supprime les balises HTML, calcule la longueur du contenu et ajoute une remarque simple.

• C’est volontairement basique.

Lorsqu’on débute, c’est parfait : on comprend immédiatement le principe.

Vous pouvez ensuite demander à Codex :

Utilise l’audit SEO WordPress et indique-moi quels articles semblent trop courts.

Codex appellera l’outil MCP et interprétera les résultats.

Le fichier server.js complet

Voici une version complète du fichier server.js.

Remplacez simplement https://votresite.fr par l’adresse de votre site WordPress.

import axios from "axios";
import { z } from "zod";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const WORDPRESS_URL = "https://votresite.fr";

const server = new McpServer({
  name: "wordpress-mcp",
  version: "1.0.0"
});

server.registerTool(
  "liste_articles_wordpress",
  {
    title: "Lister les articles WordPress",
    description: "Récupère les derniers articles publiés sur le site WordPress.",
    inputSchema: z.object({
      nombre: z.number().min(1).max(20).default(5)
    })
  },
  async ({ nombre }) => {
    const response = await axios.get(`${WORDPRESS_URL}/wp-json/wp/v2/posts`, {
      params: {
        per_page: nombre,
        _fields: "id,date,link,title,excerpt"
      }
    });

    const articles = response.data.map((post) => ({
      id: post.id,
      date: post.date,
      titre: post.title.rendered,
      lien: post.link,
      extrait: post.excerpt.rendered.replace(/<[^>]*>/g, "")
    }));

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(articles, null, 2)
        }
      ]
    };
  }
);

server.registerTool(
  "lire_article_wordpress",
  {
    title: "Lire un article WordPress",
    description: "Récupère le contenu complet d'un article WordPress à partir de son identifiant.",
    inputSchema: z.object({
      id: z.number()
    })
  },
  async ({ id }) => {
    const response = await axios.get(`${WORDPRESS_URL}/wp-json/wp/v2/posts/${id}`, {
      params: {
        _fields: "id,date,link,title,content"
      }
    });

    const post = response.data;

    const article = {
      id: post.id,
      date: post.date,
      titre: post.title.rendered,
      lien: post.link,
      contenu: post.content.rendered.replace(/<[^>]*>/g, "")
    };

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(article, null, 2)
        }
      ]
    };
  }
);

server.registerTool(
  "audit_seo_articles",
  {
    title: "Audit SEO simple des articles WordPress",
    description: "Analyse rapidement les derniers articles WordPress pour repérer les contenus potentiellement trop courts.",
    inputSchema: z.object({
      nombre: z.number().min(1).max(20).default(5)
    })
  },
  async ({ nombre }) => {
    const response = await axios.get(`${WORDPRESS_URL}/wp-json/wp/v2/posts`, {
      params: {
        per_page: nombre,
        _fields: "id,link,title,content"
      }
    });

    const audit = response.data.map((post) => {
      const contenuTexte = post.content.rendered.replace(/<[^>]*>/g, "");
      const nombreCaracteres = contenuTexte.length;

      let remarque = "Contenu correct à analyser plus en détail.";

      if (nombreCaracteres < 1500) {
        remarque = "Article probablement trop court : il mériterait peut-être d'être enrichi.";
      }

      return {
        id: post.id,
        titre: post.title.rendered,
        lien: post.link,
        longueur: `${nombreCaracteres} caractères`,
        remarque
      };
    });

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(audit, null, 2)
        }
      ]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Ce fichier expose trois outils MCP à Codex CLI :

• liste_articles_wordpress
• lire_article_wordpress
• audit_seo_articles

Vous disposez maintenant d’une base propre pour faire communiquer WordPress et une IA.

Que faire si Codex affiche une erreur de handshake ?

L’erreur de handshake est l’un des problèmes les plus fréquents avec MCP.

Elle ressemble souvent à ceci :

MCP startup failed: handshaking with MCP server failed

Dans la majorité des cas, cela signifie que le programme lancé par Codex n’est pas un vrai serveur MCP ou qu’il s’arrête trop tôt.

Voici les points à vérifier.

Assurez-vous d’abord que votre fichier se termine bien par :

const transport = new StdioServerTransport();
await server.connect(transport);

• Sans ces lignes, Codex ne peut pas dialoguer avec votre serveur.

Vérifiez ensuite que votre script ne contient pas de console.log() inutile.

Avec un transport stdio, il faut éviter d’écrire n’importe quoi dans la sortie standard, car Codex utilise justement cette sortie pour communiquer avec le serveur MCP. Si vous voulez afficher des messages de débogage, utilisez plutôt :

console.error("Message de debug");

La sortie d’erreur est séparée de la communication MCP, ce qui évite de casser le protocole.

Enfin, vérifiez que Codex lance bien la bonne commande :

codex mcp get wordpress

Vous devez voir quelque chose comme :

command: node
args: server.js

Supprimer un serveur MCP

Si le chemin n’est pas bon, supprimez l’ancien serveur :

codex mcp remove wordpress

Puis ajoutez-le à nouveau depuis le bon dossier :

codex mcp add wordpress -- node server.js

Sécuriser la connexion WordPress et IA

Pour le moment, notre serveur MCP lit uniquement des articles publics. C’est relativement peu risqué, car nous utilisons des informations déjà accessibles depuis l’API REST publique de WordPress.

Mais dès que vous voulez créer des brouillons, modifier des articles ou accéder à des données privées, la prudence devient indispensable.

La règle la plus importante est simple : ne donnez jamais votre mot de passe WordPress principal à un outil externe.

WordPress propose des mots de passe d’application. Ils permettent de créer un accès dédié pour une application précise, sans exposer votre vrai mot de passe administrateur.

Dans WordPress, vous pouvez généralement les trouver dans : Comptes > Profil > Mots de passe d’application

Vous pouvez créer un mot de passe nommé par exemple : Codex MCP

WordPress vous donnera alors une clé spécifique.

Si vous ajoutez plus tard un outil capable de créer un brouillon, vous pourrez utiliser cette clé dans votre serveur MCP.

Gardez toutefois une bonne habitude : pour commencer, créez uniquement des brouillons. Ne laissez pas une IA publier automatiquement sur votre site sans validation humaine.

L’IA peut être brillante, mais elle peut aussi se tromper avec beaucoup d’assurance. Un peu comme quelqu’un qui donne une direction dans une ville qu’il ne connaît pas. Il vaut mieux vérifier avant de suivre.

Créer des brouillons WordPress avec MCP

La création de brouillons est une suite logique et intéressante, mais elle demande une authentification.

Voici un exemple volontairement simplifié. Il sert à vous montrer le principe, mais vous devrez remplacer les valeurs par les vôtres.

Ajoutez d’abord ces constantes dans votre fichier server.js :

const WORDPRESS_USER = "votre_identifiant";
const WORDPRESS_APP_PASSWORD = "votre_mot_de_passe_application";

Remplacez les valeurs pas celle que Wordpress vous a transmis lors de la création du mot de passe d’application.

Ensuite, vous pourriez créer un outil comme ceci :

server.registerTool(
  "creer_brouillon_wordpress",
  {
    title: "Créer un brouillon WordPress",
    description: "Crée un brouillon d'article dans WordPress sans le publier.",
    inputSchema: z.object({
      titre: z.string(),
      contenu: z.string()
    })
  },
  async ({ titre, contenu }) => {
    const response = await axios.post(
      `${WORDPRESS_URL}/wp-json/wp/v2/posts`,
      {
        title: titre,
        content: contenu,
        status: "draft"
      },
      {
        auth: {
          username: WORDPRESS_USER,
          password: WORDPRESS_APP_PASSWORD
        }
      }
    );

    return {
      content: [
        {
          type: "text",
          text: `Brouillon créé avec succès : ${response.data.link}`
        }
      ]
    };
  }
);

Ce code ne publie pas directement l’article.

• Il crée un brouillon.

C’est beaucoup plus raisonnable. Vous gardez la main sur la relecture, la mise en page, les images, les liens internes et la publication finale.

Où stocker les identifiants proprement ?

Dans un vrai projet, il vaut mieux éviter d’écrire les identifiants directement dans server.js.

Une meilleure pratique consiste à utiliser des variables d’environnement.

Installez le paquet dotenv :

npm install dotenv

Créez un fichier nommé :

.env

Ajoutez vos informations :

WORDPRESS_URL=https://votresite.fr
WORDPRESS_USER=votre_identifiant
WORDPRESS_APP_PASSWORD=votre_mot_de_passe_application

Puis, au début du fichier server.js, ajoutez :

import "dotenv/config";

const WORDPRESS_URL = process.env.WORDPRESS_URL;
const WORDPRESS_USER = process.env.WORDPRESS_USER;
const WORDPRESS_APP_PASSWORD = process.env.WORDPRESS_APP_PASSWORD;

Ainsi, vos informations sensibles sont séparées du code.

Si vous utilisez Git, ajoutez aussi un fichier .gitignore :

.env
node_modules

Cela évite d’envoyer accidentellement vos identifiants sur GitHub. Et croyez-moi, découvrir un mot de passe publié dans un dépôt public n’est jamais un grand moment de bonheur.

👉 TruffleHog : Scan dépôt GitHub pour trouver des informations sensibles.

Idées d’utilisations concrètes pour un blog WordPress

Une fois votre serveur MCP en place, vous pouvez l’adapter à vos besoins.

Pour un blog WordPress, les possibilités deviennent très intéressantes et nombreuses.

Vous pouvez créer un outil qui liste les articles d’une catégorie précise, puis demander à Codex de proposer des idées de maillage interne. Vous pouvez aussi récupérer les articles les plus récents et demander une analyse de cohérence éditoriale.

👉 Découvrez ILP, notre Extension WordPress gratuite pour votre maillage interne.

Pour un siteou un blog, ce type de connexion peut servir à construire des clusters de contenu. L’IA peut consulter les titres existants, repérer les sujets proches, proposer des articles complémentaires ou détecter des angles encore non traités.

Vous pouvez également imaginer un outil qui récupère les articles sans image mise en avant, les contenus très courts ou les publications anciennes à mettre à jour.

MCP ne fait pas le travail magique tout seul. Il donne simplement à l’IA les bons outils pour travailler sur vos vraies données. Et c’est déjà énorme.

Les limites de cette approche

Cette méthode est puissante, mais elle a des limites.

D’abord, l’API REST de WordPress ne renvoie pas toujours exactement les données dont vous avez besoin. Certains champs peuvent dépendre du thème, des extensions ou des réglages du site.

Ensuite, les contenus récupérés contiennent souvent du HTML. Dans nos exemples, nous avons supprimé les balises avec une méthode simple :

replace(/<[^>]*>/g, "")

Cela suffit pour un tutoriel débutant, mais ce n’est pas parfait. Sur un projet plus avancé, vous pourriez utiliser une librairie dédiée pour nettoyer le HTML plus proprement.

Enfin, il faut garder en tête que l’IA reste un assistant. Elle peut analyser, proposer, organiser et accélérer votre travail. Mais la décision finale doit rester humaine, surtout lorsqu’il s’agit de contenu publié sur votre site.

---

---

Relier WordPress à une intelligence artificielle grâce au protocole MCP ouvre des perspectives particulièrement intéressantes pour les créateurs de contenu, les blogueurs et les développeurs web.

L’idée n’est pas de remplacer votre travail, mais de donner à l’IA une connaissance réelle de votre site afin qu’elle puisse vous assister de manière beaucoup plus pertinente. Une IA qui connaît vos articles, votre structure de contenu et vos objectifs SEO devient rapidement un collaborateur étonnamment efficace.

Le plus intéressant est que vous pouvez commencer très simplement. Une simple lecture des articles via l’API REST suffit déjà à créer des analyses de contenu, des audits SEO ou des suggestions éditoriales. Ensuite, au fil de vos expérimentations, vous pourrez ajouter de nouveaux outils MCP et construire un véritable écosystème autour de votre site WordPress.

Le protocole MCP n’en est encore qu’à ses débuts, mais il pourrait bien devenir l’une des briques fondamentales des futurs assistants IA connectés aux applications du quotidien. Et lorsque l’on possède un site WordPress, c’est probablement le moment idéal pour commencer à explorer ce nouveau terrain de jeu.