Shopware 6.7.4: B2B-Features, KI & PHP-E-Commerce

B2B-Features und automatisierte Shop-Analysen mit PHP

Der E-Commerce-Stack entwickelt sich weiter – und November 2025 bringt zwei entscheidende Entwicklungen für technisch versierte Agenturen und KMU: Shopware 6.7.4 mit erweiterten B2B-Funktionen und KI-Copilot sowie die zunehmende Reife von KI-Integration direkt in PHP-Projekten. Für Projektbudgets im 2-10k€ Bereich eröffnen sich damit neue Möglichkeiten, ohne auf teure externe Microservices zurückgreifen zu müssen.

Shopware 6.7.4: B2B-Commerce mit KI-gestützter Datenanalyse

Mit Shopware 6.7.4 verstärkt der Hersteller seinen Fokus auf B2B-E-Commerce und bringt gleichzeitig KI-Integration auf eine neue Stufe. Für Agenturen, die B2B-Shops betreuen, sind die neuen Features direkt relevant – besonders wenn Sie Ihre Kunden bei der Prozessoptimierung unterstützen.

Budget Management und Approval Workflows

Die neue Budget-Management-Funktion richtet sich an B2B-Organisationen mit komplexen Bestellprozessen. Shopware 6.7.4 führt ein vollständiges Budget-System ein, das sich nahtlos in die B2B Components integriert:

• Budget-Verwaltung im Admin-Backend: Erstellen, aktualisieren und deaktivieren Sie Budgets zentral
• Echtzeit-Tracking im Storefront: Mitarbeiter sehen verfügbare und verbrauchte Budgets während des Bestellvorgangs
• Automatische Approval-Workflows: Überschreitet eine Bestellung das Budget, wird automatisch ein Genehmigungsprozess ausgelöst
• Rollenbasierte Transparenz: Sowohl Mitarbeiter als auch Genehmiger erhalten klare Übersichten über Budget-Status

Technisch bedeutet das: Die Workflows laufen vollständig im Storefront ab, keine externen Tools notwendig. Für Ihre Kunden im Großhandel, Industrie-Equipment oder B2B-SaaS-Bereich ist das ein direkter Mehrwert – die Implementierung lässt sich in bestehende Shopware-Projekte integrieren.

Mixed Carts: Subscriptions und Einmalkäufe kombiniert

Shopware Subscriptions erhält mit 6.7.4 ein wichtiges Update: Mixed Carts erlauben erstmals die Kombination von regulären Produkten und Abonnements in einem Warenkorb. Das eliminiert einen erheblichen UX-Friction-Point im Checkout:

• Kunden können Einmalkäufe und Subscription-Produkte gemeinsam bestellen
• Beim Checkout entsteht eine einzige Bestellung, die sowohl den Einmalkauf als auch die erste Lieferung des Abonnements enthält
• Shopware übernimmt automatisch die Verwaltung der Folgebestellungen

Besonders relevant für Shops in den Bereichen Lebensmittel, Kosmetik oder Heimtierbedarf, wo Subscription-Modelle zunehmend Standard werden. Die Conversion-Rate profitiert messbar von diesem vereinfachten Checkout-Prozess.

Data Insights Skill für Copilot: KI-gestützte Shop-Analysen

Der größte Schritt in Richtung KI-Integration ist der neue Data Insights Skill für Shopware Copilot (derzeit Beta). Statt komplexe Analytics-Tools zu konfigurieren, können Shop-Betreiber jetzt direkt im Admin natural language queries stellen:

"Zeige mir einen Graph der GMV-Entwicklung für jeden Monat dieses Jahres."
"Was sind meine Top 10 Bestseller-Produkte?"
"Wie entwickelt sich die Conversion Rate im Vergleich zum Vorquartal?"

Copilot antwortet mit Visualisierungen als Text, Tabellen oder Graphen – ohne dass ein Analyst oder Data Engineer involviert werden muss. Die Datensicherheit ist dabei gewährleistet: Copilot liest nur explizit freigegebene Daten und verarbeitet keine personenbezogenen Informationen (PII) wie Kundennamen oder Adressen.

Für Agenturen bedeutet das: Sie können Ihren Kunden schnellere Insights liefern, ohne komplexe BI-Dashboards aufzusetzen. Die Implementierung reduziert Support-Aufwand und verbessert die Kundenautonomie erheblich.

