Model Context Protocol: come usarlo per automatizzare WordPress con l’AI

Se stai cercando un modo per connettere un modello AI come Claude o GPT direttamente al tuo sito WordPress, senza dover costruire integrazioni custom da zero ogni volta, il Model Context Protocol (MCP) è esattamente quello che ti serve.

MCP è uno standard aperto sviluppato da Anthropic che definisce come un modello AI può interagire con strumenti esterni: file system, database, API, CMS. In pratica, crea un “canale standardizzato” tra il modello e qualsiasi sistema esterno tu voglia collegare. Il risultato è un agente AI capace di leggere contenuti, creare bozze, aggiornare post e gestire media direttamente su WordPress, tutto via linguaggio naturale.

In questo tutorial vediamo come costruire un MCP server custom in Python che espone le API REST di WordPress come strumenti per Claude Desktop, e come usarlo per automatizzare il workflow editoriale.

Architettura MCP applicata a WordPress

Prima di scrivere una riga di codice, è utile capire come funziona MCP dal punto di vista architetturale.

Lo stack è composto da tre elementi:

• MCP Host: il client AI che esegue il modello (Claude Desktop nel nostro caso)
• MCP Server: un processo locale che espone “tool” (funzioni invocabili) e “resource” (dati leggibili)
• Sistema target: in questo caso WordPress, raggiunto tramite la sua REST API

La comunicazione tra Host e Server avviene tramite JSON-RPC 2.0 su stdio (standard input/output) o HTTP con Server-Sent Events. Claude Desktop lancia il server come processo figlio e comunica con lui via stdio: nessuna porta aperta, nessun servizio da deployare, tutto gira in locale.

Il flusso è il seguente: tu scrivi a Claude “crea una bozza sull’argomento X”, Claude decide di chiamare il tool create_post, il MCP server traduce la chiamata in una request HTTP verso la REST API di WordPress, ottiene la risposta e la restituisce a Claude che ti conferma l’operazione.

Prerequisiti

Per seguire questo tutorial ti servono:

• Python 3.11 o superiore
• Claude Desktop installato (disponibile su claude.ai)
• Un sito WordPress accessibile via HTTPS con la REST API abilitata (default)
• Le credenziali WordPress: username e una Application Password (si genera da Utenti > Profilo > Password dell’applicazione)

Installa le dipendenze Python necessarie:

pip install fastmcp httpx python-dotenv

FastMCP è il framework ufficiale Python per costruire MCP server in modo rapido. httpx gestisce le chiamate HTTP asincrone verso WordPress.

Costruire il MCP server per WordPress

Crea un file wordpress_mcp.py nella tua directory di lavoro. Ecco il codice completo del server con i tool principali:

import os
import httpx
from dotenv import load_dotenv
from fastmcp import FastMCP

load_dotenv()

WP_BASE_URL = os.getenv("WP_BASE_URL")  # es: https://tuosito.it/wp-json/wp/v2
WP_USER     = os.getenv("WP_USER")
WP_APP_PASS = os.getenv("WP_APP_PASS")

AUTH = (WP_USER, WP_APP_PASS)

mcp = FastMCP("wordpress-assistant")


@mcp.tool()
async def get_recent_posts(count: int = 5) -> list[dict]:
    """Recupera gli ultimi articoli pubblicati su WordPress."""
    async with httpx.AsyncClient() as client:
        r = await client.get(
            f"{WP_BASE_URL}/posts",
            params={"per_page": count, "status": "publish", "_fields": "id,title,link,date,status"},
            auth=AUTH
        )
        r.raise_for_status()
        return r.json()


@mcp.tool()
async def create_draft(title: str, content: str, categories: list[int] = None) -> dict:
    """Crea una nuova bozza di articolo su WordPress."""
    payload = {"title": title, "content": content, "status": "draft"}
    if categories:
        payload["categories"] = categories
    async with httpx.AsyncClient() as client:
        r = await client.post(
            f"{WP_BASE_URL}/posts",
            json=payload,
            auth=AUTH
        )
        r.raise_for_status()
        post = r.json()
        return {"id": post["id"], "title": post["title"]["rendered"], "link": post["link"]}


@mcp.tool()
async def update_post(post_id: int, title: str = None, content: str = None, status: str = None) -> dict:
    """Aggiorna titolo, contenuto o stato di un post esistente."""
    payload = {}
    if title:   payload["title"]   = title
    if content: payload["content"] = content
    if status:  payload["status"]  = status
    async with httpx.AsyncClient() as client:
        r = await client.post(
            f"{WP_BASE_URL}/posts/{post_id}",
            json=payload,
            auth=AUTH
        )
        r.raise_for_status()
        return {"id": post_id, "status": r.json().get("status")}


@mcp.tool()
async def search_posts(query: str, per_page: int = 5) -> list[dict]:
    """Cerca articoli su WordPress per keyword."""
    async with httpx.AsyncClient() as client:
        r = await client.get(
            f"{WP_BASE_URL}/posts",
            params={"search": query, "per_page": per_page, "_fields": "id,title,link,date"},
            auth=AUTH
        )
        r.raise_for_status()
        return r.json()


@mcp.tool()
async def get_categories() -> list[dict]:
    """Restituisce le categorie disponibili nel blog WordPress."""
    async with httpx.AsyncClient() as client:
        r = await client.get(
            f"{WP_BASE_URL}/categories",
            params={"per_page": 50, "_fields": "id,name,slug"},
            auth=AUTH
        )
        r.raise_for_status()
        return r.json()


if __name__ == "__main__":
    mcp.run()

