J'ai créé mon premier chatbot IA en 3 jours : retour d'expérience

Abdessamad BENALI — Thu, 12 Feb 2026 10:14:43 +0000

Comment un développeur backend sénior a construit et déployé son premier projet IA en un weekend

👋 Introduction

Développeur backend PHP depuis plus de 15 ans, j'ai passé ces dernières années à observer l'IA de loin.

Comme beaucoup, j'utilisais l'IA pour débugger du code ou générer des tests. Pratique, mais passif.

Puis un déclic en janvier 2026 :

Pourquoi ne pas intégrer l'IA directement dans mes applications backend au lieu de juste l'utiliser comme assistant personnel ?

Je me suis posé une question simple : que peut m'apporter l'IA sur mon domaine d'expertise (Symfony, APIs REST, architecture backend) ?

Décision prise : 3 mois pour explorer, expérimenter, et devenir compétent en IA appliquée au backend.

Premier projet : Créer un chatbot fonctionnel en 3 jours.

Pas 3 jours full-time. Plutôt 1-2h par jour sur mon temps libre. L'objectif n'était pas de créer une architecture ultra-optimisée ou un design parfait, mais de comprendre les fondamentaux de l'intégration IA.

Spoiler : Mission accomplie.

Dans cet article, je partage ce parcours de 3 jours : les choix techniques, les blocages et surtout les leçons apprises.

Si vous êtes développeur backend et que l'IA vous intrigue sans savoir par où démarrer, cet article est pour vous.

🎯 Contexte : Pourquoi ce projet ?

Le déclic est venu de mes missions.

Dans la plupart des réunions techniques pour mes clients, face à un problème, quelqu'un lançait en rigolant : "Et si on faisait ça avec l'IA ?"

C'était devenu un running gag.

Le problème ? On ne l'a jamais fait. On parlait d'IA pour des problématiques métier, mais jamais pour l'intégration technique côté backend.

Ma réflexion :

Je développe sur Symfony, PHP, APIs REST, architecture backend depuis 15 ans. L'IA, c'est aussi une API. Une API REST qui prend du texte en entrée et retourne du texte en sortie.

Pourquoi ne pas combiner les deux ?

L'aspect business freelance :

Aujourd'hui, mon positionnement : "Consultant Backend Symfony Senior".

Demain : "Consultant Backend + IA".

La différence ? Ce n'est pas juste monter en compétences. C'est créer de la valeur différenciante sur un marché qui évolue.

Pourquoi un chatbot comme premier projet ?

Simple : je voulais apprendre les fondamentaux sans me perdre dans la complexité.

Un chatbot, c'est :

Un projet cadré (pas de scope infini)
Facile à démontrer (une URL, ça marche)
Focus sur l'essentiel (intégration API IA + backend)

Pas de sur-engineering. Juste l'apprentissage.

🛠️ Stack Technique Choisie

Backend : Symfony 7 + PHP 8.3

J'ai gardé ma stack habituelle. L'objectif était d'apprendre l'IA, pas de réécrire tout mon backend. Symfony 7 et PHP 8.3, c'est ma zone de confort depuis des années.

IA : Google Gemini API (pas OpenAI)

Première tentative : OpenAI GPT-4. Problème : j'ai été bloqué par les coûts dès les premiers tests. Impossible d'expérimenter librement avec une facture potentielle qui grimpe.

Solution : Gemini API de Google. Quotas gratuits très généreux, parfait pour du développement et de l'expérimentation sans stress financier.

Modèle utilisé : gemini-3-flash-preview (modèle texte performant et rapide).

Frontend : Tailwind CSS (via CDN) + Vanilla JS

Je ne suis pas un expert frontend, donc j'ai choisi la simplicité.

Tailwind CSS via CDN : pas de config npm/webpack, juste un lien dans le HTML. Gain de temps massif.

Vanilla JavaScript : pas de framework (React, Vue...), juste des appels API et animations basiques. Pourquoi complexifier quand on peut faire simple ?

Déploiement : Docker + Render.com + GitHub Actions

Une fois le projet fonctionnel en local, il fallait le déployer.

Render.com offre un tier gratuit avec support Docker. Configuration simple, détection automatique de la stack.

J'ai créé un Dockerfile, connecté mon repo GitHub, et configuré le déploiement automatique via GitHub Actions : à chaque push sur main, l'app se redéploie.

Le principe directeur : minimiser la friction technique pour maximiser l'apprentissage IA.

📅 Jour 1 : Découverte et Setup

Matin : Découverte des APIs IA (1-2h)

Je ne voulais pas perdre de temps sur la théorie. Mon objectif : comprendre comment appeler une API IA en moins de 2 heures.

Première tentative : OpenAI

J'ai ouvert la documentation OpenAI. Après 15 minutes de lecture, le constat était clair : coûts élevés, limitations strictes, gestion de crédits complexe.

Pour expérimenter librement, ce n'était pas envisageable.

Pivot vers Gemini API

J'ai basculé sur Google Gemini. Documentation claire, quotas gratuits généreux. Exactement ce qu'il me fallait.

Tests avec Postman

