MCP SDK für PHP: So verbindet ihr eure Anwendungen mit KI-Assistenten

„Wie kann ich meine PHP-Anwendung mit Claude verbinden?“ Diese Frage erreicht uns immer häufiger. Mit dem offiziellen MCP SDK für PHP habt ihr endlich eine standardisierte Lösung – und wir zeigen euch, wie ihr sie einsetzt.

Das Model Context Protocol – der USB-C-Anschluss für KI

Stellt euch vor, ihr müsstet für jedes Gerät einen eigenen Anschluss entwickeln. Genau dieses Problem hatten Entwickler bisher bei der Integration von KI-Modellen. Jede Anbindung war individuell, jede Schnittstelle proprietär. Das Model Context Protocol (MCP) von Anthropic ändert das grundlegend.

MCP standardisiert, wie KI-Anwendungen wie Claude, Cursor oder ChatGPT mit externen Datenquellen und Tools kommunizieren. Seit September 2025 gibt es dafür das offizielle PHP SDK – eine Zusammenarbeit zwischen der PHP Foundation, dem Symfony-Team und Anthropic. Mit über 15 Jahren Erfahrung in Softwarequalität und Open Source haben wir uns intensiv mit dieser Technologie beschäftigt.

Was ist das MCP SDK überhaupt und warum braucht PHP das?

Das MCP SDK ist eine Framework-agnostische Bibliothek, die euch ermöglicht, MCP-Server in PHP zu implementieren. Damit exponiert ihr Funktionen eurer bestehenden PHP-Anwendung als standardisierte Tools, Ressourcen und Prompts, die KI-Assistenten direkt nutzen können.

PHP betreibt rund 77% aller Websites – von WordPress über Drupal bis zu Laravel-Anwendungen. Bis zur Veröffentlichung des offiziellen SDKs gab es keine standardisierte Möglichkeit, diese massiven Codebases mit modernen KI-Systemen zu verbinden. Das SDK schließt diese Lücke.

Die Installation erfolgt per Composer:

composer require mcp/sdk

Da das Paket noch keinen stabilen Release hat, benötigt ihr zusätzlich in eurer composer.json:

{
    "minimum-stability": "dev",
    "prefer-stable": true
}

Wie funktioniert die MCP-Architektur für PHP-Entwickler?

MCP folgt einer Client-Host-Server-Architektur. Der Host (etwa Claude Desktop oder Cursor IDE) verwaltet mehrere Clients, wobei jeder Client eine 1:1-Beziehung zu einem Server hat. Die Kommunikation läuft über JSON-RPC 2.0.

Für euch als PHP-Entwickler bedeutet das: Ihr baut MCP-Server, die Tools, Ressourcen und Prompts bereitstellen. Die KI-Assistenten verbinden sich dann als Clients mit euren Servern und können die exponierten Funktionen nutzen.

Ein minimales Beispiel zeigt, wie einfach das ist:

<?php

namespace App;

use McpCapabilityAttributeMcpTool;

class CalculatorElements
{
    #[McpTool(name: 'add_numbers')]
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }
}

Der Server-Entrypoint sieht so aus:

#!/usr/bin/env php
<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use McpServer;
use McpServerTransportStdioTransport;

Server::make()
    ->withServerInfo('My PHP Server', '1.0.0', 'Beschreibung')
    ->withDiscovery(__DIR__, ['.'])
    ->build()
    ->connect(new StdioTransport());

Welche PHP-Version und Dependencies brauche ich für das MCP SDK?

Das SDK erfordert PHP 8.1 oder höher. Für optimale Performance empfehlen wir PHP 8.2+ mit aktiviertem OPcache. Die wichtigsten Dependencies sind:

• psr/log für Logging
• symfony/uid für eindeutige Identifikatoren
• symfony/finder für Datei-Discovery
• opis/json-schema für Schema-Validierung

Optional könnt ihr symfony/console für STDIO-Transport und psr/cache für Session-Stores einbinden. Die Installation aller Dependencies übernimmt Composer automatisch.

Aus unserer Remote-Consulting-Erfahrung: Testet die Installation in einer isolierten Umgebung, bevor ihr sie in Production einsetzt. Docker eignet sich hervorragend dafür.

