Symfony AI : Quand l’intelligence artificielle devient native dans vos applications

Symfony AI est un ensemble de composants et de bundles, lancé par le projet Symfony en juillet 2025, pour intégrer des modèles d’IA dans une application PHP : appel unifié aux fournisseurs (OpenAI, Anthropic, Mistral, Gemini, modèles auto-hébergés…), agents capables d’appeler vos outils métier, recherche documentaire (RAG) et protocole MCP. En septembre 2026, il est en version 0.14 et reste expérimental : utilisable en production, à condition de le traiter comme une dépendance qui bouge encore.

Dans cet article, nous faisons le point sur ce qu’il contient, ce que son statut implique, un exemple de code complet et la place de MCP. C’est la base sur laquelle nous conseillons nos clients qui ont une application Symfony et veulent y ajouter de l’IA.

Ce que contient Symfony AI en 2026

Symfony AI vit dans son propre dépôt (symfony/ai), séparé du framework, pour suivre le rythme de l’écosystème IA. Il reprend le travail de l’organisation PHP-LLM et compte aujourd’hui plus de 90 paquets. Une équipe dédiée, la Symfony AI Core Team, en assure la maintenance.

L’intérêt principal est la couche Platform : votre code parle à une interface, et le fournisseur se choisit dans la configuration. Passer de Mistral à Anthropic, ou d’une API publique à un modèle hébergé chez vous, revient à changer quelques lignes de YAML, puis à vérifier sur vos jeux d’évaluation que la qualité des réponses tient. Les prompts, eux, se réajustent souvent d’un modèle à l’autre.

Un statut expérimental : ce que cela implique

La première version taguée, 0.1.0, date de décembre 2025. Depuis, une version mineure sort à peu près chaque mois (0.14 fin septembre 2026), avec un guide de migration à chaque fois. Les composants sont marqués expérimentaux : ils ne sont pas couverts par la promesse de rétrocompatibilité de Symfony. Autrement dit, la maintenance n’est pas « gérée par le framework » : c’est à votre équipe de suivre les évolutions.

Nos règles pour l’utiliser en production :

• Fixer les versions : une contrainte ^0.14 dans Composer bloque la version mineure. On ne monte de version qu’après lecture du fichier UPGRADE.md.
• Isoler l’IA derrière vos propres interfaces (par exemple un SupportAssistant), pour que le reste de l’application ne dépende pas de l’API de Symfony AI.
• Tester : tests unitaires des outils, tests d’intégration de l’agent avec un modèle simulé, et jeux d’évaluation sur des questions réelles pour mesurer la qualité à chaque changement de modèle ou de version.
• Suivre les coûts : l’AI Bundle remonte l’usage des tokens dans les métadonnées de chaque réponse. Branchez-le sur votre supervision.

Exemple : un agent de support qui consulte vos commandes

Le cas le plus courant : un assistant qui répond aux clients à partir de données réelles, sans leur donner accès à la base. Installation avec Mistral comme fournisseur :

composer require symfony/ai-bundle symfony/ai-agent symfony/ai-mistral-platform

La configuration déclare le fournisseur, puis un agent avec son prompt système et ses outils. Depuis les dernières versions, les outils sont explicites : un agent n’a accès qu’aux outils listés.

# config/packages/ai.yaml
ai:
    platform:
        mistral:
            api_key: '%env(MISTRAL_API_KEY)%'
    agent:
        support:
            platform: 'ai.platform.mistral'
            model: 'mistral-small-latest'
            prompt:
                text: 'Tu es l’assistant du support client. Réponds uniquement à partir des informations renvoyées par tes outils. Si tu ne sais pas, dis-le.'
            tools:
                - 'App\Ai\Tool\OrderStatus'

L’outil est une classe PHP ordinaire. Le point clé : c’est votre code qui applique les droits. Le modèle ne voit jamais la base de données, il ne reçoit que ce que l’outil lui renvoie, ici les commandes de l’utilisateur connecté.

namespace App\Ai\Tool;

use App\Repository\OrderRepository;
use Symfony\AI\Agent\Toolbox\Attribute\AsTool;
use Symfony\Bundle\SecurityBundle\Security;

#[AsTool('order_status', 'Donne le statut d’une commande du client connecté à partir de sa référence')]
final readonly class OrderStatus
{
    public function __construct(
        private OrderRepository $orders,
        private Security $security,
    ) {
    }

    /**
     * @param string $reference Référence de la commande, par exemple CMD-2026-0042
     */
    public function __invoke(string $reference): array
    {
        $order = $this->orders->findOneBy([
            'reference' => $reference,
            'customer' => $this->security->getUser(),
        ]);

        if (null === $order) {
            return ['found' => false];
        }

        return [
            'found' => true,
            'status' => $order->getStatus()->value,
            'shippedAt' => $order->getShippedAt()?->format('Y-m-d'),
        ];
    }
}

Enfin, un service de votre application appelle l’agent :

namespace App\Support;

use Symfony\AI\Agent\AgentInterface;
use Symfony\AI\Platform\Message\Message;
use Symfony\AI\Platform\Message\MessageBag;
use Symfony\Component\DependencyInjection\Attribute\Autowire;

final readonly class SupportAssistant
{
    public function __construct(
        #[Autowire(service: 'ai.agent.support')]
        private AgentInterface $agent,
    ) {
    }

    public function answer(string $question): string
    {
        $result = $this->agent->call(new MessageBag(Message::ofUser($question)));

        return $result->getContent();
    }
}