Une fois le principe compris, j'ai lancé Postman pour tester :

Appel simple question-réponse
Passage de contexte dans le prompt
Variations de paramètres (temperature, tokens)

Après 2-3 tests, j'avais compris l'essentiel.

⚠️ Difficulté rencontrée #1 : Limitation de modèle

Problème : J'avais d'abord utilisé un modèle Gemini récent, mais j'ai rapidement été bloqué par la limite d'appels gratuits.

Solution : Je suis passé à un modèle beaucoup plus généreux en quotas (gemini-3-flash-preview).

Temps perdu : 20 minutes de recherche dans la doc.

Leçon : Toujours vérifier les quotas avant de choisir un modèle.

Après-midi : Setup Symfony

Une fois l'API IA comprise, j'ai initialisé mon environnement backend.

symfony new ai-chatbot --version=7.1
cd ai-chatbot
composer require symfony/http-client

Configuration minimaliste : juste ce qu'il faut pour faire des appels HTTP et gérer les réponses.

Pas de database, pas de complexité inutile. L'objectif était l'IA, pas l'architecture.

✅ Ce que j'ai appris Jour 1

L'IA c'est aussi des APIs REST classiques (rien de magique)
Gemini gratuit > OpenAI payant pour expérimenter
Postman est parfait pour tester avant d'intégrer
Toujours vérifier les quotas des modèles

📅 Jour 2 : Intégration Backend

Matin : Architecture API

Objectif du jour : intégrer Gemini dans Symfony.

J'ai créé un contrôleur API simple. Pas d'architecture complexe, pas de sur-engineering. Juste un controller avec 3 endpoints.

Endpoint 1 : /api/chat/test

Test de disponibilité du service. J'envoie un prompt simple à Gemini, je vérifie que la connexion fonctionne.

#[Route('/api/chat/test', methods: ['GET'])]
public function test(): JsonResponse
{
    $result = $this->geminiService->testConnection();
    return $this->json(['status' => $result ? 'ok' : 'error']);
}

Endpoint 2 : /api/chat

Chat basique : une question, une réponse.

#[Route('/api/chat', methods: ['POST'])]
public function chat(Request $request): JsonResponse
{
    $message = $request->request->get('message');
    $response = $this->geminiService->generateText($message);
    return $this->json(['response' => $response]);
}

Ça marchait, mais les réponses étaient génériques.

Après-midi : Le Game Changer - Le Contexte

Endpoint 3 : /api/chat/context

C'est là que tout a changé.

Au lieu d'envoyer juste la question de l'utilisateur, j'envoie également un contexte sur mon profil :

$context = "
Je suis Abdessamad Benali, développeur Backend Symfony 15 ans.
TJM actuel : 500€, TJM cible : 750€+.
Compétences : PHP, Symfony, APIs REST, IA...
";

$fullPrompt = $context . "\n\nQuestion : " . $message;
$response = $this->geminiService->generateText($fullPrompt);

Résultat ?

Les réponses sont passées de génériques à ultra-personnalisées.

Question : "Quel est ton TJM ?"

Avant (sans contexte) : "Je ne peux pas répondre à cette question personnelle."

Après (avec contexte) : "Mon TJM actuel est de XXX€/jour..."

C'était le déclic.

Le contexte transforme une IA générique en assistant personnalisé.

Gestion technique

J'ai ajouté :

Gestion des erreurs (try/catch sur appels API)
Logs basiques (chaque appel tracé)
Commits Git réguliers (après chaque endpoint fonctionnel)

✅ Ce que j'ai appris Jour 2

Le contexte fait toute la différence en IA
Un bon prompt = contexte + question
Symfony + IA = juste un service comme un autre
Garder l'architecture simple permet d'avancer vite

📅 Jour 3 : Frontend et Déploiement

Matin : Interface Chat

Backend fonctionnel, place au frontend.

Problème : je ne suis pas expert frontend. Solution : rester simple.

Structure HTML + Tailwind CSS

J'ai d'abord posé la structure visuelle :

Zone de messages (scrollable)
Input utilisateur
Bouton d'envoi
Design avec Tailwind (gradients, ombres, animations)

Une fois le design acceptable, j'ai attaqué le JavaScript.

JavaScript : Appels API

Premier jet ultra-simple :

form.addEventListener('submit', async (e) => {
    e.preventDefault();
    const message = input.value;

    const response = await fetch('/api/chat/context', {
        method: 'POST',
        body: JSON.stringify({ message })
    });

    const data = await response.json();
    console.log(data.response); // Affichage console d'abord
});

Tests dans la console pour valider. Ça marchait.

Ensuite, intégration dans le DOM pour afficher les messages dans l'interface.

Après-midi : Polish et Déploiement

Améliorations visuelles

J'ai ajouté :

Loader pendant l'attente de réponse
Suggestions rapides (boutons pré-remplis)
Animations d'apparition des messages
Heures d'envoi

Design simple mais propre.

Déploiement : Le défi

Application fonctionnelle en local. Il fallait la déployer.

Recherche d'un hébergeur gratuit supportant PHP. J'ai trouvé Render.com.

Problème : Render préfère Docker pour les stacks custom.