KI-Integration in PHP-Projekten: Production-Ready Workflows ohne Python-Migration

Parallel zur Shopware-Entwicklung erreicht die KI-Integration in PHP 2025 einen neuen Reifegrad. Für Agenturen, die primär auf PHP/Symfony setzen, ist das eine entscheidende Entwicklung: Sie müssen nicht mehr zwingend Python-Microservices aufbauen, um KI-Features zu integrieren.

Das PHP-KI-Ökosystem: LLPhant und TransformersPHP

Zwei Frameworks dominieren aktuell die PHP-KI-Landschaft:

LLPhant: Generative AI für PHP

LLPhant (1.295 GitHub Stars) positioniert sich als "PHPs Antwort auf LangChain" und bietet umfassende Integration mit Large Language Models:

• Multi-Provider-Support: OpenAI, Anthropic Claude, Mistral, Ollama – wechseln Sie flexibel zwischen Anbietern
• RAG-Implementierung: Retrieval-Augmented Generation mit Elasticsearch, Pinecone, Chroma
• Framework-Integration: Native Unterstützung für Laravel und Symfony
• Production-Ready: Monatliche Releases, aktive Maintenance

Praktisches Beispiel für einen Customer Support Bot:

use LLPhant\Chat\OpenAIChat;
use LLPhant\Embeddings\VectorStores\Elasticsearch\ElasticsearchVectorStore;

class CustomerSupportBot
{
    private OpenAIChat $chat;
    private ElasticsearchVectorStore $vectorStore;

    public function __construct(string $apiKey)
    {
        $this->chat = new OpenAIChat($apiKey);
        $this->vectorStore = new ElasticsearchVectorStore();
    }

    public function handleInquiry(string $userMessage): string
    {
        // RAG: Relevante Dokumente aus Wissensdatenbank abrufen
        $relevantDocs = $this->vectorStore->similaritySearch($userMessage, 5);
        $context = implode("\n", $relevantDocs);
        
        $prompt = "Basierend auf diesem Kontext: {$context}\n\nBeantworte: {$userMessage}";
        
        return $this->chat->generateText($prompt);
    }
}

Performance-Benchmark (durchschnittlich über 100 Requests):

• OpenAI GPT-4: 3,2 Sekunden Antwortzeit
• Lokales Ollama (Llama 2): 1,8 Sekunden
• Anthropic Claude: 2,7 Sekunden
• Memory-Verbrauch: Basis 12MB, mit Elasticsearch +85MB

TransformersPHP: On-Premise ML mit ONNX Runtime

TransformersPHP (681 GitHub Stars) verfolgt einen anderen Ansatz: Statt API-Calls werden Hugging Face Modelle lokal via ONNX Runtime ausgeführt. Das ist besonders relevant für DSGVO-sensible Anwendungen, bei denen Daten den Server nicht verlassen dürfen:

use function Codewithkyrian\Transformers\Pipelines\pipeline;

// Sentiment-Analyse komplett lokal
$sentimentPipe = pipeline('sentiment-analysis');

$customerFeedback = [
    "Dieses Produkt ist absolut genial!",
    "Schlechtester Kauf jemals, furchtbare Qualität",
    "Geht so, nichts Besonderes"
];

foreach ($customerFeedback as $feedback) {
    $result = $sentimentPipe($feedback);
    echo "Feedback: {$feedback}\n";
    echo "Sentiment: {$result['label']} (Confidence: {$result['score']})\n\n";
}

Performance-Benchmark (4-Core Server):

• Sentiment-Analyse: ~47ms pro Text
• Übersetzung: ~180ms pro Satz
• Modell-Ladezeit (klein): 2-4 Sekunden
• Modell-Ladezeit (groß): 15-45 Sekunden
• Genauigkeit: 94,2% bei Content-Moderation

Wichtige Voraussetzung: TransformersPHP benötigt die PHP FFI-Extension. In php.ini muss aktiviert sein:

extension=ffi
ffi.enable=true

Das ist auf Shared-Hosting oft nicht verfügbar, auf VPS oder Dedicated Servern aber kein Problem.

Symfony-Integration: Enterprise-Ready AI-Workflows