Wie unterscheidet sich ein MCP-Server von einer REST-API?

Diese Frage stellen uns Entwickler regelmäßig. Der Hauptunterschied liegt im Verwendungszweck: REST-APIs sind für Web-Anwendungen konzipiert, MCP-Server für KI-Systeme.

Bei REST definiert ihr Endpunkte, Methoden und Authentifizierung selbst. Bei MCP nutzt ihr ein standardisiertes Protokoll, das KI-Modelle verstehen. Die KI kann automatisch erkennen, welche Tools verfügbar sind, welche Parameter sie erwarten und wie die Rückgabewerte strukturiert sind.

Praktisch bedeutet das: Wenn ihr einen MCP-Server baut, kann jeder MCP-kompatible Client (Claude, Cursor, ChatGPT) sofort damit arbeiten – ohne zusätzliche Integration. Bei REST müsste jeder Client individuell angebunden werden.

MCP ersetzt REST nicht, sondern ergänzt es. Für klassische Web-Anwendungen bleibt REST die richtige Wahl. Für KI-Integration ist MCP der neue Standard.

Welche Transport-Optionen bietet das PHP SDK?

Das SDK unterstützt drei Transport-Typen:

STDIO Transport – Ideal für lokale Entwicklung und CLI-Tools. Die Kommunikation läuft über Standard Input/Output:

use McpServerTransportStdioTransport;

$transport = new StdioTransport();
$server->connect($transport);

HTTP Transport mit Server-Sent Events – Für Web-basierte Clients und den MCP Inspector:

use McpServerTransportStreamableHttpTransport;

$transport = new StreamableHttpTransport(
    $request, 
    $responseFactory, 
    $streamFactory
);
$response = $server->run($transport);

Streamable HTTP mit Resumability – Für Production-Umgebungen mit hoher Verfügbarkeit. Unterstützt automatische Reconnects und Session-Persistenz.

In unseren Projekten nutzen wir STDIO für die Entwicklung und Streamable HTTP für Production. Der Wechsel erfordert nur minimale Code-Änderungen.

Wie registriere ich Tools, Ressourcen und Prompts?

Das SDK bietet zwei Wege: Attribute-basierte Discovery und manuelle Registrierung.

Attribute-basierte Discovery (empfohlen):

use McpCapabilityAttributeMcpTool;
use McpCapabilityAttributeMcpResource;
use McpCapabilityAttributeMcpPrompt;

class MyCapabilities
{
    #[McpTool(name: 'send_email')]
    public function sendEmail(string $to, string $subject, string $body): bool
    {
        // E-Mail-Logik
        return true;
    }

    #[McpResource(uri: 'config://app/settings', mimeType: 'application/json')]
    public function getSettings(): array
    {
        return ['theme' => 'dark', 'language' => 'de'];
    }

    #[McpPrompt(name: 'summarize')]
    public function createSummaryPrompt(string $topic): string
    {
        return "Erstelle eine Zusammenfassung zu: {$topic}";
    }
}

Manuelle Registrierung für komplexere Szenarien:

$server = Server::builder()
    ->addTool([MyClass::class, 'myMethod'], 'tool_name')
    ->addResource([MyClass::class, 'getData'], 'data://config')
    ->build();

Beide Methoden lassen sich kombinieren. Manuelle Registrierungen haben Vorrang bei Namenskonflikten.

Wie integriere ich das SDK in Laravel oder Symfony?

Für Laravel gibt es seit Version 12.x das offizielle laravel/mcp Package. Die Integration erfolgt über Artisan-Befehle:

composer require laravel/mcp
php artisan vendor:publish --provider="LaravelMcpMcpServiceProvider"
php artisan make:mcp-server WeatherServer

Server-Klassen landen in app/Mcp/Servers, Tools in app/Mcp/Tools.

Für Symfony existiert das symfony/mcp-bundle. Die Konfiguration in config/packages/mcp.yaml:

mcp:
    client_transports:
        stdio: true
        http: true

MCP-Capabilities werden automatisch per PHP-Attribute erkannt. Das Bundle unterstützt Tools, Prompts, Ressourcen und Resource-Templates.

Beide Frameworks bieten nahtlose Integration mit Dependency Injection und bestehenden Authentifizierungsmechanismen.