Crea un file .env nella stessa directory con le tue credenziali:

WP_BASE_URL=https://tuosito.it/wp-json/wp/v2
WP_USER=il_tuo_username
WP_APP_PASS=xxxx xxxx xxxx xxxx xxxx xxxx

Nota: la Application Password di WordPress viene generata nel formato con spazi. Puoi usarla così com’è oppure rimuovere gli spazi: httpx gestisce l’autenticazione Basic correttamente in entrambi i casi.

Configurare Claude Desktop per usare il server

Claude Desktop carica i MCP server da un file di configurazione JSON. Su macOS il percorso è:

~/Library/Application Support/Claude/claude_desktop_config.json

Su Windows:

%APPDATA%\Claude\claude_desktop_config.json

Apri il file (crealo se non esiste) e aggiungi la configurazione del server:

{
  "mcpServers": {
    "wordpress": {
      "command": "python",
      "args": ["/percorso/assoluto/wordpress_mcp.py"],
      "env": {
        "WP_BASE_URL": "https://tuosito.it/wp-json/wp/v2",
        "WP_USER": "il_tuo_username",
        "WP_APP_PASS": "xxxx xxxx xxxx xxxx xxxx xxxx"
      }
    }
  }
}

In alternativa, se usi il file .env, puoi omettere la sezione env nel JSON e gestire tutto da lì. Riavvia Claude Desktop dopo aver salvato il file: vedrai comparire l’icona a forma di martello nella barra degli strumenti della chat, che indica i tool MCP disponibili.

Verifica che tutto funzioni

Prima di affidarti a Claude, testa il server in autonomia dalla riga di comando con il client di test integrato in FastMCP:

fastmcp dev wordpress_mcp.py

Questo avvia il MCP Inspector, un’interfaccia web locale che ti permette di invocare i tool manualmente, vedere le request/response JSON e fare debug senza passare per Claude Desktop. È lo strumento più utile nella fase di sviluppo.

Use case pratici con Claude

Una volta configurato il server, puoi interagire con WordPress direttamente dalla chat di Claude Desktop usando linguaggio naturale. Ecco alcuni esempi concreti:

Creare una bozza da un brief

Scrivi a Claude:

“Crea una bozza di articolo intitolata ‘Come usare i vector database per applicazioni RAG’ con un’introduzione tecnica di circa 400 parole, rivolta a sviluppatori backend.”

Claude scriverà il contenuto e chiamerà automaticamente il tool create_draft per pubblicare la bozza su WordPress. Riceverai l’ID e il link diretto all’articolo nel pannello di amministrazione.

Analizzare i contenuti esistenti

“Recupera gli ultimi 10 articoli del blog e dimmi quali trattano argomenti di AI generativa. Per ciascuno, suggerisci un articolo correlato che potrebbe aumentare il traffico organico.”

Claude invoca get_recent_posts, legge i titoli, e costruisce una strategia editoriale basata sui contenuti reali del tuo sito.

Aggiornare un post esistente

“Cerca gli articoli che parlano di ChatGPT e aggiorna quello con ID 142 aggiungendo una sezione finale che confronta le capacità con Claude 3.5.”

Claude usa search_posts per trovare il contesto, poi update_post per modificare il contenuto direttamente.

Workflow editoriale completo

Il caso d’uso più potente è costruire un workflow in una singola conversazione: Claude recupera le categorie disponibili, scrive l’articolo rispettando le linee guida editoriali che gli fornisci, assegna la categoria corretta e crea la bozza pronta per la revisione. Il tutto in 30 secondi.

Considerazioni di sicurezza

Alcune best practice prima di mettere in produzione questa configurazione:

• Usa sempre le Application Password di WordPress, mai le credenziali del profilo principale
• Crea un utente WordPress dedicato con ruolo Editor (non Administrator) specifico per le automazioni MCP
• Tieni il file .env fuori dal version control: aggiungi .env al .gitignore
• Se il tuo WordPress è accessibile pubblicamente, assicurati che la REST API richieda autenticazione per le operazioni di scrittura (comportamento default)

Estendere il server: idee per tool aggiuntivi

La struttura del server è facilmente estendibile. Ecco alcuni tool che puoi aggiungere con poche righe di codice:

• upload_media: carica immagini dalla macchina locale e le associa al post
• get_comments: recupera e analizza i commenti per moderazione automatica
• update_seo_fields: se usi Yoast o RankMath, entrambi espongono endpoint REST per modificare meta title e description
• schedule_post: imposta la data di pubblicazione di una bozza

Ogni tool è semplicemente una funzione Python decorata con @mcp.tool(): il docstring diventa la descrizione che il modello AI legge per capire quando e come usarlo. Scrivi descrizioni chiare e contestualizzate, sono fondamentali per la qualità delle chiamate automatiche.

Conclusioni

Il Model Context Protocol trasforma qualsiasi sistema dotato di API in uno strumento nativo per l’AI. Con meno di 100 righe di Python puoi dare a Claude la capacità di gestire l’intero ciclo di vita dei contenuti su WordPress: dalla ricerca, alla creazione, alla pubblicazione.

La vera potenza non è nel singolo tool, ma nella composizione: Claude può combinare più strumenti in sequenza per portare a termine task complessi che prima richiedevano ore di lavoro manuale. E con la standardizzazione MCP, lo stesso server può essere riutilizzato con qualsiasi client AI compatibile, oggi Claude Desktop, domani un agente autonomo in produzione.

Se vuoi approfondire come integrare questi workflow nella tua infrastruttura o costruire agenti AI custom per la tua azienda, sono disponibile per una consulenza.