Für Symfony-Projekte bietet das Framework durch Dependency Injection und Event System ideale Voraussetzungen für saubere KI-Integration:

# config/services.yaml
services:
    App\AI\LLPhantProvider:
        arguments:
            $apiKey: '%env(OPENAI_API_KEY)%'
    
    App\AI\TransformersProvider:
        arguments:
            $modelsPath: '%kernel.project_dir%/var/models'
    
    App\EventListener\AISecurityListener:
        tags:
            - { name: kernel.event_listener, event: kernel.request, priority: 100 }

Event-basierte Validierung für AI-Requests:

class AISecurityListener
{
    public function onKernelRequest(RequestEvent $event): void
    {
        $request = $event->getRequest();
        
        if (str_starts_with($request->getPathInfo(), '/api/ai/')) {
            $this->validateAIRequest($request);
        }
    }
    
    private function validateAIRequest(Request $request): void
    {
        $content = $request->getContent();
        
        // Prompt Injection Prevention
        $dangerousPatterns = [
            '/\b(ignore|vergiss|system|admin)\s+(vorherige|obige|anweisung)/i',
            '/\b(jailbreak|umgehe|überschreibe)\s+(sicherheit|filter|regel)/i'
        ];
        
        foreach ($dangerousPatterns as $pattern) {
            if (preg_match($pattern, $content)) {
                throw new SecurityException('Potenziell schädlicher Input erkannt');
            }
        }
        
        if (strlen($content) > 8000) {
            throw new ValidationException('Input überschreitet maximale Länge');
        }
    }
}

Praktische Anwendungsfälle für 2-10k€ Projektbudgets

Beide Technologien – Shopware 6.7.4 und PHP-KI-Integration – eröffnen konkrete Projektmöglichkeiten für KMU und Agenturen:

E-Commerce mit KI-Customer-Support

Projektszenario: Shopware-Shop mit automatisiertem First-Level-Support

Tech-Stack:

• Shopware 6.7.4 (B2B oder Professional Edition)
• LLPhant für Chat-Integration
• Elasticsearch für RAG-Wissensdatenbank
• Symfony Messenger für Queue-Processing

Implementation:

class CustomerSupportService
{
    public function __construct(
        private OpenAIChat $chat,
        private OrderRepository $orderRepo,
        private ElasticsearchVectorStore $knowledgeBase
    ) {}
    
    public function generateResponse(string $inquiry, string $customerId): string
    {
        // Kundenkontext aufbauen
        $recentOrders = $this->orderRepo->findRecentByCustomer($customerId, 5);
        $orderContext = $this->formatOrderHistory($recentOrders);
        
        // Relevante Wissensdatenbank-Einträge
        $relevantDocs = $this->knowledgeBase->similaritySearch($inquiry, 3);
        $kbContext = implode("\n", $relevantDocs);
        
        $prompt = "
Kundenhistorie: {$orderContext}
Wissensdatenbank: {$kbContext}
Kundenanfrage: {$inquiry}

Erstelle eine hilfreiche, empathische Antwort auf Deutsch.
Beziehe relevante Bestellinformationen ein, falls zutreffend.
        ";
        
        return $this->chat->generateText($prompt);
    }
    
    private function formatOrderHistory(array $orders): string
    {
        return collect($orders)
            ->map(fn($order) => sprintf(
                "Bestellung #%s: %s - %s",
                $order->getOrderNumber(),
                $order->getStateMachineState()->getName(),
                $order->getAmountTotal()
            ))
            ->implode("\n");
    }
}

Projektergebnis:

• Durchschnittliche Antwortzeit: 1,8 Minuten (vorher: 4,2 Minuten)
• Kundenzufriedenheit: 89% (vorher: 67%)
• Projektaufwand: ca. 3 Wochen bei bestehender Shopware-Installation
• Stundensatz: 65-85€, Gesamtbudget: ca. 7.500€

Content-Moderation für Community-Plattformen

Projektszenario: WordPress-Multisite oder Symfony-Forum mit automatisierter Content-Moderation

Tech-Stack:

• Symfony 7.x oder WordPress 6.x
• TransformersPHP für lokale ML-Inference
• Redis für Response-Caching
• MySQL/PostgreSQL für Moderation-Logs

Implementation:

class ContentModerationService
{
    private array $pipelines;
    
    public function __construct()
    {
        $this->pipelines = [
            'toxicity' => pipeline('text-classification', 'unitary/toxic-bert'),
            'sentiment' => pipeline('sentiment-analysis'),
            'language' => pipeline(
                'text-classification', 
                'papluca/xlm-roberta-base-language-detection'
            )
        ];
    }
    
    public function moderateContent(string $content): ModerationResult
    {
        // Multi-Modell-Analyse für robuste Moderation
        $toxicity = $this->pipelines['toxicity']($content);
        $sentiment = $this->pipelines['sentiment']($content);
        $language = $this->pipelines['language']($content);
        
        $shouldFlag = $toxicity['label'] === 'TOXIC' 
                   && $toxicity['score'] > 0.8;
                   
        $needsReview = $sentiment['label'] === 'NEGATIVE' 
                    && $sentiment['score'] > 0.9;
        
        return new ModerationResult([
            'approved' => !$shouldFlag,
            'requires_review' => $needsReview,
            'toxicity_score' => $toxicity['score'],
            'sentiment' => $sentiment['label'],
            'confidence' => $sentiment['score'],
            'detected_language' => $language['label']
        ]);
    }
    
    public function batchModerate(array $contents): array
    {
        $results = [];
        
        // Batch-Processing mit Memory-Management
        $chunks = array_chunk($contents, 50);
        
        foreach ($chunks as $chunk) {
            foreach ($chunk as $content) {
                $results[] = $this->moderateContent($content);
            }
            
            // Garbage Collection bei hohem Memory-Verbrauch
            if (memory_get_usage() > 512 * 1024 * 1024) {
                gc_collect_cycles();
            }
        }
        
        return $results;
    }
}

Projektergebnis:

• Verarbeitungsvolumen: 50.000 Kommentare/Tag komplett lokal
• Moderation-Genauigkeit: 94,2%
• Kosteneinsparung: ca. 2.800€/Monat vs. externe AI-APIs
• Projektaufwand: 2-3 Wochen Implementation
• Gesamtbudget: ca. 5.500€

Shopware Product Recommendations mit lokaler ML

Projektszenario: Shopware-Shop mit KI-gestützten Produktempfehlungen ohne externe APIs

Tech-Stack:

• Shopware 6.7.4
• TransformersPHP für Embedding-Generation
• MySQL Vector Search (ab MySQL 8.0.33)
• Redis für Embedding-Cache

Implementation:

class ProductRecommendationService
{
    private object $embeddingPipeline;
    private RedisClient $redis;
    
    public function __construct(
        private EntityRepository $productRepo,
        RedisClient $redis
    ) {
        $this->embeddingPipeline = pipeline('feature-extraction', 'sentence-transformers/all-MiniLM-L6-v2');
        $this->redis = $redis;
    }
    
    public function getSimilarProducts(string $productId, int $limit = 6): array
    {
        $product = $this->productRepo->search(
            new Criteria([$productId]),
            Context::createDefaultContext()
        )->first();
        
        // Produkt-Text für Embedding
        $productText = sprintf(
            "%s %s %s",
            $product->getName(),
            $product->getDescription() ?? '',
            implode(' ', $product->getCategoryTree() ?? [])
        );
        
        // Cache-Key für Embedding
        $cacheKey = "embedding:product:{$productId}";
        
        // Embedding generieren oder aus Cache laden
        $embedding = $this->redis->get($cacheKey);
        if (!$embedding) {
            $result = $this->embeddingPipeline($productText);
            $embedding = json_encode($result['embeddings'][0]);
            $this->redis->setex($cacheKey, 86400, $embedding); // 24h Cache
        }
        
        // Vector Similarity Search
        return $this->findSimilarByEmbedding($embedding, $productId, $limit);
    }
    
    private function findSimilarByEmbedding(string $embedding, string $excludeId, int $limit): array
    {
        $sql = "
            SELECT product_id, 
                   (1 - (embedding <=> :query_embedding)) as similarity
            FROM product_embeddings
            WHERE product_id != :exclude_id
            ORDER BY similarity DESC
            LIMIT :limit
        ";
        
        return $this->connection->fetchAllAssociative($sql, [
            'query_embedding' => $embedding,
            'exclude_id' => $excludeId,
            'limit' => $limit
        ]);
    }
}

