MCP Server per WordPress: come ho connesso Claude al mio blog

Se sei un blogger o un creator digitale, probabilmente passi un bel po' di tempo a gestire i contenuti del tuo sito: cercare articoli già pubblicati, controllare cosa manca, pianificare nuove uscite. E se potessi farlo semplicemente parlando con un assistente AI?

Grazie al Model Context Protocol (MCP), oggi è possibile e in questo articolo ti racconto come ho costruito un MCP server per connettere Claude direttamente al mio blog WordPress.

Cos'è il Model Context Protocol (MCP)?

Il Model Context Protocol è uno standard aperto sviluppato da Anthropic che consente ai modelli di linguaggio (LLM) come Claude di interagire con strumenti e sorgenti dati esterne in modo strutturato e sicuro.

In parole semplici: MCP è il “linguaggio” che permette a un'AI di parlare con le tue applicazioni. Invece di limitarsi a generare testo, un modello dotato di MCP può fare cose reali: leggere database, cercare documenti, creare contenuti, interrogare API.

L'architettura è composta da tre elementi principali:

• MCP Host: l'applicazione AI (nel mio caso, Claude su Cowork)
• MCP Client: il componente nativo di Claude che gestisce la comunicazione tra host e server
• MCP Server: il servizio che espone gli strumenti a Claude (nel mio caso, lo script Python che interroga le REST API del mio blog WordPress)

Perché ho creato un MCP server per il mio blog

Gestisco pensando.it da ormai quasi 20 anni e nel tempo ho accumulato decine e decine di articoli su tecnologia, AI, digital marketing e molto altro. Il problema? Ogni volta che volevo capire cosa avevo già scritto su un argomento, o quando cercavo un post specifico da aggiornare, dovevo navigare manualmente nel backend di WordPress.

Con un MCP server dedicato, posso fare tutto questo direttamente da Claude: basta descrivere cosa cerco e l'AI interroga il mio blog in tempo reale e mi risponde.

L'architettura del server

Il server MCP che ho realizzato si interfaccia con le API REST di WordPress, che sono native in ogni installazione WordPress dalla versione 4.7 in poi, e le espone come tool fruibili da Claude.

L'implementazione segue il pattern standard di un MCP server: definisce un insieme di strumenti con nome, descrizione e schema dei parametri, e gestisce le chiamate in ingresso restituendo i risultati nel formato atteso dal client.

La comunicazione avviene localmente tramite stdio (standard input/output), il che significa che il server gira sulla stessa macchina dove uso Claude, senza esporre nulla all'esterno, un aspetto importante dal punto di vista della sicurezza.

 

I tool disponibili

Il server espone tre strumenti principali, pensati apposta per le esigenze quotidiane di un blogger:

1. get_recent_posts: Gli ultimi articoli pubblicati

Restituisce gli ultimi N articoli del blog, con titolo, data, estratto e link. Utile per avere sempre sotto controllo i contenuti più recenti senza aprire WordPress.

2. search_posts: Cerca nel blog per parola chiave

Esegue una ricerca full-text nel blog e restituisce gli articoli corrispondenti. Puoi chiedere a Claude “ho scritto qualcosa su DeepSeek?” e lui interroga direttamente il tuo sito.

3. create_draft:Crea una nuova bozza

Permette a Claude di creare una bozza di articolo direttamente nel backend WordPress, con titolo e contenuto. L'articolo viene salvato come bozza, non pubblicato, così puoi revisionarlo prima di renderlo live.

Questo stesso articolo che stai leggendo, per esempio, è stato creato proprio così!

Come creare l'mcp server

Cominciamo con il vedere qualis ono i prerequisiti per poter creare l'mcp server

Prerequisiti

Come prima cosa prima di iniziare, assicurati di avere:

• Python 3.10+ installato sulla tua macchina
• Claude Desktop installato (versione con supporto MCP)
• Un sito WordPress con REST API abilitata (attiva per default da WP 4.7)
• Accesso all'area admin del sito WordPress

Step 1: Crea la struttura del progetto

Inizia creando una cartella dedicata e configurando il virtual environment Python. Isolare le dipendenze è una buona pratica che evita conflitti con altri progetti:

mkdir wordpress-mcp
cd wordpress-mcp
python3 -m venv .venv
source .venv/bin/activate        # macOS / Linux
# .venv\Scripts\activate         # Windows

