KI in WordPress einbauen: Plugin oder API

Sie betreiben eine WordPress- oder TYPO3-Seite und möchten eine KI-Funktion einbauen: einen Text zusammenfassen, Entwürfe vorschlagen, Fragen beantworten. Dann stehen Sie vor einer Weichenstellung. Nehmen Sie ein fertiges Plugin oder eine Extension, oder binden Sie die Schnittstelle eines KI-Anbieters selbst an?

Der Artikel ordnet die Wege ein und zeigt für beide Systeme, wie eine eigene Anbindung im Kern aussieht. Die Code-Beispiele nutzen nur die in der WordPress- und TYPO3-Dokumentation beschriebenen Schnittstellen. Sie sind gekürzt und gehören nicht ungeprüft in eine produktive Seite.

Drei Wege, KI in ein CMS zu holen

1. Fertiges Plugin oder fertige Extension. Ein WordPress-Plugin erweitert WordPress um Funktionen, eine TYPO3-Extension tut dasselbe für TYPO3. Wer die gewünschte KI-Funktion schon als Erweiterung findet, spart Entwicklungszeit. Dafür richten Sie sich nach dem, was die Erweiterung kann, und hängen von ihrer Pflege ab. Konkrete Produkte nenne ich hier nicht, weil sich der Markt schnell ändert. Prüfen Sie bei jedem Kandidaten, wie aktuell er ist, welche Anbieter er anspricht und wohin Ihre Daten fließen.

2. Eigene Anbindung. Ihr Server ruft die Schnittstelle (API) eines KI-Anbieters selbst auf. Das lohnt sich, wenn die Funktion zu Ihrem Ablauf passen soll, etwa weil sie auf Ihre Inhalte oder Ihre Rollen im Redaktionssystem zugreift. Dieser Weg steht im Mittelpunkt des Artikels.

3. KI-Agent oder MCP-Server. Soll die KI selbst Aktionen im System auslösen, reicht ein einfacher Textaufruf nicht. Diesen Fall behandle ich auf der Seite KI-Agenten und MCP-Server.

Meine Einschätzung: Für eine einzelne, gängige Funktion lohnt der Blick auf ein fertiges Plugin. Sobald Rollen, eigene Inhaltstypen oder ein festgelegter Standort der Verarbeitung ins Spiel kommen, wird die eigene Anbindung planbarer.

WordPress 7.0: der eingebaute KI-Client

Seit WordPress 7.0 bringt der Kern einen KI-Client mit. Er gibt PHP-Code eine einheitliche Art, mit generativen Modellen zu arbeiten, unabhängig vom Anbieter. Zugangsdaten tragen Administratoren nach der Installation eines Anbieter-Plugins unter „Einstellungen > Connectors“ ein. Den Einstieg bildet die Funktion wp_ai_client_prompt().

<?php
/**
 * Fasst einen Text mit dem KI-Client von WordPress zusammen.
 * Setzt WordPress 7.0 und einen eingerichteten Connector voraus.
 */
function wd_summarize( string $text ): string {
	$summary = wp_ai_client_prompt( 'Fasse in drei Sätzen zusammen: ' . $text )
		->generate_text();

	if ( is_wp_error( $summary ) ) {
		error_log( $summary->get_error_message() );
		return '';
	}

	return $summary;
}

generate_text() wirft bei einem Fehler keine Ausnahme, sondern liefert ein WP_Error-Objekt zurück. Deshalb steht die Prüfung mit is_wp_error() direkt dahinter.

Der Vorteil dieses Weges: Die anbieterneutrale Schnittstelle und die Schlüsselverwaltung liegen im Kern und nicht in Ihrem Code. Ob ein Anbieter zu Ihren Anforderungen an Standort und Datenschutz passt, klärt das nicht. Das legen Sie vor dem Einbau fest.

WordPress mit eigener Anbindung: wp_remote_post

