🤖 Symfony AI in Action - Construire des systèmes IA réels avec Symfony

le 24 avril 2026

Pendant deux jours, les 23 et 24 avril 2026, la conférence SymfonyLive Berlin a rassemblé la communauté autour des évolutions majeures de l’écosystème Symfony.

Parmi les talks, un en particulier marque un tournant :

👉 Symfony AI in Action, présenté par Christopher Hertel.

• 🎥 Slides : https://speakerdeck.com/chr_hertel/symfony-ai-in-action-symfonylive-berlin-2026
• 🧠 Symfony AI : https://ai.symfony.com
• 🛠️ Support utilisé pour cet article : https://slidewire.dev

Cet article ne résume pas la conférence. Il propose une lecture Darkwood de ce qui est en train de se passer.

Le vrai sujet : arrêter de penser “chatbot”

Aujourd’hui, beaucoup d’intégrations IA se limitent à ça :

écrire un prompt → appeler un modèle → afficher une réponse

C’est insuffisant.

Le problème réel, en production, est ailleurs :

• orchestrer plusieurs modèles
• gérer le contexte et la mémoire
• exposer des actions (tools)
• contrôler les coûts et les logs
• intégrer le tout dans une architecture métier

👉 Symfony AI ne propose pas un chatbot. 👉 Symfony AI propose une stack complète.

Symfony AI : une stack, pas une feature

L’objectif est clair :

“Enable AI features, not only LLMs.”

Symfony AI introduit plusieurs briques fondamentales :

• Platform → abstraction des modèles
• Agent → boucle LLM + tools
• Store → embeddings & RAG
• AI Bundle → intégration Symfony
• MCP Bundle / SDK → exposition de tools

👉 On passe d’un appel API… à une architecture IA complète.

Platform : abstraction des modèles

Premier problème classique :

OpenAI, Claude, Gemini, Mistral → APIs différentes

Symfony AI introduit une abstraction unique.

$platform->invoke('gpt-5-mini', $input);

Même code, différents providers.

Pourquoi c’est clé

• changer de modèle sans refactor
• optimiser les coûts
• fallback multi-provider
• intégrer local + remote

👉 Symfony devient une couche d’orchestration des modèles.

Streaming & multimodal

Symfony AI va plus loin que le simple texte :

• streaming de tokens en temps réel
• audio, image, PDF
• output binaire

Exemples :

• analyser un PDF
• décrire une image
• traiter un audio
• générer des fichiers

👉 L’IA devient une brique applicative multimodale.

Structured Output : reprendre le contrôle

Problème classique :

les LLM retournent du texte… pas des données fiables

Symfony AI introduit des réponses typées :

$response_format => MyDTO::class

Résultat :

• objets PHP exploitables
• validation stricte
• intégration directe au métier

👉 On passe de “texte généré” à données contrôlées.

Agent : connecter le LLM à ton application

Un agent, c’est :

un modèle qui peut appeler ton code

Avec Symfony AI :

#[AsTool('create_recipe')]

Tu exposes ton métier comme un tool.

Ce que ça change

Avant :

• LLM isolé

Après :

• LLM + accès à ton système

👉 L’IA devient exécutable.

Human in the loop : sécurité

Point critique souvent oublié :

une IA ne doit pas tout faire automatiquement

Symfony AI permet de :

• intercepter un tool call
• demander validation
• bloquer ou autoriser

Exemple :

• publier un article
• déclencher une action critique

👉 Tu gardes le contrôle.

Memory : contextualiser

Les agents ne fonctionnent pas sans contexte.

Symfony AI permet de :

• injecter des données utilisateur
• gérer des profils
• stocker de l’historique
• contrôler les permissions

👉 L’IA devient contextuelle et personnalisée.

Store & RAG : connecter tes données

Pipeline :

1. loading
2. filtering
3. transforming
4. vectorizing

👉 Tu construis une base vectorielle.

Ensuite :

• requête utilisateur
• recherche dans le store
• enrichissement du prompt

👉 C’est le RAG (Retrieval Augmented Generation).

Impact réel

• FAQ intelligente
• moteur de recherche métier
• copilote interne
• assistant documenté

👉 Tu branches l’IA sur ta connaissance métier.

Multi-agents : spécialisation

Architecture avancée :

• agent principal
• sub-agents spécialisés
• orchestration
• partage ou isolation de contexte

Exemple :

• agent support
• agent technique
• agent billing

👉 Chaque agent a un rôle.

MCP : exposer ton système

Symfony AI s’inscrit dans un mouvement plus large :

👉 le protocole MCP

Objectif :

• exposer tes tools
• rendre ton système interrogeable
• standardiser les interactions IA

👉 Ton application devient un serveur d’intelligence.

Le vrai tournant : l’orchestration

Le point le plus important n’est pas :

• les modèles
• les prompts
• les agents

👉 Le vrai sujet est l’orchestration.

Questions clés :

• qui appelle quoi ?
• avec quel contexte ?
• sous quelles permissions ?
• avec quelle traçabilité ?
• comment reprendre la main ?

L’approche Darkwood

Chez Darkwood, la réponse est claire :

Stack proposée

• Symfony AI → briques IA
• MCP → exposition des tools
• Flow → orchestration
• Navi → exécution + tracing
• Uniflow → interface

Pourquoi cette stack

Symfony AI donne :

• les modèles
• les agents
• les tools
• le RAG

Mais il manque :

• orchestration métier
• contrôle global
• visibilité complète

👉 C’est là qu’interviennent Flow et Navi.

Ce que ça change concrètement

Avant :

• scripts IA isolés
• prompts fragiles
• peu de contrôle

Après :

• système orchestré
• exécution traçable
• logique métier intégrée

👉 On passe de “jouer avec l’IA” à construire des systèmes fiables.

Conclusion

Symfony AI marque une évolution majeure :

tu ne construis plus un chatbot tu construis une feature IA complète

Aujourd’hui, tu as :

• une abstraction des modèles
• des agents connectés à ton code
• un système de mémoire
• du RAG intégré
• une base pour orchestrer

👉 Tu n’as plus d’excuse.

Pour aller plus loin

• Symfony AI : https://ai.symfony.com
• Slides de Christopher Hertel : https://speakerdeck.com/chr_hertel/symfony-ai-in-action-symfonylive-berlin-2026
• Le support technique qui m'a permis de générer les slides - Slidewire : https://slidewire.dev

Darkwood

• Navi → exécution & tracing
• Flow → orchestration
• Uniflow → interface

👉 Articles à venir pour implémentations concrètes.