Symfony AI Initiative : PHP entre dans l'ère des LLM

La semaine du 7 juillet 2025 marque un tournant pour l'écosystème PHP. L'équipe Symfony publie « Kicking off the Symfony AI Initiative » sur symfony.com — annonce relayée dans A Week of Symfony #967 — et ouvre simultanément le mono-repo symfony/ai sur GitHub. Ce n'est pas un wrapper LLM de plus : c'est une proposition d'architecture complète pour intégrer les grands modèles de langage directement dans un projet Symfony 7.3, sans quitter l'écosystème, sans bricoler des clients HTTP à la main.

Un mono-repo, quatre composants

Le dépôt symfony/ai est structuré en packages indépendants qu'on installe à la carte — même philosophie que Symfony Messenger ou Serializer. Une abstraction de bas niveau (Platform), une couche orchestration (Agent), du stockage vectoriel (Store), et un bundle prêt-à-l'emploi (AI Bundle) qui injecte le tout dans le conteneur de services.

• Platform — abstraction sur les LLM (Claude Sonnet 4, OpenAI GPT-4o, Mistral) avec une interface commune ; gère streaming, tool-calls et message history
• Agent — orchestration de boucles agent/tool avec support natif du Model Context Protocol (MCP)
• Store — gestion des embeddings, indexation et recherche vectorielle (RAG-ready)
• AI Bundle — configuration YAML, injection de dépendances Symfony, profiler web inclus

# Symfony 7.3 / PHP 8.4
composer require symfony/ai-bundle

# Provider Anthropic
composer require symfony/ai-anthropic

# Store pour le RAG (exemple avec PostgreSQL + pgvector)
composer require symfony/ai-store-doctrine

# config/packages/ai.yaml
symfony_ai:
    platform:
        anthropic:
            api_key: '%env(ANTHROPIC_API_KEY)%'
            model: claude-sonnet-4-5   # Claude Sonnet 4, GA depuis mai 2025
        openai:
            api_key: '%env(OPENAI_API_KEY)%'
            model: gpt-4o
    agent:
        default:
            platform: anthropic
            tools:
                - App\AiTool\ProductSearchTool
    store:
        default:
            driver: doctrine
            dsn: '%env(DATABASE_URL)%'

Premier contact avec Platform et Agent

L'API respecte les conventions Symfony : tout passe par l'injection de dépendances, les messages sont des value objects typés, le streaming s'appuie sur les générateurs PHP natifs. Voici un service minimal qui interroge l'agent et retourne la réponse :

<?php
// src/Service/AssistantService.php

declare(strict_types=1);

namespace App\Service;

use Symfony\AI\Agent\AgentInterface;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;

final class AssistantService
{
    public function __construct(
        private readonly AgentInterface $agent,
    ) {}

    public function answer(string $userQuestion, string $systemContext = ''): string
    {
        $messages = new MessageBag(
            Message::ofSystem($systemContext ?: 'Tu es un assistant technique Symfony.'),
            Message::ofUser($userQuestion),
        );

        $response = $this->agent->call($messages);

        return $response->getContent();
    }
}

RAG, Store et MCP : ce qui distingue l'initiative

Le composant Store est l'apport le plus structurant pour les projets métier. Il abstrait le stockage vectoriel — Doctrine/pgvector en premier, Qdrant et Meilisearch dans la roadmap — et expose une API uniforme pour indexer des documents et récupérer les chunks pertinents avant de les injecter dans le contexte du LLM. Le pattern RAG devient une affaire de configuration, pas de plomberie.

<?php
// src/Command/IndexDocumentsCommand.php

use Symfony\AI\Store\Document;
use Symfony\AI\Store\StoreInterface;
use Symfony\AI\Platform\EmbeddingsInterface;

final class IndexDocumentsCommand extends Command
{
    public function __construct(
        private readonly StoreInterface $store,
        private readonly EmbeddingsInterface $embeddings,
    ) {
        parent::__construct();
    }

    protected function execute(InputInterface $input, OutputInterface $output): int
    {
        $chunks = $this->loadMarkdownChunks('/docs');

        foreach ($chunks as $chunk) {
            $vector = $this->embeddings->create($chunk->text);
            $this->store->add(new Document(
                content: $chunk->text,
                metadata: ['source' => $chunk->filename],
                vector: $vector,
            ));
        }

        return Command::SUCCESS;
    }
}

Le support MCP (Model Context Protocol) intégré dans le composant Agent est la vraie surprise de l'annonce. Un agent Symfony peut désormais exposer ses tools au format MCP et être consommé par n'importe quel client compatible — Claude Code, une UI Electron, un autre microservice — sans écrire une ligne de protocole custom. C'est la pièce qui transforme un LLM embarqué en surface d'intégration ouverte.

Roadmap et ce qu'on attend pour la suite

• Stabilisation de l'API Platform et Agent (les interfaces peuvent encore changer avant une release stable)
• Drivers Store supplémentaires : Qdrant, Weaviate, Meilisearch
• Intégration au Symfony Profiler pour observer les appels LLM en développement
• Documentation officielle sur symfony.com (en cours au moment de l'annonce)
• Possible intégration dans Symfony 7.4 LTS prévue pour novembre 2025 — non confirmée officiellement à date

L'initiative arrive au bon moment. Claude Sonnet 4 et GPT-4o sont matures, les coûts d'inférence ont chuté, et les équipes PHP cherchent à intégrer de l'IA sans réécrire leur backend. Symfony AI répond à ça avec la philosophie habituelle : composants découplés, bundle d'intégration progressif, abstraction multi-provider. C'est exactement l'outillage qui manquait à l'écosystème PHP pour rivaliser sérieusement avec LangChain ou le SDK Python d'Anthropic.

Tu veux intégrer un LLM ou un agent RAG dans ton application Symfony sans partir d'une page blanche ? Le Bear Scan (audit architecture IA) te livre un plan d'action concret en 48 h — choix du provider, design du Store, sécurisation des appels — avant que tu ne poses la première ligne de code.