Läuft Ihre Seite nicht auf WordPress 7.0 oder spricht Ihr Anbieter nicht über einen Connector, rufen Sie die API selbst auf. WordPress liefert dafür die HTTP-API mit wp_remote_post(). Die Funktion gibt die Antwort oder ein WP_Error zurück. Den Statuscode der Antwort liest wp_remote_retrieve_response_code(); der Code prüft ihn zusätzlich.

Den Schlüssel legen Sie nicht in den Quelltext des Plugins und nicht in die Datenbank, sondern als Konstante in die wp-config.php:

// wp-config.php: Schlüssel vom Anbieter hier eintragen, Datei nicht ins Repository
define( 'WD_AI_API_KEY', 'SCHLUESSEL_HIER_EINTRAGEN' );

Im Plugin liest der Aufruf die Konstante:

<?php
function wd_ask_model( string $prompt ) {
	$response = wp_remote_post(
		'https://api.example.com/v1/generate', // Adresse laut Anbieterdokumentation
		array(
			'headers' => array(
				'Content-Type'  => 'application/json',
				'Authorization' => 'Bearer ' . WD_AI_API_KEY,
			),
			'body'    => wp_json_encode( array( 'prompt' => $prompt ) ),
			'timeout' => 30,
		)
	);

	if ( is_wp_error( $response ) ) {
		return $response;
	}

	$status = wp_remote_retrieve_response_code( $response );
	if ( 200 !== $status ) {
		return new WP_Error( 'wd_ai_http', 'Unerwarteter Status: ' . $status );
	}

	return json_decode( wp_remote_retrieve_body( $response ), true );
}

Die Adresse und das Format von body stammen vom jeweiligen Anbieter. api.example.com ist ein Platzhalter.

Der Aufruf gehört auf den Server

Der Browser Ihrer Besucher darf den Schlüssel nie zu sehen bekommen. Schlüssel im JavaScript einer Seite sind für jeden lesbar, der den Quelltext öffnet. Üblich ist deshalb ein eigener Endpunkt auf Ihrem Server, den das Skript im Browser aufruft, während der Server den Schlüssel anhängt und die Anfrage weiterreicht.

In WordPress registrieren Sie dafür eine REST-Route. Die Registrierung gehört in einen Callback auf rest_api_init, und seit WordPress 5.5 verlangt WordPress zusätzlich einen permission_callback. Wer den Endpunkt offen lässt, lässt jeden Besucher auf Ihre Kosten KI-Anfragen stellen. Das Beispiel erlaubt ihn nur Nutzern, die Beiträge bearbeiten dürfen. Ruft ein angemeldeter Nutzer die Route aus dem Browser auf, sendet das Skript zusätzlich den REST-Nonce im Header X-WP-Nonce mit (Aktion wp_rest). Fehlt er, behandelt WordPress die Anfrage als nicht angemeldet, und die Rollenprüfung schlägt fehl:

<?php
add_action( 'rest_api_init', function () {
	register_rest_route(
		'wd-ai/v1',
		'/summarize',
		array(
			'methods'             => 'POST',
			'callback'            => 'wd_rest_summarize',
			'permission_callback' => function () {
				return current_user_can( 'edit_posts' );
			},
		)
	);
} );

wd_rest_summarize nimmt die Anfrage entgegen, ruft intern wd_ask_model() auf und gibt ein WP_REST_Response oder ein WP_Error zurück. Die Antwort des Modells behandeln Sie wie Nutzereingabe und escapen sie bei der Ausgabe in HTML, etwa mit esc_html(). Für eine öffentliche Funktion wie einen Chatbot auf der Website reicht diese Rollenprüfung nicht. Dann brauchen Sie weitere Schutzmaßnahmen gegen Missbrauch, die ich im Projekt gemeinsam mit Ihnen festlege. Einen ausführlicheren Einstieg zum Chatbot finden Sie im Artikel KI-Chatbot auf Website einbinden.

TYPO3: RequestFactory in einer Extension