Installa le tre dipendenze necessarie:

pip install mcp httpx python-dotenv

Ecco a cosa servono:

• mcp: il framework Model Context Protocol di Anthropic con il suo server FastMCP
• httpx: client HTTP moderno per chiamare le REST API di WordPress
• python-dotenv: per caricare le credenziali da un file .env senza hardcodarle nel codice

Step 2: Genera una Application Password su WordPress

Il server si autenticherà con WordPress tramite le Application Password, un meccanismo sicuro che ti permette di revocare l'accesso in qualsiasi momento senza cambiare la password principale dell'account.

Per generarla:

1. Accedi all'area admin di WordPress
2. Vai in Utenti → Il tuo profilo
3. Scorri fino alla sezione Application Passwords
4. Inserisci un nome descrittivo (ad esempio Claude Desktop)
5. Clicca Aggiungi nuova Application Password
6. Copia subito la password generata (verrà mostrata solo una volta)

La password ha questo formato: xxxx xxxx xxxx xxxx xxxx xxxx gli spazi sono normali e fanno parte della password.

Step 3: Crea il file .env con le credenziali

Nella cartella del progetto crea un file chiamato .env:

WP_URL=https://tuosito.com
WP_USER=tuo_utente_wordpress
WP_APP_PASSWORD=xxxx xxxx xxxx xxxx xxxx xxxx

Importante per la sicurezza: aggiungi subito .env al tuo .gitignore per non pubblicare mai le credenziali su GitHub o altri repository pubblici.

Step 4: Scrivi il server MCP

Crea il file principale wordpress_mcp_server.py.

Partiamo dall'header e dalla configurazione iniziale:

import os
import httpx
from pathlib import Path
from dotenv import load_dotenv
from mcp.server.fastmcp import FastMCP

# Carica le variabili d'ambiente dal file .env
# Path assoluto relativo allo script: funziona anche se Claude Desktop
# lancia il processo da una cartella diversa
load_dotenv(dotenv_path=Path(__file__).parent / ".env")

WP_URL      = os.getenv("WP_URL", "").rstrip("/")
WP_USER     = os.getenv("WP_USER", "")
WP_APP_PASS = os.getenv("WP_APP_PASSWORD", "")

# Crea l'istanza del server MCP
mcp = FastMCP("WordPress Assistant")

Nota il dettaglio di Path(__file__).parent / ".env": usando il path assoluto relativo allo script (anziché alla working directory), il file .env viene trovato correttamente anche quando Claude Desktop lancia il processo da una cartella diversa da quella del progetto.

Tool 1: Leggi gli ultimi articoli

@mcp.tool()
def get_recent_posts(count: int = 5) -> str:
    """
    Restituisce gli ultimi articoli pubblicati sul blog WordPress.
    Usare quando l'utente chiede: ultimi post, articoli recenti,
    cosa ho pubblicato di recente, ultimi contenuti del blog.

    Args:
        count: numero di articoli da restituire (default 5, max 20)
    """
    count = min(count, 20)  # limite di sicurezza

    url = f"{WP_URL}/wp-json/wp/v2/posts"
    params = {
        "per_page": count,
        "orderby":  "date",
        "order":    "desc",
        "_fields":  "id,title,date,link,status"
    }

    try:
        response = httpx.get(url, params=params, auth=(WP_USER, WP_APP_PASS), timeout=10)
        response.raise_for_status()
        posts = response.json()

        if not posts:
            return "Nessun articolo trovato sul blog."

        lines = [f"Trovati {len(posts)} articoli recenti:\n"]
        for post in posts:
            title  = post["title"]["rendered"]
            date   = post["date"][:10]
            link   = post["link"]
            status = post["status"]
            lines.append(f"• [{date}] {title}\n  Stato: {status}\n  Link: {link}\n")

        return "\n".join(lines)

    except httpx.HTTPStatusError as e:
        return f"Errore HTTP {e.response.status_code}: {e.response.text}"
    except Exception as e:
        return f"Errore durante la chiamata a WordPress: {str(e)}"

La docstring è il cuore di ogni tool MCP: è ciò che Claude legge per decidere quando chiamare questo strumento. Includere frasi d'esempio (“ultimi post”, “cosa ho pubblicato di recente”) aiuta notevolmente il modello a fare il match corretto con la richiesta dell'utente.