Solution rapide : j'ai créé un Dockerfile basique :

FROM php:8.3-cli
COPY . /app
RUN composer install
CMD php -S 0.0.0.0:8080 -t public

Configuration sur Render, connexion GitHub, et... déployé en 10 minutes !

URL live accessible : le chatbot était en production.

Soir : Tests Utilisateurs

J'ai fait tester à 2 amis avec des profils différents, pour avoir un feedback technique et business.

"C'est super cool, mais tu devrais vraiment mettre un lien vers ton portfolio dans les réponses !" - "C'est génial pour la tech, mais ça manque d'impact business. Comment ça va m'aider à vendre ?"

Leçon : Les feedbacks, même durs, sont essentiels pour progresser.

✅ Ce que j'ai appris Jour 3

Tailwind CSS via CDN = gain de temps massif
Vanilla JS suffit pour un projet simple
Docker simplifie le déploiement
Les vrais feedbacks (même durs) sont précieux
Projet d'apprentissage ≠ projet de vente

💡 Top 5 Leçons Apprises

1. L'IA c'est aussi une API REST

Avant de commencer, je me faisais des idées complexes sur l'IA. Data science, maths, Python obligatoire...

Réalité : L'IA, c'est aussi une API REST.

Une fois la documentation ouverte, j'ai compris : on envoie du texte en POST, on reçoit du texte en réponse. Comme n'importe quelle API que je consomme depuis 15 ans.

Si vous savez consommer une API REST, vous savez utiliser l'IA.

2. Le contexte fait TOUTE la différence

Sans contexte : réponses génériques et inutiles.

Avec contexte : réponses personnalisées et pertinentes.

Le prompt n'est pas juste une question. C'est contexte + question.

Le contexte, c'est votre "base de données temporaire". Plus il est précis, meilleures sont les réponses.

La qualité de vos réponses dépend de la qualité de votre contexte.

3. Shipping > Perfection

J'aurais pu passer 2 semaines à perfectionner l'architecture, optimiser le design, ajouter des features.

Au lieu de ça : 3 jours pour livrer.

Résultat :

Projet live et fonctionnel
Feedbacks utilisateurs réels
Apprentissage validé
Confiance boostée

Mieux vaut shipped imparfait que parfait non-livré.

4. Commencer simple, itérer ensuite

Pas d'architecture complexe. Pas de sur-engineering. Pas de "et si on ajoutait ça ?".

Approche :

Version 1 : Un controller, 3 routes, ça marche.
Version 2 : Ajout contexte.
Version 3 : Frontend basique.
Version 4 : Déploiement.

Chaque étape = petite victoire. Chaque victoire = motivation pour continuer.

Itération > Perfection dès le départ.

5. Déployer tôt = Feedbacks précieux

Garder son projet en local = zéro validation.

Le déployer = feedbacks réels.

Mes 2 testeurs m'ont donné des retours que je n'aurais jamais eus seul, des idées d'amélioration, une critique constructive (focus business vs tech).

Ces feedbacks ont plus de valeur que 10h de développement en isolation.

Déployer = apprendre. Apprendre = progresser.

🎯 Conclusion

Ce que j'ai fait en 3 jours :

✅ Intégré l'IA dans un projet backend concret
✅ Créé un chatbot fonctionnel et déployé
✅ Obtenu des feedbacks utilisateurs réels
✅ Validé que c'est accessible (pas besoin d'être data scientist)

Ce que je n'ai PAS fait :

❌ Une architecture parfaite
❌ Un design award-winning
❌ Devenu expert IA du jour au lendemain

Mais ce n'était pas l'objectif.

L'objectif était de démontrer qu'avec une solide expérience backend, on peut intégrer l'IA rapidement sur des cas concrets.

Pas besoin d'années d'étude. Juste 3 jours pour comprendre les fondamentaux et livrer quelque chose de fonctionnel.

Et maintenant ?

Ce chatbot était mon projet d'apprentissage. Le prochain sera différent : un projet métier avec ROI mesurable et besoin business réel.

Parce que la vraie valeur de l'IA, ce n'est pas la technologie. C'est l'impact business qu'elle génère.

Et vous ?

Si vous êtes développeur backend et que l'IA vous intrigue, lancez-vous. Choisissez un petit projet, donnez-vous 3 jours, et livrez.

Vous serez surpris de ce que vous pouvez accomplir.

Des retours ? Des questions ? Une expérience similaire à partager ? Les commentaires sont ouverts, j'ai hâte d'en discuter avec vous !

🔗 Liens et Contact

Demo live du chatbot - Testez-le vous-même !
Code source GitHub - Projet open source
LinkedIn - Connectons-nous !
Mon portfolio

NB : Pour la démo, étant sur un plan gratuit, le site est mis en pause si pas d'activité pendant 15 min. Il suffit d'attendre que le service redémarre (quelques secondes)

📚 Ressources Utiles

Documentation

Publié le 12/02/2026 par Abdessamad Benali

Si cet article vous a été utile, n'hésitez pas à le partager avec d'autres développeurs qui hésitent à se lancer dans l'IA !

DEV Community: Abdessamad BENALI