Quand un client demande « Où en est ma commande CMD-2026-0042 ? », le modèle décide d’appeler order_status, l’agent exécute la méthode PHP, renvoie le résultat au modèle, qui rédige la réponse. La description de l’outil et le commentaire @param servent à générer le schéma que le modèle lit : ils méritent le même soin qu’une documentation d’API.

Pour un vrai service, on ajoute : une confirmation humaine avant toute action qui modifie des données, des limites d’usage, la journalisation des appels d’outils, et des questions de test qui couvrent les cas « je ne sais pas ». Pour répondre à partir de votre documentation, le composant Store ajoute la recherche documentaire : c’est le principe du RAG.

MCP : à quoi il sert, et à quoi il ne sert pas

Le Model Context Protocol (MCP) est un protocole ouvert qui standardise la façon dont un client IA (un assistant comme Claude ou ChatGPT, un IDE, vos propres agents) découvre et appelle les outils, ressources et prompts exposés par un serveur MCP. Il ne sert pas à changer de fournisseur de modèle : c’est le rôle de la couche Platform.

Le MCP Bundle couvre deux usages :

1. Exposer votre application comme serveur MCP, en STDIO ou en HTTP. Vos équipes ou vos clients peuvent alors interroger votre application depuis leur assistant IA.
2. Consommer des serveurs MCP existants depuis vos agents : dans la configuration de l’agent, une entrée mcp_server ajoute les outils d’un serveur distant à ceux de l’agent.

Un outil MCP se déclare lui aussi par attribut :

namespace App\Mcp;

use App\Repository\ProductRepository;
use Mcp\Capability\Attribute\McpTool;
use Mcp\Capability\Attribute\Schema;

final class ProductStockTool
{
    public function __construct(private ProductRepository $products)
    {
    }

    #[McpTool(name: 'product-stock', description: 'Stock disponible pour une référence produit')]
    public function __invoke(
        #[Schema(description: 'Référence produit (SKU)')]
        string $sku,
    ): array {
        $product = $this->products->findOneBy(['sku' => $sku]);

        return ['sku' => $sku, 'available' => $product?->getStock() ?? 0];
    }
}

Un serveur MCP expose des actions sur votre système d’information : il se traite comme une API publique, avec authentification, droits par outil et journalisation. C’est ce que nous mettons en place dans nos projets de serveur MCP.

Quand choisir Symfony AI, Neuron AI ou un SDK direct

• Symfony AI : votre application est en Symfony, vous voulez pouvoir changer de fournisseur, vous avez besoin d’outils, de RAG ou de MCP, et vous acceptez de suivre les montées de version.
• Neuron AI : un framework d’agents PHP indépendant du framework web, utile si votre application n’est pas en Symfony ou si vous l’utilisez déjà.
• Le SDK du fournisseur : un appel simple (résumé, classification, extraction) vers un seul fournisseur. Moins de dépendances, mais un changement de fournisseur coûte plus cher.

Quel que soit le choix, deux règles ne changent pas : l’IA reste derrière une interface de votre code, et la qualité se mesure avec des jeux d’évaluation, pas à l’impression.

Ce qu’il faut prévoir avant de se lancer

Symfony AI réduit le code d’intégration. Il ne remplace pas le travail qui fait qu’un service IA tient en production :

• Des données propres et des droits clairs : un agent n’est pas plus fiable que les outils et documents qu’on lui donne.
• Une évaluation continue : un agent ne s’améliore pas seul en répondant. Il progresse quand l’équipe ajuste prompts, outils, données ou modèle, à partir des retours utilisateurs et des jeux de test.
• La maîtrise des coûts : cache des réponses quand c’est pertinent, choix d’un modèle léger pour les tâches simples et d’un modèle plus puissant pour les autres, bascule automatique vers un second fournisseur en cas d’indisponibilité, suivi des tokens.
• La confidentialité : avec les offres API et entreprise des principaux fournisseurs, vos données ne servent pas à l’entraînement par défaut. Si elles ne doivent pas sortir de chez vous, Symfony AI sait appeler un modèle auto-hébergé.

Comment nous vous accompagnons

Nous concevons, développons et maintenons des applications métier et des fonctions IA, en Symfony notamment.

Sur un projet Symfony AI, notre lead technique porte l’architecture, fait les revues de code et reste votre interlocuteur technique. Nos équipes appliquent le même standard que sur le reste de l’application : revue de code systématique, tests automatisés, intégration continue, gestion des secrets, environnements séparés, et pour l’IA, jeux d’évaluation et suivi de la qualité et des coûts. Votre code, vos accès, vos clés d’API : tout reste à vous.

Selon votre besoin :

• ajouter un assistant ou un agent à votre service client ou à vos outils internes : agents IA et chatbots ;
• intégrer recherche intelligente, extraction ou synthèse dans votre produit : fonctionnalités IA pour votre produit ;
• rendre votre application accessible aux assistants IA : serveur MCP ;
• faire passer un prototype en production : reprise de POC IA ;
• moderniser ou faire évoluer l’application elle-même : développement Symfony.

Vous avez une application Symfony et un cas d’usage IA en tête ? Parlons-en : nous regardons avec vous si Symfony AI est le bon outil, et comment l’intégrer proprement.

FAQ