Welche Sicherheitsaspekte muss ich bei MCP-Servern beachten?

Sicherheit ist bei MCP-Servern kritisch, da sie KI-Systemen Zugriff auf eure Anwendung geben. Hier die wichtigsten Punkte aus unserer Consulting-Praxis:

Authentifizierung: Das MCP-Protokoll unterstützt OAuth 2.1. Für Laravel nutzt ihr Passport oder Sanctum:

Mcp::web('/mcp/weather', WeatherExample::class)
    ->middleware('auth:api');

Input-Validierung: Das SDK generiert automatisch JSON-Schemas aus euren Type-Hints. Nutzt diese Validierung konsequent und fügt zusätzliche Prüfungen für kritische Operationen hinzu.

Rate-Limiting: Implementiert Limits pro Client und Zeitfenster. Das Protokoll selbst bietet keine Rate-Limits, ihr müsst sie auf Anwendungsebene umsetzen.

Least-Privilege-Prinzip: Exponiert nur die Funktionen, die tatsächlich benötigt werden. Jedes zusätzliche Tool vergrößert die Angriffsfläche.

Logging und Monitoring: Protokolliert alle Tool-Aufrufe mit Client-ID, Parametern und Ergebnis. Bei Produktivumgebungen ist ein Audit-Trail unverzichtbar.

Wie debugge ich Probleme mit meinem MCP-Server?

Die häufigsten Probleme und ihre Lösungen:

Verbindung wird abgelehnt: Prüft den Server-Pfad in der Client-Konfiguration. Bei STDIO muss der Pfad zum PHP-Script absolut sein:

{
    "mcpServers": {
        "my-server": {
            "command": "php",
            "args": ["/absolute/path/to/mcp-server.php"]
        }
    }
}

Tool wird nicht erkannt: Stellt sicher, dass die Discovery-Verzeichnisse korrekt konfiguriert sind:

$server->discover(
    basePath: __DIR__,
    scanDirs: ['src/Handlers', 'src/Services']
);

JSON-Parse-Fehler: Überprüft, ob eure Tool-Rückgaben JSON-serialisierbar sind. Arrays und skalare Typen funktionieren problemlos, komplexe Objekte müssen serialisierbar sein.

Aktiviert für systematisches Debugging das Verbose-Logging im SDK. Der MCP Inspector ist ein hervorragendes Tool zum Testen eurer Server – er zeigt alle JSON-RPC-Nachrichten im Klartext.

Praktische Einsatzszenarien für das MCP SDK

Das SDK eröffnet vielfältige Möglichkeiten:

E-Commerce-Integration: Exponiert Produkt-Kataloge, Bestell-Status und Kundendaten an KI-Assistenten. Claude kann dann Kundenanfragen beantworten, ohne dass ihr eine eigene Chat-Oberfläche bauen müsst.

Content-Management: Gebt KI-Systemen Zugriff auf eure CMS-Inhalte. Automatisiert Content-Erstellung, Übersetzungen und SEO-Optimierungen direkt aus dem Workflow.

DevOps und Monitoring: Verbindet eure Monitoring-Tools mit KI-Assistenten. Lasst euch Logs analysieren, Deployments durchführen und Incidents bearbeiten – alles über natürlichsprachliche Anweisungen.

Interne Tools: Macht eure internen Systeme KI-zugänglich. Mitarbeiter können per Chat auf Daten zugreifen, Reports erstellen und Prozesse anstoßen.

Euer nächster Schritt

Das MCP SDK für PHP ist production-ready, auch wenn es noch keine finale Version gibt. Die Zusammenarbeit von PHP Foundation, Symfony und Anthropic garantiert langfristige Wartung und Weiterentwicklung.

Ihr wollt das MCP SDK in eurem Projekt einsetzen oder habt Fragen zur Integration? Mit über 15 Jahren Erfahrung in Softwarequalität, Open Source und Remote Consulting unterstützen wir euch gerne – von der ersten Konzeption bis zum Production-Deployment.

Kontakt: roland@nevercodealone.de

Wir freuen uns auf eure Projekte – und darauf, gemeinsam die nächste Generation PHP-basierter KI-Anwendungen zu bauen.

---

Never Code Alone – Gemeinsam für bessere Software-Qualität!