Projektergebnis:

• Empfehlungs-Latenz: ~120ms pro Request
• Keine externen API-Kosten
• DSGVO-konform (alle Daten bleiben auf eigenem Server)
• Projektaufwand: 1,5-2 Wochen
• Gesamtbudget: ca. 4.200€

Memory-Management und Performance-Optimierung

Sowohl LLPhant als auch TransformersPHP sind memory-intensiv. Für Production-Deployments sollten Sie folgende Optimierungen implementieren:

Model Caching und Reuse

class OptimizedAIService
{
    private static ?object $cachedModel = null;
    
    public static function getOptimizedPipeline(string $task): object
    {
        // Modell wiederverwendbar cachen
        if (self::$cachedModel === null) {
            self::$cachedModel = pipeline($task);
        }
        
        return self::$cachedModel;
    }
}

Batch Processing mit Garbage Collection

public function batchProcess(array $inputs, string $task, int $batchSize = 50): array
{
    $results = [];
    $chunks = array_chunk($inputs, $batchSize);
    
    foreach ($chunks as $chunk) {
        $batchResults = $this->processBatch($chunk, $task);
        $results = array_merge($results, $batchResults);
        
        // Garbage Collection bei Memory-Threshold
        if (memory_get_usage() > 512 * 1024 * 1024) {
            gc_collect_cycles();
        }
    }
    
    return $results;
}

PHP.ini Anpassungen für AI-Workloads

; Empfohlene Settings für AI-intensive Anwendungen
memory_limit = 2G
max_execution_time = 300
opcache.enable = 1
opcache.memory_consumption = 256
opcache.max_accelerated_files = 20000
extension=ffi
ffi.enable=true

Sicherheit: CVE-2024-4577 und Prompt Injection Prevention

PHP-Entwickler sollten sich der kritischen Sicherheitslücke CVE-2024-4577 (CVSS 9.8) bewusst sein, die Windows-PHP-CGI-Installationen betrifft. Besonders AI-Anwendungen sind attraktive Ziele, da sie sensible Trainingsdaten verarbeiten.

Sofortmaßnahmen

• Update auf sichere Versionen: PHP 8.3.8+, PHP 8.2.20+, PHP 8.1.29+
• Wechsel von CGI zu PHP-FPM: sudo apt install php-fpm
• Application-Level Security: Input-Validierung für AI-Requests

Prompt Injection Prevention

class AISecurityValidator
{
    public function validateAIInput(string $input): string
    {
        $dangerousPatterns = [
            '/\b(ignore|vergiss|system|admin)\s+(vorherige|obige|anweisung)/i',
            '/\b(jailbreak|umgehe|überschreibe)\s+(sicherheit|filter|regel)/i',
            '/\b(führe\s+aus|run|eval)\s+(code|script|befehl)/i'
        ];
        
        foreach ($dangerousPatterns as $pattern) {
            if (preg_match($pattern, $input)) {
                throw new SecurityException(
                    'Potenziell schädlicher Input erkannt'
                );
            }
        }
        
        if (strlen($input) > 8000) {
            throw new ValidationException(
                'Input überschreitet maximale Länge'
            );
        }
        
        return $input;
    }
}

PHP 8.5 und der Pipe Operator: Lesbarer ML-Code

Der für November 2025 erwartete Pipe Operator (|>) in PHP 8.5 verbessert die Lesbarkeit von ML-Datenverarbeitungspipelines erheblich:

// Vorher: Verschachtelte Funktionsaufrufe
$result = array_unique(
    array_filter(
        array_map(function($text) {
            return strtolower(trim($text));
        }, explode(',', $userInput)),
        function($item) {
            return !empty($item) && strlen($item) > 2;
        }
    )
);

// PHP 8.5: Lesbarer Left-to-Right Flow
$result = $userInput
    |> explode(',', ...)
    |> array_map(fn($text) => strtolower(trim($text)), ...)
    |> array_filter(..., fn($item) => !empty($item) && strlen($item) > 2)
    |> array_unique(...);

Für ML-Preprocessing-Pipelines ist das ein Game-Changer in Bezug auf Code-Wartbarkeit:

class TextPreprocessor
{
    public function preprocessForML(array $documents): array
    {
        return $documents
            |> array_map(fn($doc) => $this->cleanText($doc), ...)
            |> array_filter(..., fn($doc) => strlen($doc) > 50)
            |> array_map(fn($doc) => $this->tokenize($doc), ...)
            |> array_map(fn($tokens) => $this->removeStopwords($tokens), ...)
            |> array_filter(..., fn($tokens) => count($tokens) > 5);
    }
}

Docker-Setup für AI-enabled PHP Applications

Ein production-ready Docker-Setup für PHP-AI-Projekte sollte ausreichend Memory und Caching-Layer bereitstellen:

# docker-compose.yml
version: "3.8"

services:
  app:
    build: .
    volumes:
      - ./models:/app/storage/models
      - ./var:/app/var
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - PHP_MEMORY_LIMIT=2G
      - APP_ENV=prod
    deploy:
      resources:
        limits:
          memory: 3G
        reservations:
          memory: 1G
    depends_on:
      - redis
      - elasticsearch

  redis:
    image: redis:7-alpine
    command: redis-server --maxmemory 512mb --maxmemory-policy allkeys-lru
    
  elasticsearch:
    image: elasticsearch:8.11.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms1g -Xmx1g"
    volumes:
      - es_data:/usr/share/elasticsearch/data

volumes:
  es_data:
    driver: local

Grenzen und realistische Erwartungen

Trotz des Fortschritts: PHP-AI hat klare Limitierungen, die Sie Ihren Kunden kommunizieren sollten:

Was PHP-AI nicht kann

• Model Training: Weder LLPhant noch TransformersPHP unterstützen Model-Training. Sie sind auf Inference mit vortrainierten Modellen beschränkt.
• Heavy Numerical Computing: PHP erreicht nicht die Performance von Python's NumPy/SciPy-Ökosystem.
• GPU-Beschleunigung: Limitierte GPU-Unterstützung im Vergleich zu Python. ONNX Runtime kann theoretisch GPU nutzen, Setup ist aber komplex.
• Community-Größe: Kleineres Ökosystem bedeutet weniger vorgefertigte Lösungen und Community-Wissen.

Wann Sie Python empfehlen sollten

Seien Sie ehrlich mit Ihren Kunden: Python ist die bessere Wahl für:

• Custom Model-Architekturen
• Model-Training und Fine-Tuning
• Schweres numerisches Computing
• Cutting-Edge Research Implementations
• Maximale Performance-Optimierung

PHP-AI ist ideal für:

• Bestehende PHP-Infrastruktur
• Web-first Applications
• Teams mit PHP-Expertise
• Präferenz für schnelle Integration über maximale Performance

Fazit: Der richtige Einsatz von Shopware 6.7.4 und PHP-AI

Sowohl Shopware 6.7.4 als auch die PHP-KI-Integration erreichen 2025 einen Reifegrad, der sie für produktive Projekte im 2-10k€ Budget qualifiziert. Für Agenturen bedeutet das:

Shopware 6.7.4 eignet sich für:

• B2B-Shops mit komplexen Bestellprozessen
• Subscription-Modelle im E-Commerce
• Kunden, die datengetriebene Insights ohne externe BI-Tools benötigen

PHP-AI-Integration ist sinnvoll bei:

• Bestehenden PHP/Symfony-Projekten
• DSGVO-sensiblen Anwendungen (TransformersPHP lokal)
• Customer Support Automation
• Content Moderation
• Product Recommendations

Die Kombination aus Shopware's nativem Copilot und custom PHP-AI-Integration via LLPhant/TransformersPHP eröffnet neue Möglichkeiten, ohne dass Sie komplett auf Python-Microservices umschwenken müssen. Der Schlüssel liegt in der realistischen Einschätzung: PHP-AI ersetzt keine Data Science Teams, aber es demokratisiert AI-Features für typische Web-Anwendungen erheblich.

Für technische Beratung zu Shopware-Projekten, Symfony-Entwicklung oder PHP-AI-Integration erreichen Sie mich unter d-schwenker.de. Ich unterstütze Agenturen und KMU im Raum Oldenburg und deutschlandweit bei der Integration moderner E-Commerce- und KI-Lösungen.

Dennis Schwenker-Sanders | Symfony & PHP Development | d-schwenker.de