Tool 2: Cerca articoli per parola chiave

@mcp.tool()
def search_posts(keyword: str, count: int = 5) -> str:
    """
    Cerca articoli nel blog WordPress che contengono una parola chiave.
    Usare quando l'utente chiede: cerca articoli su X, trova post che
    parlano di Y, ho scritto qualcosa su Z?.

    Args:
        keyword: parola o frase da cercare nel titolo e nel contenuto
        count:   numero massimo di risultati (default 5)
    """
    import re

    url = f"{WP_URL}/wp-json/wp/v2/posts"
    params = {
        "search":   keyword,
        "per_page": min(count, 10),
        "_fields":  "id,title,date,link,excerpt"
    }

    try:
        response = httpx.get(url, params=params, auth=(WP_USER, WP_APP_PASS), timeout=10)
        response.raise_for_status()
        posts = response.json()

        if not posts:
            return f"Nessun articolo trovato con la parola chiave '{keyword}'."

        lines = [f"Trovati {len(posts)} articoli per '{keyword}':\n"]
        for post in posts:
            title         = post["title"]["rendered"]
            date          = post["date"][:10]
            link          = post["link"]
            excerpt       = post.get("excerpt", {}).get("rendered", "")
            excerpt_clean = re.sub(r"<[^>]+>", "", excerpt).strip()[:120]
            lines.append(f"• [{date}] {title}\n  {excerpt_clean}...\n  Link: {link}\n")

        return "\n".join(lines)

    except httpx.HTTPStatusError as e:
        return f"Errore HTTP {e.response.status_code}: {e.response.text}"
    except Exception as e:
        return f"Errore durante la ricerca: {str(e)}"

Tool 3: Crea una bozza

@mcp.tool()
def create_draft(title: str, content: str) -> str:
    """
    Crea una nuova bozza di articolo su WordPress.
    Usare quando l'utente chiede: crea un articolo su X, scrivi una bozza
    su Y, aggiungi un nuovo post al blog con questo titolo e contenuto.

    L'articolo viene salvato come bozza (non pubblicato),
    l'utente può revisionarlo nel pannello WordPress prima di pubblicarlo.

    Args:
        title:   titolo dell'articolo
        content: corpo dell'articolo (può contenere HTML base)
    """
    url     = f"{WP_URL}/wp-json/wp/v2/posts"
    payload = {
        "title":   title,
        "content": content,
        "status":  "draft"   # mai pubblicare direttamente!
    }

    try:
        response = httpx.post(url, json=payload, auth=(WP_USER, WP_APP_PASS), timeout=10)
        response.raise_for_status()
        post = response.json()

        post_id   = post["id"]
        post_link = post["link"]
        edit_link = f"{WP_URL}/wp-admin/post.php?post={post_id}&action=edit"

        return (
            f"Bozza creata con successo!\n"
            f"  Titolo:    {title}\n"
            f"  ID post:   {post_id}\n"
            f"  Anteprima: {post_link}\n"
            f"  Modifica:  {edit_link}"
        )

    except httpx.HTTPStatusError as e:
        return f"Errore HTTP {e.response.status_code}: {e.response.text}"
    except Exception as e:
        return f"Errore durante la creazione della bozza: {str(e)}"

Entry point del server

Conclude il file con il blocco di avvio:

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

Il metodo mcp.run() avvia il server in modalità stdio: il processo resta in ascolto e scambia messaggi JSON-RPC con Claude Desktop tramite stdin/stdout.

Step 5: Collega il server a Claude Desktop

Questa è la fase che “accende” tutto, devi aggiungere il tuo server al file di configurazione di Claude Desktop.

Apri il file di configurazione:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Aggiungi la sezione mcpServers (o integra quella esistente):

{
  "mcpServers": {
    "wordpress": {
      "command": "/percorso/assoluto/al/progetto/.venv/bin/python",
      "args": ["/percorso/assoluto/al/progetto/wordpress_mcp_server.py"]
    }
  }
}

Per trovare il percorso corretto esegui nel terminale, con il venv attivo:

which python   # ti dà il percorso dell'interprete Python nel venv
pwd            # ti dà il percorso della cartella del progetto