TYPO3 bringt für Anfragen an externe Server die Klasse RequestFactory mit. Sie ist ein vereinfachter Aufsatz auf den HTTP-Client Guzzle. Die unter $GLOBALS['TYPO3_CONF_VARS']['HTTP'] gesetzten Optionen gelten dabei automatisch. Ich lege Zugangsdaten in der Extension-Konfiguration ab, die TYPO3 in config/system/settings.php speichert und die Sie mit ExtensionConfiguration lesen. Der Wert steht dort im Klartext; die Datei gehört nicht ins Quelltext-Repository.

<?php

declare(strict_types=1);

namespace MyVendor\KiAnbindung\Service;

use GuzzleHttp\Exception\GuzzleException;
use TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
use TYPO3\CMS\Core\Http\RequestFactory;

final class ModelClient
{
    public function __construct(
        private readonly RequestFactory $requestFactory,
        private readonly ExtensionConfiguration $extensionConfiguration,
    ) {}

    public function ask(string $prompt): array
    {
        $apiKey = (string)$this->extensionConfiguration->get('ki_anbindung', 'apiKey');

        try {
            $response = $this->requestFactory->request(
                'https://api.example.com/v1/generate', // Adresse laut Anbieterdokumentation
                'POST',
                [
                    'headers' => [
                        'Authorization' => 'Bearer ' . $apiKey,
                        'Content-Type' => 'application/json',
                    ],
                    'body' => json_encode(['prompt' => $prompt]),
                ],
            );
        } catch (GuzzleException) {
            return []; // HTTP- oder Verbindungsfehler: Aufrufer behandelt die leere Antwort
        }

        $data = json_decode($response->getBody()->getContents(), true);

        return is_array($data) ? $data : [];
    }
}

Die TYPO3-Dokumentation nennt für RequestFactory unter anderem die Optionen headers und body. Die Dokumentation beschreibt die Optionen als Teilmenge der Guzzle-Optionen, die sich erweitern lässt. Die Zeitgrenze für Anfragen legen Sie in TYPO3 über die HTTP-Einstellungen fest. Laut Guzzle-Dokumentation wirft Guzzle bei Antworten mit Fehlerstatus (4xx und 5xx) standardmäßig eine Ausnahme; das Beispiel fängt sie ab. Die Klasse gehört in eine Extension, die Sie wie jede andere nach der TYPO3-Dokumentation Ihrer Version aufbauen. Extbase ist dafür möglich, aber nicht vorgeschrieben. Aufrufe aus Frontend-Plugin oder Backend-Modul laufen auf dem Server, der Schlüssel bleibt dort.

Prüfen Sie vor dem Einbau die Dokumentation zu Ihrer TYPO3-Version, denn Details wie die Art, die RequestFactory zu beziehen, unterscheiden sich zwischen Beispielen verschiedener Versionen.

Worauf Sie vor dem Start achten sollten

• Standort und Anbieter: Jeder dieser Aufrufe schickt den übergebenen Text an den Anbieter des Modells. Welche Daten das sein dürfen, klären Sie vorher.
• Schlüssel: Außerhalb des Browsers, außerhalb der Datenbank und außerhalb des Quelltext-Repositorys speichern, wie oben gezeigt.
• Fehlerfälle: Zeitüberschreitung, Fehlerstatus und leere Antwort kommen vor. Der Code muss sie abfangen, ohne dass die Seite ausfällt.
• Kosten: Sie hängen von Anbieter, Modell und Nutzungsmenge ab. Eine Zahl nenne ich erst nach einem Gespräch über Ihren Fall.
• Recht: Bei der technischen Umsetzung berücksichtige ich die Anforderungen der DSGVO; ob der Einsatz im Einzelfall rechtmäßig ist, bewertet Ihre Datenschutzberatung. Eine Rechtsberatung ist das nicht.

Wenn Sie das nicht selbst bauen möchten

Ich setze KI-Funktionen in vorhandenen WordPress-, TYPO3- und PHP-Webanwendungen um, auch in Laravel-Projekten. Was dazugehört, steht auf der Seite KI für WordPress und TYPO3. Einen Überblick über alle KI-Leistungen gibt die KI-Integration. Beschreiben Sie mir über das Kontaktformular kurz Ihr System und die gewünschte Funktion. Ich melde mich mit einer ersten Einschätzung.