Usa sempre il percorso assoluto all'interprete Python dentro il virtual environment: in questo modo tutte le dipendenze sono disponibili senza dover attivare manualmente il venv ogni volta.

Dopo aver salvato il file, riavvia completamente Claude Desktop (chiudi e riapri l'applicazione, non basta minimizzare).

I server MCP vengono caricati solo all'avvio e puoi trovarli in Claude Desktop dal menu : Personalizza > Connettori > wordpress (SVILUPPO IN LOCALE)

Ricordati di abilitare i tre endpoint in modalità “Consenti Sempre” oppure “Richiede Approvazione”

Step 6: Verifica e test

Una volta riavviato Claude Desktop, in basso a sinistra della finestra comparirà l'icona MCP. Cliccaci: nella lista deve apparire wordpress con stato running.

Ora apri una nuova chat e prova questi prompt naturali:

Mostrami gli ultimi 5 articoli del mio blog

Cerca articoli che parlano di intelligenza artificiale

Crea una bozza con titolo "Test MCP" e scrivi un breve paragrafo introduttivo sull'argomento

Claude analizzerà il testo, sceglierà il tool corretto in base alla docstring e chiamerà la REST API di WordPress. Se tutto funziona, vedrai i risultati direttamente in chat e, per il create_draft, troverai la bozza nel pannello admin del tuo sito.

Troubleshooting rapido

Se qualcosa non va, controlla i log di Claude Desktop:

• macOS: ~/Library/Logs/Claude/mcp-server-wordpress.log

Gli errori più comuni: command not found indica un percorso Python errato (verifica con which python nel venv attivo); 401 Unauthorized segnala credenziali sbagliate (controlla il file .env e rigenera la Application Password da WordPress); un JSON non valido nel file di configurazione impedisce il caricamento del server (verifica su jsonlint.com).

Un esempio pratico: la sessione di oggi

Per darti un'idea concreta di come funziona nella pratica, ecco una mini-demo basata su una sessione reale di questa mattina.

Ho aperto Claude su Cowork e ho scritto:

“Cerca articoli che parlano di AI nel mio blog”

Claude ha invocato il tool search_posts con keyword “AI” e in pochi secondi mi ha restituito 10 articoli, ordinati per data, con titolo e link diretto. Zero clic su WordPress, zero navigazione nel backend.

Poi ho detto:

“Crea una bozza di articolo che descriva l'MCP server che ho realizzato”

Claude mi ha fatto alcune domande (target, contenuti da includere, titolo) e poi ha invocato create_draft creando l'articolo che stai leggendo.

Cosa puoi fare con questo approccio

Le possibilità non si fermano ai tre tool che ho implementato. Un MCP server per WordPress può essere esteso per supportare molti altri scenari:

• Analizzare i contenuti esistenti e suggerire aggiornamenti SEO
• Identificare gap editoriali (“non ho mai scritto di X”)
• Generare calendari editoriali basati sugli articoli già presenti
• Collegare Claude anche ad altri sistemi (analytics, newsletter, social)

Il video completo su YouTube

Accedi al mio canale YouTube e guarda il video

Conclusioni

Con meno di 200 righe di Python abbiamo creato un ponte diretto tra Claude Desktop e WordPress. Il punto di forza di MCP è proprio questo: la semplicità del contratto un decoratore @mcp.tool(), una docstring ben scritta e un valore di ritorno stringa nasconde tutta la complessità del protocollo sottostante.

Da qui in avanti le possibilità di espansione sono numerose: gestione di categorie e tag, upload di immagini tramite l'endpoint /wp-json/wp/v2/media, modifica di articoli esistenti, o integrazione con altri strumenti MCP nello stesso file di configurazione.

Se vuoi avere il codice completo contattami per una consulenza dedicata!

Integrare un MCP server con WordPress è un modo concreto per portare l'AI dentro il tuo flusso di lavoro editoriale, non solo a fianco. Non si tratta di far scrivere tutto all'AI (la voce rimane la tua), ma di usarla come un assistente davvero connesso al tuo contesto, che conosce il tuo blog, i tuoi articoli, la tua storia editoriale.

Se vuoi essere aggiornato iscriviti alla newsletter oppure seguimi sul mio canale YouTube!

Hai domande o vuoi sapere come replicarlo per il tuo sito? Scrivimi nei commenti.