Comment devenir ingénieur en IA en 6 mois (RESSOURCES)

Le génie logiciel en IA est rapidement devenu l'un des ensembles de compétences les plus précieux dans le secteur technologique

Le problème, c'est que la plupart des débutants n'ont aucune idée précise de ce qu'ils devraient réellement étudier

Certains commencent par la théorie de l'apprentissage automatique

D'autres restent bloqués à regarder des tutoriels sans fin

D'autres encore sautent directement dans les prompts et les agents sans comprendre les API, les bases du backend ou la façon dont les vrais produits sont réellement construits

Le résultat est généralement le même : beaucoup de confusion et très peu de compétences pratiques

Si votre objectif est de devenir ingénieur IA, vous n'avez pas besoin de maîtriser tous les domaines de l'intelligence artificielle

Vous devez apprendre à construire des systèmes IA utiles dans le monde réel

Cela signifie apprendre à :

• construire des applications de bout en bout avec les LLM
• travailler avec des API de modèles comme OpenAI et Anthropic
• concevoir correctement des prompts et du contexte
• utiliser des sorties structurées et l'appel d'outils
• ajouter de la récupération quand c'est nécessaire
• déployer des projets pour que les gens puissent réellement les utiliser

Ce guide a été créé pour vous donner une feuille de route pratique sur 6 mois

L'article fait plus de 10 000 MOTS, donc sa lecture peut prendre quelques heures, voire plus

Mais sa vraie valeur est que pour chaque compétence que vous devez apprendre, il y a des ressources et des explications claires sur ce qu'il faut faire

Ainsi, en six mois, vous pouvez atteindre le niveau d'ingénieur IA, et commencer à l'utiliser par vous-même dès les 1 à 2 premiers mois

Écrire cet article a pris plus de 40 HEURES, et j'y ai travaillé avec mon ami @andy_ai0

Il vient de commencer à construire sa marque personnelle sur X, mais il comprend très bien l'IA et a beaucoup aidé pour cet article

Je pense vraiment qu'il mérite votre suivi et votre soutien pendant qu'il grandit

Commençons maintenant à lire l'article ⬇️

Ce que fait réellement un ingénieur IA

Beaucoup de gens entendent l'expression « ingénieur IA » et imaginent quelqu'un qui entraîne des modèles géants à partir de zéro

En réalité, la plupart des ingénieurs IA modernes font quelque chose de beaucoup plus pratique

Ils construisent des produits et des systèmes sur la base de modèles existants

Cela inclut généralement :

• la connexion aux API LLM
• la conception des prompts et des flux de contexte
• la construction de systèmes de chat, de recherche ou d'automatisation
• l'intégration d'outils, de bases de données et d'API externes
• la gestion des sorties structurées
• l'amélioration de la fiabilité, du coût et de la latence
• le déploiement de fonctionnalités IA dans des applications réelles

Donc, en pratique, un ingénieur IA se situe souvent entre :

• le génie logiciel
• l'ingénierie produit
• l'automatisation
• l'IA appliquée

C'est pourquoi ce rôle se développe si rapidement

Les entreprises n'ont pas seulement besoin de chercheurs

Elles ont besoin de personnes capables de prendre des modèles et de les transformer en produits utiles

C'est aussi pourquoi cette feuille de route se concentre moins sur la théorie lourde et plus sur l'exécution pratique

Si vous pouvez construire de vraies applications LLM, des systèmes de récupération, des automatismes et des workflows prêts pour la production, vous êtes déjà bien plus proche d'être employable que la plupart des débutants

⏩------------------------------------------------------------------------⏪

Mois 1 : Acquérir de solides bases en programmation et les fondamentaux

Votre objectif ce mois-ci : Devenir un développeur Python fonctionnel

Vous n'avez pas besoin d'être un expert, vous devez juste arrêter de chercher la syntaxe de base sur Google et être capable de construire des programmes simples en toute confiance

L'ingénierie IA est avant tout du génie logiciel

Tout dans les mois suivants suppose que vous pouvez écrire du Python propre, utiliser le terminal, appeler des API et gérer une base de code. Ce mois-ci est votre fondation

Ce qu'il faut apprendre

1. Python

Python est le langage de l'ingénierie IA. Point final. Presque toutes les bibliothèques, API et tutoriels que vous rencontrerez au cours des six prochains mois sont en Python

Comment l'apprendre :

Commencez par un cours structuré qui vous oblige à écrire du code, pas seulement à regarder des vidéos

L'erreur la plus courante que font les débutants est de consommer du contenu passivement, de lire en suivant, d'acquiescer et de ne jamais ouvrir un éditeur de code

Luttez contre cela en codant chaque exemple au fur et à mesure

Ressources :

1. Python for Everybody (Coursera, gratuit en audit)

Lien : https://www.coursera.org/specializations/python

Le meilleur point de départ pour les débutants absolus. Dr. Chuck est l'un des professeurs de Python les plus accessibles sur Internet

2. freeCodeCamp Python Course (YouTube, gratuit)

Lien : https://www.youtube.com/watch?v=rfscVS0vtbw

Une vidéo complète de 4 heures couvrant tous les fondamentaux

3. CS50P : Introduction à la programmation avec Python (Harvard, gratuit)

Lien : https://cs50.harvard.edu/python/

Plus rigoureux. Inclut des séries de problèmes et un projet final. Idéal si vous voulez de la structure

4. Documentation officielle Python (le tutoriel)

Lien : https://docs.python.org/3/tutorial/

Aride mais faisant autorité, utilisez-la comme référence

Ce sur quoi se concentrer :

• Variables, types de données, boucles, conditions, fonctions
• Listes, dictionnaires, ensembles, tuples
• Entrées/sorties de fichiers et travail avec JSON
• Classes et POO de base (juste assez pour comprendre ce que vous lisez)
• Gestion des erreurs avec try/except
• Environnements virtuels (venv) et pip
• Gestion des paquets – comprendre requirements.txt

Projet pratique : Construisez un outil CLI simple en Python. Quelque chose comme un suivi de dépenses personnel qui lit/écrit dans un fichier JSON, ou un script qui appelle une API publique (comme une API météo) et imprime les résultats formatés

2. Git et GitHub

Git est la façon dont les développeurs professionnels sauvegardent et partagent le code. Vous en aurez constamment besoin, pour versionner vos projets, collaborer et présenter votre travail sur GitHub

Comment l'apprendre :

Git est déroutant au début car le modèle mental n'est pas évident

N'essayez pas de mémoriser les commandes, comprenez plutôt le problème que Git résout

(suivi des modifications, collaboration, possibilité d'annuler les erreurs) et les commandes auront du sens

Ressources :

1. GitHub Skills (gratuit, interactif)

Lien : https://skills.github.com/

Cours interactifs officiels intégrés à GitHub. Commencez ici

2. Learn Git Branching (gratuit, interactif)

Lien : https://learngitbranching.js.org/

De loin le meilleur outil visuel pour comprendre les branches et les fusions

3. Pro Git Book (livre en ligne gratuit)

Lien : https://git-scm.com/book/en/v2

La référence complète. Passez aux chapitres dont vous avez besoin

Ce sur quoi se concentrer :

• git init, add, commit, push, pull
• Branches et fusions
• Comprendre .gitignore
• Créer des dépôts sur GitHub et pousser des projets locaux
• Lire et écrire des fichiers README de base

Pratique : À partir de maintenant, chaque projet que vous construisez, même les petits scripts, doit vivre dans un dépôt GitHub. Cela crée l'habitude et vous donne un portfolio

3. Notions de base du CLI / Terminal

En tant qu'ingénieur IA, vous allez exécuter des scripts, installer des paquets, gérer des serveurs et naviguer dans les fichiers entièrement depuis la ligne de commande

Être lent ou effrayé dans le terminal est un véritable goulot d'étranglement

Ressources :

1. Les 50 commandes Linux et Terminal les plus populaires (cours complet pour débutants)

Lien : https://www.youtube.com/watch?v=ZtqBQ68cfJc

Bon pour les débutants absolus sous Linux/Mac

2. The Missing Semester of Your CS Education (MIT, gratuit)

Lien : https://missing.csail.mit.edu/

Couvre les scripts shell, les outils de terminal et la maîtrise de la ligne de commande que la plupart des cours d'informatique omettent

Ce sur quoi se concentrer :

• Navigation : cd, ls, pwd, mkdir, rm
• Lecture de fichiers : cat, less, grep
• Exécution de scripts Python depuis le terminal
• Variables d'environnement
• Compréhension basique de PATH

4. JSON, API, HTTP et notions de base asynchrones

Vous allez appeler des API LLM dès le premier jour du mois 2

Cela signifie que vous devez comprendre comment les API web fonctionnent avant de toucher aux SDK OpenAI ou Anthropic

Ressources :

1. Notions de base HTTP – MDN Web Docs (gratuit)

Lien : https://developer.mozilla.org/fr/docs/Web/HTTP/Overview

L'explication la plus claire du fonctionnement des requêtes et réponses HTTP

2. Tutoriel API REST

Lien : https://restfulapi.net/

Court et pratique

3. Documentation de la bibliothèque Python requests

Lien : https://requests.readthedocs.io/fr/latest/

Apprenez à appeler n'importe quelle API web en Python

4. Python async/await (gratuit)

Lien : https://realpython.com/async-io-python/

Comprendre l'async est essentiel pour travailler plus tard avec des réponses LLM en streaming

Ce sur quoi se concentrer :

• Requêtes GET, POST – ce qu'elles sont et comment les faire en Python
• Lire et écrire du JSON
• Codes de statut HTTP (200, 400, 401, 404, 500 – ce que chacun signifie)
• Ce qu'est une clé API et les modèles d'authentification de base
• Ce que async def et await font et pourquoi ils existent

Projet pratique : Écrivez un script Python qui appelle une API publique gratuite (essayez Open-Meteo pour les données météo – pas besoin de clé API) et formatez le résultat comme une sortie JSON propre

5. SQL de base et Pandas

Vous n'aurez pas besoin d'être un data scientist, mais vous devrez régulièrement inspecter, interroger et manipuler des données

Les bases de SQL et la maîtrise de pandas vous feront gagner un temps considérable

Ressources :

1. SQLBolt (gratuit, interactif)

Lien : https://sqlbolt.com/

Le moyen le plus rapide d'apprendre SQL à partir de zéro. 20 courtes leçons avec des exercices dans le navigateur

2. Guide officiel de démarrage de Pandas

Lien : https://pandas.pydata.org/docs/getting_started/index.html

Parcourez le tutoriel « 10 Minutes to Pandas »

3. Cours Kaggle Pandas (gratuit)

Lien : https://www.kaggle.com/learn/pandas

Pratique, concret, court

Ce sur quoi se concentrer :

• SQL : SELECT, WHERE, GROUP BY, JOIN, ORDER BY
• Pandas : chargement de CSV, filtrage de lignes, sélection de colonnes, agrégations de base

6. FastAPI

Ressources :

1. Tutoriel officiel FastAPI (gratuit)

Lien : https://fastapi.tiangolo.com/tutorial/

Véritablement l'une des meilleures documentations de framework jamais écrites

Parcourez-la du début à la fin. Couvre les paramètres de chemin, les corps de requête, la validation Pydantic et l'exécution d'un serveur de développement

2. Développement d'API Python (cours de 19 heures, freeCodeCamp, YouTube, gratuit)

Lien : https://www.youtube.com/watch?v=ZtqBQ68cfJc

Couvre les fondamentaux de la conception d'API, y compris les routes, la sérialisation, la validation de schéma et l'intégration de base de données SQL. Construit une API de type réseau social complet à partir de zéro

Ce sur quoi se concentrer : Créer des endpoints GET et POST, les paramètres de chemin et de requête, les corps de requête avec Pydantic, exécuter uvicorn, et utiliser l'interface /docs intégrée de FastAPI pour tester votre API sans écrire de client

Jalon du mois 1

À la fin de ce mois, vous devriez être capable de :

• Écrire des programmes Python qui lisent/écrivent des fichiers, appellent des API et gèrent les erreurs
• Versionner votre code avec Git et pousser des projets sur GitHub
• Naviguer dans le terminal sans hésitation
• Comprendre ce qu'est une requête HTTP et en faire une en Python
• Interroger une base de données SQLite avec du SQL de base
• Construire et exécuter une application FastAPI simple localement

⏩------------------------------------------------------------------------⏪

Mois 2 : Maîtriser le développement d'applications LLM

Votre objectif ce mois-ci : Construire des applications alimentées par l'IA en utilisant les API OpenAI et Anthropic

À la fin, vous devriez être à l'aise pour écrire des prompts qui fonctionnent de manière fiable, obtenir des données structurées des modèles, leur faire appeler vos fonctions et gérer tout ce qui peut mal tourner

C'est le cœur de l'ingénierie IA. Tout le reste dans la feuille de route se construit sur ce que vous apprenez ici

Ce qu'il faut apprendre

1. Notions fondamentales de prompting

Le prompting ne consiste pas seulement à poser des questions poliment. C'est l'art d'écrire des instructions qui produisent des sorties cohérentes et fiables à partir de modèles qui sont fondamentalement probabilistes

En tant qu'ingénieur IA, vous passerez étonnamment beaucoup de temps ici

Comment l'apprendre :

Commencez par le tutoriel interactif d'Anthropic car c'est le plus pratique

Ensuite, lisez le guide officiel d'OpenAI. Après cela, le Prompt Engineering Guide consolide tout

Parcourez les trois dans l'ordre – chacun renforce les autres

Ressources :

1. Tutoriel interactif de prompt engineering d'Anthropic (gratuit, GitHub)

Lien : https://github.com/anthropics/prompt-eng-interactive-tutorial

Un cours étape par étape divisé en 9 chapitres avec des exercices, conçu pour vous donner de nombreuses occasions de pratiquer l'écriture et le dépannage de prompts vous-même

Exécutez-le en tant que notebooks Jupyter avec l'API Claude

2. Documentation de prompt engineering d'Anthropic (gratuit)

Lien : https://docs.anthropic.com/fr/docs/build-with-claude/prompt-engineering/overview

La référence officielle. Couvre tout, de la clarté de base à la structuration XML et aux systèmes agentiques

3. Guide de prompt engineering d'OpenAI (gratuit)

Lien : https://platform.openai.com/docs/guides/prompt-engineering

Le guide officiel d'OpenAI, couvrant les formats de prompt qui fonctionnent bien avec leurs modèles et mènent à des sorties plus utiles

4. PromptingGuide.ai (gratuit)

Lien : https://www.promptingguide.ai/

Couvre les techniques essentielles, du prompting de base aux stratégies avancées, en passant par l'appel de fonction, l'intégration d'outils et les systèmes agentiques

Ce sur quoi se concentrer : La différence entre les messages système et utilisateur, pourquoi la spécificité compte, le raisonnement en chaîne de pensée (pensez étape par étape), l'utilisation d'exemples dans les prompts (few-shot), et comment de petits changements de formulation peuvent modifier considérablement la qualité de la sortie

Pratique : Prenez une tâche réelle – résumer un document, extraire des informations clés d'un texte, classer un retour – et écrivez 5 prompts différents pour cela. Comparez les sorties. Vous verrez immédiatement à quel point la conception du prompt affecte la fiabilité

2. Sorties structurées / Schémas JSON

Dans les applications réelles, vous ne voulez presque jamais de texte brut d'un LLM, vous voulez des données structurées que vous pouvez analyser, stocker et utiliser dans votre code

Les sorties structurées résolvent ce problème en forçant le modèle à correspondre à un schéma que vous définissez

Ressources :

1. Guide des sorties structurées d'OpenAI (docs officiels, gratuit)

Lien : https://platform.openai.com/docs/guides/structured-outputs

Couvre la fonctionnalité qui garantit que les modèles génèrent toujours des réponses conformes à votre schéma JSON, afin que vous n'ayez pas à vous soucier des clés manquantes ou des valeurs hallucinées

2. Bibliothèque Instructor (gratuit, open source)

Lien : https://python.useinstructor.com/

Le moyen le plus propre d'obtenir des sorties structurées de n'importe quel fournisseur LLM en utilisant les modèles Pydantic

Fonctionne avec OpenAI, Anthropic, Google et plus de 15 autres fournisseurs avec la même interface de code, avec des tentatives automatiques en cas d'échec de validation

C'est ce que la plupart des ingénieurs IA en production utilisent réellement

3. OpenAI Cookbook : Introduction aux sorties structurées (gratuit)

Lien : https://cookbook.openai.com/examples/structured_outputs_intro/

Exemples pratiques couvrant les sorties de chaîne de pensée, l'extraction de données structurées et la génération d'interface utilisateur, bon pour comprendre les cas d'utilisation réels

Ce sur quoi se concentrer : Définir des modèles Pydantic pour vos données, passer des schémas à l'API, comprendre la différence entre les sorties structurées et le mode JSON, et gérer les refus avec élégance

Projet pratique : Construisez un analyseur de factures ou de reçus. Donnez-lui du texte brut (par exemple « Facture n°123, 45,99 $ pour 3 gadgets, échéance 30 mars ») et faites-lui retourner un objet Python structuré avec des champs comme invoice_number, amount, items, due_date

3. Appel de fonction / d'outil

L'appel d'outil est ce qui transforme un LLM d'un générateur de texte en quelque chose qui peut agir – chercher sur le web, interroger une base de données, appeler votre API, exécuter du code. C'est l'une des compétences les plus importantes de tout ce guide

Comment le comprendre : Le modèle n'exécute pas réellement vos fonctions

Il examine le prompt et retourne un appel structuré avec le nom de la fonction et les arguments lorsqu'il décide qu'un outil doit être utilisé

Votre code exécute ensuite l'appel et renvoie le résultat

Ressources :

1. Guide d'appel de fonction d'OpenAI (docs officiels, gratuit)

Lien : https://platform.openai.com/docs/guides/function-calling

La référence définitive. Couvre la définition des outils, le flux d'appel en 5 étapes, les appels parallèles et les meilleures pratiques

2. Documentation de l'utilisation d'outils d'Anthropic (gratuit)

Lien : https://docs.anthropic.com/fr/docs/build-with-claude/tool-use

Le guide équivalent d'Anthropic pour Claude. Les concepts sont les mêmes, la syntaxe est légèrement différente

3. OpenAI Cookbook : Comment appeler des fonctions avec des modèles de chat (gratuit, GitHub)

Lien : https://github.com/openai/openai-cookbook/blob/main/examples/How_to_call_functions_with_chat_models.ipynb

Un notebook complet exécutable parcourant la boucle complète d'appel d'outil avec des exemples réels

Ce sur quoi se concentrer : Décrire clairement les fonctions dans un schéma JSON, analyser les réponses d'appel d'outil, exécuter la fonction et renvoyer les résultats, gérer les cas où aucun appel d'outil n'est nécessaire, et le concept de tool_choice: « auto »

Projet pratique : Construisez un assistant simple qui a trois outils : get_weather(city), calculate(expression) et search_notes(query) (recherchez simplement un dictionnaire codé en dur). Connectez-les tous et regardez le modèle décider lequel appeler en fonction de ce que vous lui demandez

4. Réponses en streaming

Le streaming signifie afficher la sortie du modèle au fur et à mesure qu'elle est générée – mot par mot – plutôt que d'attendre la réponse complète. Cela rend vos applications nettement plus rapides et plus vivantes

Ressources :

1. Documentation streaming OpenAI (officiel, gratuit)

Lien : https://platform.openai.com/docs/api-reference/streaming

La référence pour ajouter stream=True aux requêtes et itérer sur les morceaux

2. Documentation streaming Anthropic (officiel, gratuit)

Lien : https://docs.anthropic.com/fr/api/messages-streaming

La référence de l'API streaming d'Anthropic avec des exemples Python

3. Comment fonctionne le streaming des API LLM – Simon Willison (gratuit)

Lien : https://til.simonwillison.net/llms/streaming-llm-apis

Un décryptage technique clair du fonctionnement des Server-Sent Events pour OpenAI, Anthropic et Google, utile pour comprendre ce qui se passe réellement au niveau HTTP

Ce sur quoi se concentrer : Définir stream=True, itérer sur les morceaux delta, assembler la réponse complète à partir des parties, et intégrer le streaming dans un endpoint FastAPI en utilisant StreamingResponse

Conseil : Le streaming est presque toujours le bon choix pour les applications orientées utilisateur. Personne ne veut regarder un spinner de chargement pendant 10 secondes en attendant qu'une réponse complète apparaisse d'un coup

5. État de la conversation

Les LLM sont sans état – ils n'ont pas de mémoire entre les appels. L'historique de la conversation est quelque chose que vous gérez en envoyant la liste complète des messages à chaque requête. Comprendre cela est fondamental

Ressources :

1. Guide des complétions de chat OpenAI, Gestion des conversations (officiel, gratuit)

Lien : https://platform.openai.com/docs/guides/conversation-state

L'explication canonique du fonctionnement du tableau de messages et de la gestion des conversations multi-tours

2. Documentation de l'API Messages d'Anthropic (officiel, gratuit)

Lien : https://docs.anthropic.com/fr/api/messages

L'équivalent d'Anthropic. Même concept, utile à lire pour voir en quoi ils diffèrent

Ce sur quoi se concentrer : La structure du tableau de messages, pourquoi vous devez ajouter à la fois les messages de l'utilisateur et de l'assistant, les limites de la fenêtre de contexte et ce qui se produit lorsqu'elles sont dépassées, et les stratégies de troncature de base (supprimer les messages les plus anciens, résumer l'historique)

Projet pratique : Construisez un chatbot multi-tours simple dans le terminal. Chaque tour ajoute à la liste de messages. Ajoutez une commande /reset pour effacer l'historique, et affichez le nombre actuel de tokens après chaque échange

6. Notions de base sur les coûts, la latence et les tokens

Livrer des applications IA sans comprendre les coûts et les tokens, c'est la garantie de se retrouver avec des factures surprises et des applications lentes. C'est ennuyeux mais essentiel

Ressources :

1. Page de tarification OpenAI (officielle)

Lien : https://openai.com/api/pricing

Sachez combien coûtent les tokens d'entrée et de sortie par modèle. Mettez-la en favori et vérifiez-la chaque fois que vous choisissez un modèle

2. Page de tarification Anthropic (officielle)

Lien : https://www.anthropic.com/pricing

Idem pour les modèles Claude

3. Outil tokenizer OpenAI (gratuit, interactif)

Lien : https://platform.openai.com/tokenizer

Collez n'importe quel texte et voyez exactement combien de tokens il contient. Utilisez-le constamment pendant votre apprentissage

4. Tiktoken (bibliothèque Python, gratuit)

Lien : https://github.com/openai/tiktoken

La bibliothèque tokenizer d'OpenAI pour compter les tokens dans le code avant d'envoyer des requêtes

Ce sur quoi se concentrer : Ce qu'est un token (environ 4 caractères / 3/4 d'un mot), comment les tokens d'entrée et de sortie sont tarifés différemment, comment la taille de la fenêtre de contexte affecte ce que vous pouvez faire, et le compromis de latence entre les modèles plus petits et plus rapides et les modèles plus grands et plus intelligents

Aussi : n'utilisez pas GPT-4/Opus pour tout – les modèles moins chers sont souvent assez bons pour des tâches simples

7. Gestion des échecs

Les API LLM échouent. Les limites de débit sont atteintes, les réponses expirent, le modèle retourne un JSON malformé. Gérer les échecs avec élégance est ce qui sépare une démonstration d'une application de production

Ressources :

1. Référence des codes d'erreur OpenAI (officiel, gratuit)

Lien : https://platform.openai.com/docs/guides/error-codes

Chaque type d'erreur que vous rencontrerez et que faire à ce sujet

2. Documentation de gestion des erreurs Anthropic (officiel, gratuit)

Lien : https://docs.anthropic.com/fr/api/errors

Idem pour Claude

3. Tenacity (bibliothèque Python, gratuit)

Lien : https://tenacity.readthedocs.io/

Une bibliothèque propre pour ajouter une logique de réessai avec backoff exponentiel à n'importe quelle fonction Python. Un décorateur et vos réessais sont gérés

Ce sur quoi se concentrer : Les erreurs de limite de débit (429) et le backoff exponentiel, la gestion des délais d'attente avec httpx/requests, la validation de la sortie du modèle avant de l'utiliser, les stratégies de repli (réessayer avec un modèle différent, retourner une réponse en cache), et ne jamais faire planter votre application parce que le LLM a retourné une sortie inattendue

8. Sensibilisation à l'injection de prompt

L'injection de prompt est le risque de sécurité n°1 dans les applications LLM

Cela se produit lorsque l'entrée utilisateur non fiable est combinée avec des instructions système, permettant à un utilisateur de modifier, remplacer ou injecter un nouveau comportement dans le prompt – ce qui amène le système à effectuer des actions non intentionnelles ou à générer des sorties manipulées

Vous n'avez pas besoin d'être un expert en sécurité, mais vous devez savoir que cela existe avant de livrer quoi que ce soit

Ressources :

1. OWASP Top 10 pour les applications LLM – LLM01 : Injection de prompt (gratuit)

Lien : https://genai.owasp.org/llmrisk/llm01-prompt-injection/

La classification de référence couvrant les injections directes (jailbreaking), les injections indirectes via du contenu externe comme des documents ou des sites web, et les scénarios d’attaque réels

2. OWASP Prompt Injection Prevention Cheat Sheet (gratuit)

Lien : https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html

Schémas défensifs pratiques : validation des entrées, contrôle des privilèges et validation des sorties

3. Evidently AI : Qu’est-ce que l’injection de prompt ? (gratuit)

Lien : https://www.evidentlyai.com/llm-guide/prompt-injection-llm

Un explicateur clair destiné aux développeurs sur les types d’attaques, les risques et les modèles de conception pour les atténuer

Sur quoi se concentrer : La différence entre injection directe et indirecte, pourquoi les prompts système ne sont pas vraiment « sécurisés », le principe du moindre privilège pour l’accès aux outils, et ne jamais faire confiance à une sortie non validée du LLM pour prendre des décisions importantes automatiquement

Jalon du Mois 2

À la fin de ce mois, vous devriez être capable de :

• Écrire des prompts qui produisent des résultats cohérents et fiables pour une tâche donnée
• Obtenir des données JSON structurées de n’importe quel modèle en utilisant Pydantic + Instructor
• Mettre en place l’appel d’outils pour qu’un modèle puisse appeler vos fonctions Python
• Diffuser des réponses en temps réel via un point de terminaison FastAPI
• Gérer correctement l’historique des conversations à plusieurs tours
• Estimer le coût en tokens d’une requête avant de l’envoyer
• Gérer les erreurs d’API, les timeouts et les mauvaises sorties sans planter
• Expliquer ce qu’est l’injection de prompt et appliquer des défenses de base

⏩------------------------------------------------------------------------⏪

Mois 3 : Apprenez le RAG correctement

Votre objectif ce mois-ci : Construire des systèmes qui permettent aux LLM de répondre à des questions à partir de vos documents, et pas seulement de leurs données d’entraînement

À la fin, vous devriez être capable d’ingérer des documents, de les vectoriser et de les stocker, de récupérer les bons morceaux au moment de la requête, et de produire des réponses fondées, précises et sourcées

Le RAG est la compétence pratique la plus demandée en ingénierie IA en ce moment. Presque tous les cas d’usage réels en entreprise – chatbots de support client, bases de connaissances internes, Q&A sur documents – sont construits dessus

Le comprendre en profondeur, pas seulement copier un tutoriel, c’est ce qui distingue les bons ingénieurs des excellents

1. Les embeddings

Avant de pouvoir construire un système RAG, vous devez comprendre ce que sont réellement les embeddings – car ils sont le fondement sur lequel tout repose

Un embedding de texte est une projection d’un texte dans un espace vectoriel de haute dimension

La position de ce texte dans cet espace est représentée par une longue séquence de nombres

Fait crucial, les textes sémantiquement similaires se retrouvent proches dans cet espace – ce qui rend possible la recherche par similarité

Ressources :

1. Stack Overflow Blog : Une introduction intuitive aux embeddings de texte (gratuit)

Lien : https://stackoverflow.blog/2023/11/09/an-intuitive-introduction-to-text-embeddings/

La meilleure explication pour les débutants. Écrite par un développeur qui a passé des années à construire des produits de NLP, avec un accent sur le développement de la bonne intuition plutôt que sur les maths

2. Google ML Crash Course : Les embeddings (gratuit)

Lien : https://developers.google.com/machine-learning/crash-course/embeddings

Explique pourquoi les représentations vectorielles denses résolvent des problèmes que le one-hot encoding ne peut pas résoudre – en particulier, capturer les relations sémantiques entre les éléments

3. HuggingFace : Démarrer avec les embeddings (gratuit)

Lien : https://huggingface.co/blog/getting-started-with-embeddings

Guide pratique. Montre comment générer des embeddings avec la bibliothèque sentence-transformers, les héberger et les utiliser pour une recherche sémantique sur un jeu de données FAQ réel

4. Guide OpenAI sur les embeddings (docs officiels, gratuit)

Lien : https://platform.openai.com/docs/guides/embeddings

La référence pour utiliser les modèles text-embedding-3-small et text-embedding-3-large d’OpenAI dans le code

Sur quoi se concentrer : Qu’est-ce qu’un vecteur conceptuellement, pourquoi des textes similaires produisent des vecteurs similaires, comment fonctionne la similarité cosinus, la différence entre les modèles d’embedding (OpenAI, HuggingFace sentence-transformers), et ce que signifie la dimension d’embedding en pratique

Pratique : Prenez 20 phrases sur des sujets connexes, vectorisez-les avec OpenAI ou sentence-transformers, et écrivez une simple recherche du plus proche voisin qui retourne les 3 plus similaires à une requête. C’est littéralement le cœur du RAG en miniature

2. Le découpage (chunking)

Vos documents sont trop volumineux pour être vectorisés en entier. Le découpage est le processus qui consiste à les diviser en morceaux plus petits avant de les vectoriser

La façon dont vous découpez vos documents affecte directement la capacité de votre système à trouver les informations pertinentes et à fournir des réponses précises – même un système de récupération parfait échoue s’il recherche sur des données mal préparées

Ressources :

1. Weaviate : Stratégies de découpage pour le RAG (gratuit)

Lien : https://weaviate.io/blog/chunking-strategies-for-rag

Le guide le plus pratique. Couvre le découpage de taille fixe, récursif et sémantique, avec des conseils clairs sur quand utiliser chacun

2. Unstructured : Meilleures pratiques de découpage pour le RAG (gratuit)

Lien : https://unstructured.io/blog/chunking-for-rag-best-practices

Une plongée technique approfondie sur les tailles de morceaux, le chevauchement, et comment la fenêtre de contexte du modèle d’embedding impose des limites strictes

Un bon point de départ pour l’expérimentation est une taille de morceau d’environ 250 tokens (environ 1000 caractères), combinée à un chevauchement de 10 à 20 % entre les morceaux consécutifs pour éviter de perdre le contexte aux frontières

3. Documentation des splitter de texte LangChain (officielle, gratuit)

Lien : https://python.langchain.com/docs/concepts/text_splitters/

La référence pratique pour utiliser RecursiveCharacterTextSplitter, MarkdownTextSplitter et les splitters sémantiques dans le code

Sur quoi se concentrer : Le découpage de taille fixe avec chevauchement comme base, le découpage récursif pour les documents structurés, le découpage sémantique pour une meilleure détection des frontières, et le compromis fondamental : des morceaux trop grands perdent en précision de récupération ; des morceaux trop petits perdent du contexte

Conseil pour débutants : Commencez avec RecursiveCharacterTextSplitter de LangChain avec chunk_size=500 et chunk_overlap=50. C’est la valeur par défaut la plus sensée pour la plupart des documents et vous donne une base de travail à partir de laquelle vous pourrez vous améliorer

3. Bases de données vectorielles

Une fois que vous avez des embeddings, vous avez besoin d’un endroit pour les stocker et les rechercher efficacement. C’est à cela que servent les bases de données vectorielles

Le bon choix dépend de votre situation : utilisez Chroma pour un prototypage local rapide, Pinecone pour une évolutivité clé en main gérée, Weaviate pour la flexibilité open source avec une recherche hybride puissante, Qdrant pour des filtres complexes et un hébergement économique, et pgvector si vous utilisez déjà PostgreSQL et souhaitez éviter d’ajouter un autre système

Ressources :

1. Documentation officielle Chroma (gratuit)

Lien : https://docs.trychroma.com/

Chroma est parfait pour les développeurs individuels et les petites équipes qui privilégient la rapidité de développement et la simplicité – il fonctionne en mémoire ou localement sans infrastructure à gérer

2. Centre d’apprentissage Pinecone (gratuit)

Lien : https://www.pinecone.io/learn/

D’excellents tutoriels gratuits couvrant les concepts de recherche vectorielle, la recherche hybride et les pipelines RAG. Bon matériel indépendant du fournisseur, même si vous n’utilisez pas Pinecone

3. Documentation Qdrant (gratuit)

Lien : https://qdrant.tech/documentation/

Meilleure option open source pour la production avec filtrage avancé. Très rapide, flexible et gratuit à héberger soi-même

4. pgvector (open source, gratuit)

Lien : https://github.com/pgvector/pgvector

Si vous construisez quelque chose qui utilise déjà PostgreSQL, pgvector ajoute la recherche vectorielle directement dans votre base de données existante sans nouvelle infrastructure

Sur quoi se concentrer : Créer une collection, insérer des embeddings avec des métadonnées, interroger par similarité avec top_k, et filtrer par métadonnées au moment de la requête

Vous n’avez pas besoin de comprendre les algorithmes d’indexation (HNSW, IVF) – comprenez simplement comment les utiliser

Projet pratique : Indexez 50 à 100 pages d’une documentation publique quelconque (par exemple la documentation Python, ou un dump d’article Wikipedia) dans Chroma avec des métadonnées (URL source, titre de section). Écrivez une fonction de requête qui récupère les 5 morceaux les plus pertinents pour n’importe quelle question

4. Filtrage par métadonnées

La recherche par similarité brute ne suffit pas pour les applications réelles. Le filtrage par métadonnées vous permet de restreindre la récupération à un sous-ensemble pertinent – par date, source, type de document, utilisateur, catégorie ou tout autre attribut que vous stockez avec chaque morceau

Ressources :

1. Pinecone : Guide du filtrage par métadonnées (gratuit)

Lien : https://docs.pinecone.io/guides/data/filter-with-metadata

Explication claire avec des exemples de code pour filtrer les vecteurs par champs de métadonnées avant ou pendant la recherche par similarité

2. LlamaIndex : Guide des filtres de métadonnées (docs officiels, gratuit)

Lien : https://docs.llamaindex.ai/en/stable/module_guides/querying/node_postprocessors/node_postprocessors/

Explique comment appliquer des filtres au moment de la requête dans les pipelines LlamaIndex

Sur quoi se concentrer : Étiqueter chaque morceau avec les métadonnées pertinentes lors de l’ingestion (nom du fichier source, numéro de page, section, date, catégorie), et utiliser ces champs pour filtrer les résultats au moment de la requête. C’est ce qui fait la différence entre une démo jouet et un système de production où les utilisateurs peuvent demander « montre-moi seulement les résultats des rapports du T4 2025 au T1 2026 »

5. Le reclassement (reranking)

Le reclassement est une technique qui ajoute un coup de pouce sémantique à la qualité de recherche de tout système de recherche par mots-clés ou vectoriel

Après que la première étape de récupération a renvoyé un ensemble de candidats, un reclasser renote ces résultats en fonction de la pertinence contextuelle réelle par rapport à la requête – pas seulement de la proximité vectorielle

Le schéma en deux étapes est : vectoriser et rechercher (rapide, approximatif) → reclasser le top-k (plus lent, plus précis). Le résultat est une qualité de récupération nettement meilleure avec seulement un coût modeste en latence

Ressources :

1. Documentation de reclassement Cohere (officielle, gratuit)

Lien : https://docs.cohere.com/docs/reranking-with-cohere

Le meilleur endroit pour commencer. Couvre l’intégralité du workflow de reclassement, y compris les données semi-structurées comme les e-mails et les documents JSON. Nécessite seulement une ligne de code pour l’ajouter à un pipeline de récupération existant

2. LangChain : Intégration du reclasser Cohere (docs officiels, gratuit)

Lien : https://python.langchain.com/docs/integrations/retrievers/cohere-reranker/

Explique comment connecter le reclassement Cohere dans un récupérateur LangChain en utilisant ContextualCompressionRetriever

Sur quoi se concentrer : Le schéma en deux étapes récupérer-puis-reclasser, la différence entre un bi-encodeur (utilisé pour la recherche par embedding de première étape) et un cross-encodeur (utilisé pour le reclassement), et le compromis pratique latence/qualité du reclassement du top-20 vs top-5

6. Problèmes de qualité de récupération

La plupart des échecs du RAG ne sont pas des échecs du modèle, ce sont des échecs de récupération. Comprendre les façons dont la récupération peut mal tourner est essentiel pour déboguer les systèmes réels

Problèmes courants à apprendre :

• Dérive sémantique : L’embedding de la requête ne correspond pas à l’embedding du morceau pertinent même si l’information s’y trouve. Correction : essayez la réécriture de requête ou HyDE (Hypothetical Document Embeddings)
• Problèmes de frontière de morceau : L’information pertinente est répartie sur deux morceaux. Correction : augmentez le chevauchement ou utilisez le découpage sémantique
• Contexte de métadonnées manquant : Les morceaux sont sémantiquement similaires à la requête mais appartiennent au mauvais document, date ou utilisateur. Correction : utilisez le filtrage par métadonnées
• Top_k trop petit : Le bon morceau existe mais n’est pas dans les 5 premiers résultats récupérés. Correction : augmentez top_k lors de la récupération et réduisez après reclassement

Ressources :

1. LangChain : Transformations de requêtes (gratuit)

Lien : https://python.langchain.com/docs/how_to/#query-analysis

Couvre la réécriture de requête, le step-back prompting et HyDE

2. Pinecone : Améliorer la qualité de récupération (gratuit)

Lien : https://www.pinecone.io/learn/retrieval-augmented-generation/#retrieval-quality

Parcours pratique des modes de défaillance courants avec des correctifs

7. Réduction des hallucinations

Le RAG réduit considérablement les hallucinations par rapport à un LLM standard, mais ne les élimine pas

En fournissant au modèle des faits récupérés à l’exécution, le RAG ancre ses réponses dans des sources réelles plutôt que de se fier uniquement aux données d’entraînement, et la sortie du modèle peut même citer ces sources, augmentant ainsi la transparence et la confiance

Mais les échecs de récupération, les mauvais morceaux et les informations contradictoires peuvent encore amener le modèle à inventer des choses

Ressources :

1. Zep : Réduire les hallucinations des LLM – Un guide du développeur (gratuit)

Lien : https://www.getzep.com/ai-agents/reducing-llm-hallucinations/

Guide pratique axé sur les développeurs couvrant les stratégies d’ancrage des prompts, le chain-of-thought pour les tâches factuelles et les schémas de vérification des sorties

2. Voiceflow : 5 façons de réduire les hallucinations des LLM (gratuit)

Lien : https://www.voiceflow.com/blog/prevent-llm-hallucinations

Bon aperçu de la stratégie combinée : RAG + chain-of-thought + garde-fous surpassent ensemble toute approche unique

Sur quoi se concentrer : Demander au modèle de répondre uniquement à partir du contexte fourni (et de dire « je ne sais pas » quand la réponse ne s’y trouve pas), ajouter un seuil de confiance avant de diffuser les réponses, et toujours valider la qualité de récupération avant de blâmer le LLM

8. Citations et ancrage

Un système RAG ancré ne se contente pas de répondre – il indique d’où vient la réponse. C’est essentiel pour la confiance des utilisateurs et pour le débogage

Ressources :

1. Anthropic : Donner des sources à Claude (docs, gratuit)

Lien : https://docs.anthropic.com/en/docs/build-with-claude/citations

Explique comment demander à Claude de produire des réponses citées avec des références aux sources

2. LangChain : RAG avec sources (gratuit)

Lien : https://python.langchain.com/docs/how_to/qa_sources/

Explique comment renvoyer les documents sources avec les réponses dans un pipeline RAG LangChain

Sur quoi se concentrer : Transmettre les métadonnées des morceaux (nom du fichier source, numéro de page, URL) dans le contexte du prompt, demander au modèle de référencer les sources dans sa réponse, et afficher ces sources dans votre interface utilisateur ou votre réponse API

9. Votre framework RAG : LangChain ou LlamaIndex

Vous n’avez pas besoin de construire un pipeline RAG from scratch. Deux frameworks dominent le domaine et méritent d’être connus :

LlamaIndex est optimisé pour placer la recherche et l’indexation en premier – il abstrait l’ingestion, le découpage, la vectorisation et l’interrogation en quelques lignes de code, vous permettant de construire un prototype fonctionnel en un après-midi

LangChain brille lorsque votre application ressemble davantage à un moteur d’orchestration – il excelle avec les workflows multi-agents, l’appel d’outils et les chaînes conditionnelles qui interrogent plusieurs LLM ou API externes avant de générer une réponse

Pour le Mois 3, commencez avec LlamaIndex pour le RAG. Passez à LangChain lorsque vous atteindrez le travail sur les agents du Mois 4

Ressources :

1. LlamaIndex : Introduction au RAG (docs officiels, gratuit)

Lien : https://developers.llamaindex.ai/python/framework/understanding/rag/

Couvre les cinq étapes clés du RAG : chargement, indexation, stockage, interrogation et évaluation – et comment LlamaIndex gère chacune

2. Tutoriel de démarrage LlamaIndex (docs officiels, gratuit)

Lien : https://developers.llamaindex.ai/python/framework/getting_started/starter_example/

Le guide de démarrage rapide officiel. Construisez un système RAG fonctionnel en moins de 30 lignes

3. LangChain : Construire un agent RAG (docs officiels, gratuit)

Lien : https://docs.langchain.com/oss/python/langchain/rag

Montre comment construire une application de Q&A sur du texte non structuré en utilisant un agent RAG, d’une version minimale de 40 lignes jusqu’à un pipeline de récupération complet avec reclassement

Projet pratique : Construisez une application « discutez avec vos documents ». Ingérez 10 à 20 fichiers PDF ou texte (vos propres notes, un chapitre de manuel, une documentation produit – n’importe quoi). Construisez un point de terminaison FastAPI qui accepte une question, récupère les 5 morceaux les plus pertinents avec reclassement, et renvoie une réponse citée provenant de Claude ou OpenAI. C’est une véritable pièce de portfolio

Jalon du Mois 3

À la fin de ce mois, vous devriez être capable de :

• Expliquer ce qu’est un embedding et pourquoi des textes similaires produisent des vecteurs similaires
• Découper intelligemment n’importe quel document en utilisant des stratégies appropriées
• Stocker et interroger des embeddings dans une base de données vectorielle avec filtrage par métadonnées
• Ajouter une étape de reclassement pour améliorer la qualité de récupération
• Déboguer systématiquement les échecs de récupération courants
• Construire un pipeline RAG complet de bout en bout en utilisant LlamaIndex ou LangChain qui ingère des documents, récupère les morceaux pertinents et renvoie des réponses fondées et citées

⏩------------------------------------------------------------------------⏪

Mois 4 : Agents, outils, workflows et évaluations

Votre objectif ce mois-ci : Construire des systèmes d’IA capables d’exécuter des séquences d’actions de manière autonome, d’assembler des workflows en plusieurs étapes et d’évaluer de manière critique s’ils fonctionnent

À la fin, vous devriez être capable de construire un véritable agent from scratch, de comprendre quand les agents sont un mauvais choix, et de mesurer les performances de tout ce que vous construisez

C’est là que l’ingénierie IA devient véritablement complexe. Les compétences du Mois 4 sont ce qui distingue les ingénieurs IA juniors de ceux qui peuvent posséder une fonctionnalité IA entière de bout en bout

1. Boucles d’agent

Un agent n’est pas magique, c’est un modèle étonnamment simple

Pensez aux agents comme des systèmes axés sur des objectifs qui parcourent constamment un cycle d’observation, de raisonnement et d’action

Cette boucle leur permet d’aborder des tâches qui vont au-delà des simples questions et réponses, en entrant dans l’automatisation réelle, l’utilisation d’outils et l’adaptation à la volée

La « réflexion » se fait dans le prompt, la « ramification » se produit lorsque l’agent choisit parmi les outils disponibles, et l’« exécution » se produit lorsque nous appelons des fonctions externes. Tout le reste n’est que tuyauterie

Une fois que vous intériorisez cela, même les frameworks d’agent les plus complexes deviennent lisibles

Ressources :

1. Anthropic : Construire des agents efficaces (officiel, gratuit)

Lien : https://www.anthropic.com/research/building-effective-agents

Le meilleur écrit sur les agents en production. Lisez ceci avant d’écrire une seule ligne de code d’agent

2. OpenAI : Guide pratique pour construire des agents (PDF officiel, gratuit)

Lien : https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

Le guide complémentaire d’OpenAI couvrant les schémas d’agent, les garde-fous et les modèles de sécurité en production

3. freeCodeCamp : Le manuel de l’agent LLM open source (gratuit)

Lien : https://www.freecodecamp.org/news/the-open-source-llm-agent-handbook/

Un guide pratique complet couvrant la boucle d’agent, LangGraph, CrewAI, la planification, la mémoire et l’utilisation d’outils. Idéal pour se mettre rapidement en pratique

4. LangChain Academy : Introduction à LangGraph (cours gratuit)

Lien : https://academy.langchain.com/courses/intro-to-langgraph

Le cours gratuit officiel pour LangGraph, le framework d’orchestration d’agents le plus utilisé. Couvre l’état, la mémoire, l’humain dans la boucle, et plus encore

Sur quoi se concentrer : Le cycle percevoir → planifier → agir → observer, comment la boucle d’agent se termine, ce qui se passe lorsqu’un appel d’outil échoue à l’intérieur d’une boucle, et pourquoi les agents ne sont que des boucles while avec un LLM qui prend les décisions de branchement

Pratique : Construisez un agent from scratch sans aucun framework – juste l’API OpenAI ou Anthropic directement. Donnez-lui 3 outils, un objectif et une boucle. C’est la chose la plus précieuse que vous puissiez faire pour vraiment comprendre ce que les frameworks abstraient

2. Sélection d’outils

Écrire de bons outils représente la moitié du travail. Les descriptions de vos outils et de leurs paramètres sont le manuel d’utilisation pour le LLM. Si le manuel est vague, le LLM utilisera mal l’outil. Soyez douloureusement, implacablement explicite

Un outil mal décrit sera appelé de manière incorrecte, appelé au mauvais moment ou ignoré complètement. Un outil bien décrit se comporte de manière prévisible et est sélectionné correctement sur un large éventail d’entrées

Ressources :

1. OpenAI : Meilleures pratiques pour l’appel de fonctions (docs officiels, gratuit)

Lien : https://platform.openai.com/docs/guides/function-calling/best-practices

Le guide de référence pour écrire des descriptions d’outils qui fonctionnent de manière fiable, avec des conventions de nommage et des schémas de documentation des paramètres

2. Anthropic : Meilleures pratiques pour l’utilisation d’outils (docs officiels, gratuit)

Lien : https://docs.anthropic.com/en/docs/build-with-claude/tool-use/implement-tool-use#best-practices-for-tool-definitions

L’équivalent d’Anthropic. Portez une attention particulière aux conseils sur quand laisser le modèle choisir vs forcer un outil spécifique

Sur quoi se concentrer : Écrire des noms d’outils qui sont des verbes explicites par eux-mêmes, écrire des descriptions qui expliquent quand appeler l’outil (pas seulement ce qu’il fait), garder les paramètres minimaux et bien typés, et concevoir des outils avec le LLM comme appelant

Conseil pour débutants : Testez chaque description d’outil en vous demandant : « Si je n’avais aucune documentation et seulement ce schéma JSON, saurais-je exactement quand et comment appeler ceci ? » Si ce n’est pas le cas, il faut encore travailler

3. Gestion de l’état

Dans LangGraph, l’état est un objet mémoire partagé qui circule dans le graphe. Il stocke toutes les informations pertinentes – messages, variables, résultats intermédiaires et historique des décisions – et est géré automatiquement tout au long de l’exécution

Comprendre l’état est la clé pour construire des agents capables de gérer des tâches multi-tours, de se remettre des échecs et de passer proprement d’un composant à un autre

Ressources :

1. Documentation officielle LangGraph : Gestion de l’état (gratuit)

Lien : https://langchain-ai.github.io/langgraph/concepts/low_level/#state

La référence définitive. Couvre les schémas d'état, les réducteurs et la façon dont l'état circule à travers les nœuds et les arêtes.

2. DataCamp : Tutoriel LangGraph Agents (gratuit)

Lien : https://www.datacamp.com/tutorial/langgraph-agents

Couvre les bases de l'état, des nœuds et des arêtes avec du code pratique, menant à des agents avec état et mémoire persistante entre les sessions.

3. Real Python : LangGraph en Python (gratuit)

Lien : https://realpython.com/langgraph-python/

Un tutoriel approfondi qui construit un agent LangGraph complet avec état, avec des explications détaillées du graphe d'état et des arêtes conditionnelles.

Ce sur quoi se concentrer : Définir les schémas d'état avec TypedDict, le fonctionnement des réducteurs pour fusionner les mises à jour parallèles, la différence entre l'état en mémoire et la persistance par points de contrôle, et comment fonctionnent les pauses avec intervention humaine en inspectant et modifiant l'état en cours d'exécution.

4. Gestion des tentatives et des échecs dans les agents

Les agents échouent différemment des appels LLM classiques. Un mauvais appel d'outil en cours de boucle peut corrompre l'état, provoquer des boucles infinies ou produire silencieusement des réponses erronées. Vous avez besoin de stratégies explicites pour tout cela.

Ressources :

1. LangGraph : Gestion des erreurs et tentatives (docs officiels, gratuit)

Lien : https://langchain-ai.github.io/langgraph/how-tos/autofill-tool-errors/

Explique comment ajouter une gestion automatique des erreurs et une logique de réessai au niveau du nœud d'outil dans LangGraph.

2. Guide pratique des agents OpenAI : section Garde-fous (gratuit)

Lien : https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf

Couvre les garde-fous comme une défense en couches, combinant des vérifications basées sur LLM, des filtres basés sur des règles comme les regex, et des API de modération pour vérifier les entrées et sorties à chaque étape de la boucle de l'agent.

Ce sur quoi se concentrer : Limites maximales d'itération pour éviter les boucles infinies, réessai par outil avec backoff exponentiel, capture et journalisation des exceptions au niveau de l'exécution des outils sans faire planter l'agent, et quand signaler un échec à l'utilisateur plutôt que de réessayer silencieusement.

5. Quand NE PAS utiliser d'agents

C'est l'une des compétences les plus importantes et les plus négligées en ingénierie IA. Les agents sont excitants, mais ils sont aussi lents, coûteux, imprévisibles et difficiles à déboguer. Savoir quand opter pour quelque chose de plus simple est un signe de bon jugement.

Anthropic recommande de trouver la solution la plus simple possible et de n'augmenter la complexité que si nécessaire – cela peut signifier ne pas construire du tout de systèmes agentiques.

Les systèmes agentiques échangent latence et coût contre de meilleures performances sur la tâche, et vous devez soigneusement réfléchir à quand cet échange a du sens.

Le cadre de décision est le suivant :

• Utilisez un seul appel LLM si la tâche peut être résolue en un seul prompt avec le bon contexte.
• Utilisez un workflow si les étapes sont fixes et prévisibles.
• Utilisez un agent uniquement si le nombre d'étapes est réellement imprévisible et nécessite une prise de décision dynamique.

Ressources :

1. Anthropic : Construire des agents efficaces, quand utiliser des agents (officiel, gratuit)

Lien : https://www.anthropic.com/research/building-effective-agents

La réponse la plus autorisée à cette question, directement de l'équipe qui construit les modèles.

2. Simon Willison : Concevoir des boucles agentiques (gratuit)

Lien : https://simonwillison.net/2025/Sep/30/designing-agentic-loops/

Le point de vue pratique d'un ingénieur senior sur quand la complexité des agents est justifiée et comment penser la conception de boucles agentiques.

Ce qu'il faut mémoriser : Une chaîne de 3 appels LLM fixes sera toujours plus rapide, moins chère et plus facile à déboguer qu'un agent qui pourrait faire 3 appels. Réservez les agents pour des tâches vraiment ouvertes.

6. Workflows multi-étapes

Entre le « prompt unique » et « l'agent complet », il existe un vaste terrain productif intermédiaire : les workflows. Les workflows sont idéaux lorsque la tâche peut être proprement décomposée en sous-tâches fixes – en échangeant de la latence contre une meilleure précision en rendant chaque appel LLM plus facile et plus ciblé.

Les motifs courants incluent l'enchaînement de prompts (la sortie d'un appel est l'entrée du suivant), le routage (classer l'entrée et l'envoyer à des gestionnaires spécialisés), la parallélisation (exécuter plusieurs appels simultanément et agréger), et l'orchestrateur-sous-agent (un LLM planifie, les autres exécutent).

Ressources :

1. Anthropic : Motifs de workflow (officiel, gratuit)

Lien : https://www.anthropic.com/research/building-effective-agents#workflow-patterns

Couvre tous les motifs principaux avec des diagrammes et des exemples de code. Les sections sur la parallélisation et l'orchestration sont particulièrement utiles.

2. LangGraph : Réseaux multi-agents (docs officiels, gratuit)

Lien : https://langchain-ai.github.io/langgraph/concepts/multi_agent/

Explique comment connecter plusieurs agents ensemble en un réseau, avec des motifs de superviseur et de transfert.

Projet pratique : Construisez un pipeline de contenu en 3 étapes :

Étape 1 – un LLM extrait les faits clés d'un article.

Étape 2 – un autre appel LLM utilise ces faits pour générer un tweet, un post LinkedIn et un résumé en parallèle.

Étape 3 – un dernier appel LLM évalue les trois pour la qualité et choisit le meilleur.

Pas d'agent requis, pur workflow.

7. Harnais d'évaluation

Les évaluations sont la façon dont vous savez si votre système IA fonctionne réellement – pas seulement sur les exemples que vous avez testés à la main, mais systématiquement sur des centaines d'entrées.

Les agents IA sont puissants mais complexes à déployer car leur comportement probabiliste et multi-étapes introduit de nombreux points de défaillance.

Différentes parties d'un agent – les LLM, les outils, les récupérateurs et les workflows – nécessitent chacune leur propre approche d'évaluation.

Ressources :

1. DeepEval (open source, gratuit)

Lien : https://deepeval.com/docs/getting-started

Un framework d'évaluation LLM open source inspiré de pytest. Écrivez des cas de test avec des entrées et des sorties attendues, exécutez-les avec plus de 50 métriques intégrées, y compris l'hallucination, la pertinence des réponses et la cohérence factuelle, et détectez les régressions entre les versions.

2. [Promptfoo (open source, gratuit)](https://github.com/promptfoo/promptfoo)

Lien : https://github.com/promptfoo/promptfoo

Une CLI et une bibliothèque pour tester et évaluer les applications LLM avec des suites de tests automatisés. Prend en charge la comparaison côte à côte de plusieurs prompts sur plusieurs modèles, l'intégration CI/CD et le red teaming pour les vulnérabilités de sécurité.

3. LangSmith (offre gratuite)

Lien : https://smith.langchain.com/

Traçage, débogage et évaluation pour les applications LangChain et LangGraph. L'offre gratuite est généreuse et l'interface de traçage rend le débogage des boucles d'agents considérablement plus facile.

4. Ragas (open source, gratuit)

Lien : https://docs.ragas.io/

Framework d'évaluation spécialisé pour les pipelines RAG. Mesure la fidélité, la pertinence des réponses, la précision du contexte et le rappel du contexte. Essentiel si vous évaluez des systèmes RAG à partir du Mois 3.

Ce sur quoi se concentrer : Construire un ensemble de test de référence de 20 à 50 entrées représentatives avec des sorties attendues ou des grilles d'évaluation, écrire des fonctions d'évaluation qui notent les sorties de manière déterministe (correspondance de chaîne, validation de schéma JSON) ou avec LLM comme juge, et exécuter les évaluations automatiquement lorsque vous modifiez un prompt ou changez de modèle.

État d'esprit critique : Les évaluations ne sont pas un polissage optionnel. Chaque changement de prompt, remplacement de modèle ou ajustement de récupération que vous effectuez sans exécuter d'évaluations est un pari. Les ingénieurs qui livrent des produits IA fiables exécutent des évaluations en permanence.

8. Métriques de succès des tâches

Au-delà des évaluations automatiques, vous avez besoin de métriques qui vous disent si votre agent atteint son objectif réel.

Ressources :

1. Hamel Husain : Votre produit IA a besoin d'évaluations (gratuit)

Lien : https://hamel.dev/blog/posts/evals/

L'un des articles les plus pratiques écrits sur la construction de pipelines d'évaluation pour des systèmes IA de production réels, par quelqu'un qui l'a fait à grande échelle.

2. Framework OpenAI Evals (open source, gratuit)

Lien : https://github.com/openai/evals

Le propre framework d'évaluation d'OpenAI, avec une vaste bibliothèque de modèles d'évaluation contribués par la communauté que vous pouvez adapter.

Ce sur quoi se concentrer : La différence entre les métriques de processus (l'agent a-t-il appelé le bon outil ?) et les métriques de résultat (la tâche a-t-elle réussi ?), définir des critères de succès clairs avant de construire quoi que ce soit, et utiliser LLM comme juge pour l'évaluation des sorties qui résistent à une correspondance exacte (comme les réponses longues ou les traces de raisonnement multi-étapes).

Projet pratique : Reprenez votre pipeline RAG du Mois 3 et construisez un véritable harnais d'évaluation autour. Créez 30 paires question-réponse à partir de vos documents, exécutez-les dans votre pipeline, et notez chaque réponse pour la pertinence, la fidélité et l'exhaustivité en utilisant DeepEval. Ensuite, modifiez une chose (taille des morceaux, modèle, top-k) et réexécutez pour voir si cela s'est amélioré.

Jalon du Mois 4

À la fin de ce mois, vous devriez être capable de :

• Expliquer ce qu'est une boucle d'agent et en implémenter une à partir de zéro sans framework.
• Écrire des descriptions d'outils qui sont sélectionnées correctement et de manière fiable.
• Gérer correctement l'état de l'agent en utilisant LangGraph ou équivalent.
• Gérer les échecs dans les boucles d'agents sans planter.
• Décider en toute confiance si une tâche nécessite un agent, un workflow ou un prompt unique.
• Construire des workflows multi-étapes qui enchaînent, routent et parallélisent les appels LLM.
• Écrire des évaluations automatisées qui détectent les régressions lorsque vous modifiez des prompts ou des modèles.
• Définir et mesurer des métriques de succès de tâches pour tout système IA que vous construisez.

⏩------------------------------------------------------------------------⏪

Mois 5 : Déploiement, réflexion produit et fiabilité

Votre objectif ce mois-ci : Prenez tout ce que vous avez construit et rendez-le prêt pour la production.

À la fin, vous devriez être capable de déployer une application IA qui gère de vrais utilisateurs, un vrai trafic et de vrais échecs sans s'effondrer à 2 heures du matin.

C'est là que la plupart des ingénieurs IA calent. Ils peuvent construire une super démo mais ne peuvent pas livrer un produit qui survit au contact avec le monde réel.

Les compétences ici sont ce pour quoi les entreprises paient réellement : fiabilité, sécurité, contrôle des coûts et la capacité à maintenir les choses en fonctionnement quand quelque chose casse inévitablement.

1. Modèles de production FastAPI

Vous savez déjà comment construire une application FastAPI depuis le Mois 1. Maintenant, vous devez la faire survivre au trafic de production.

La différence entre le développement et la production est brutale. Un seul processus uvicorn avec --reload est bien pour construire. En production, il devient le goulot d'étranglement dès que le trafic réel arrive.

Ce dont vous avez réellement besoin : configuration ASGI multi-travailleurs, middleware de gestion d'erreurs approprié, points de terminaison de vérification d'état et politiques CORS.

Ressources :

1. Documentation de déploiement FastAPI (officiel, gratuit)

Lien : https://fastapi.tiangolo.com/deployment/

Le guide officiel couvrant les travailleurs Uvicorn, Gunicorn et le déploiement Docker. Commencez ici avant toute autre chose.

2. Guide de déploiement production FastAPI (CYS Docs, gratuit)

Lien : https://craftyourstartup.com/cys-docs/fastapi-production-deployment/

Modèles de production complets : configuration Gunicorn, proxy inverse Nginx, vérifications d'état, limitation de débit. Inclut des fichiers de configuration réels que vous pouvez adapter.

3. Meilleures pratiques FastAPI pour la production (FastLaunchAPI, gratuit)

Lien : https://fastlaunchapi.dev/blog/fastapi-best-practices-production-2026

Couvre le pooling de base de données asynchrone, la mise en cache Redis, l'authentification JWT et les tâches en arrière-plan. Des modèles testés en production provenant d'un modèle réel utilisé par plus de 100 développeurs.

Ce sur quoi se concentrer : Exécuter Gunicorn avec des travailleurs Uvicorn (pas Uvicorn nu), configurer des points de terminaison de vérification d'état, ajouter un middleware CORS, implémenter des sessions de base de données asynchrones appropriées et utiliser des tâches en arrière-plan pour tout ce qui n'a pas besoin de bloquer la réponse.

2. Docker

Docker est la façon dont vous arrêtez de dire « ça marche sur ma machine » et commencez à livrer des déploiements cohérents.

Si vous construisez des applications IA, Docker résout les conflits de dépendances, garantit des environnements cohérents et rend la mise à l'échelle simple.

Vous n'avez pas besoin de devenir un expert Docker. Vous devez être capable de conteneuriser votre application FastAPI + LLM et de la déployer n'importe où.

Ressources :

1. Guide officiel de démarrage Docker (gratuit)

Lien : https://docs.docker.com/get-started/

Le point de départ canonique. Couvre les images, les conteneurs, les Dockerfiles et Docker Compose.

2. freeCodeCamp : Comment construire et déployer un système IA multi-agents avec Python et Docker (gratuit)

Lien : https://www.freecodecamp.org/news/build-and-deploy-multi-agent-ai-with-python-and-docker/

Tutoriel pratique de bout en bout construisant un pipeline multi-agents réel avec Docker Compose. Couvre la séparation des préoccupations, la planification cron et les considérations de sécurité.

3. DataCamp : Déployer des applications LLM avec Docker (gratuit)

Lien : https://www.datacamp.com/tutorial/deploy-llm-applications-using-docker

Guide étape par étape spécifiquement pour les applications LLM avec pipelines RAG. Couvre la création de Dockerfile, la gestion d'environnement et le déploiement.

4. Conteneurisation Docker pour applications LLM (ApXML, gratuit)

Lien : https://apxml.com/courses/python-llm-workflows/chapter-10-deployment-operational-practices/containerization-docker-llm-apps

Couvre la sélection d'image de base, la gestion des dépendances, les builds multi-étapes et Docker Compose pour les déploiements LLM multi-services.

Ce sur quoi se concentrer : Écrire un Dockerfile pour une application Python/FastAPI, utiliser des builds multi-étapes pour garder les images petites, Docker Compose pour les configurations multi-services (application + base de données + Redis), les variables d'environnement pour les secrets, et .dockerignore pour éviter de fuir des fichiers sensibles.

Projet pratique : Conteneurisez votre application RAG du Mois 3. Créez un fichier docker-compose.yml qui exécute votre application FastAPI, une base de données vectorielle (Chroma ou Qdrant) et Redis pour la mise en cache. Déployez-la de sorte que docker compose up démarre tout.

3. Tâches en arrière-plan et files d'attente

Les appels LLM sont lents. Si un utilisateur demande à votre application de traiter un document et que vous le faites attendre 30 secondes pour une réponse, il partira.

Les tâches en arrière-plan vous permettent d'accepter la demande immédiatement, de la traiter de manière asynchrone et de notifier l'utilisateur lorsque c'est terminé.

Ressources :

1. Guide officiel de démarrage Celery (gratuit)

Lien : https://docs.celeryq.dev/en/stable/getting-started/introduction.html

La file d'attente de tâches Python standard. Couvre la configuration de base, la définition des tâches et la gestion des travailleurs.

2. Documentation FastAPI sur les tâches en arrière-plan (officiel, gratuit)

Lien : https://fastapi.tiangolo.com/tutorial/background-tasks/

Tâches en arrière-plan légères intégrées pour des cas d'utilisation simples. Utilisez ceci pour des tâches rapides de type « lance et oublie », Celery pour tout ce qui est plus lourd.

Ce sur quoi se concentrer : Comprendre quand utiliser BackgroundTasks intégré de FastAPI par rapport à une vraie file d'attente de tâches comme Celery, configurer Redis comme courtier de messages, gérer les échecs de tâches et les tentatives, et renvoyer le statut de la tâche à l'utilisateur.

4. Authentification et sécurité des clés API

Si votre application IA a une API, elle a besoin d'authentification. Sans cela, n'importe qui peut utiliser vos points de terminaison, brûler vos crédits LLM, et vous vous réveillerez avec une facture de 5 000 $.

Ressources :

1. Documentation FastAPI sur la sécurité (officiel, gratuit)

Lien : https://fastapi.tiangolo.com/tutorial/security/

Couvre OAuth2, les jetons JWT, les clés API et les modèles d'authentification basés sur les dépendances. La référence officielle, parcourez le tutoriel complet.

2. OWASP API Security Top 10 (gratuit)

Lien : https://owasp.org/API-Security/

La liste faisant autorité des risques de sécurité API. Comprenez l'authentification compromise, l'injection et l'assignation de masse avant de livrer quoi que ce soit.

3. Auth0 : Meilleures pratiques d'authentification API (gratuit)

Lien : https://auth0.com/docs/get-started/authentication-and-authorization

Guide pratique pour implémenter l'authentification et l'autorisation dans les API.

Ce sur quoi se concentrer : Jetons JWT pour l'authentification utilisateur, gestion des clés API pour la communication service à service, limitation de débit par utilisateur/clé, ne jamais stocker de secrets dans le code (utiliser des variables d'environnement), et comprendre la différence entre authentification (qui êtes-vous) et autorisation (que pouvez-vous faire).

5. Journalisation et observabilité

En production, si vous ne pouvez pas voir ce qui se passe, vous ne pouvez pas réparer ce qui est cassé.

Les applications LLM ont un défi unique : le modèle peut renvoyer un code d'état 200 et pourtant produire une réponse inutile ou hallucinée. La surveillance traditionnelle ne détecte pas cela. Vous avez besoin d'une observabilité spécifique aux LLM.

Ressources :

1. Langfuse (open source, offre gratuite)

Lien : https://langfuse.com/docs/observability/overview

Plateforme d'observabilité LLM open source. Trace chaque requête : prompt envoyé, réponse reçue, utilisation de tokens, latence, appels d'outils. Prend en charge le versionnement des prompts, l'évaluation et la notation LLM comme juge. S'intègre avec OpenAI, Anthropic, LangChain, LlamaIndex.

2. LangSmith (offre gratuite)

Lien : https://smith.langchain.com/

De l'équipe LangChain. Si vous utilisez LangChain/LangGraph, la configuration est une variable d'environnement. Traçage, débogage, tableaux de bord de surveillance et évaluations en ligne. L'offre gratuite est généreuse pour le développement et la production à petite échelle.

3. Python Structlog (gratuit)

Lien : https://www.structlog.org/

Journalisation structurée pour Python. Produit des journaux JSON qui sont réellement consultables et analysables. Bien meilleur que print() ou la journalisation de base pour les applications de production.

Ce sur quoi se concentrer : Tracer chaque appel LLM (prompt d'entrée, sortie, tokens, latence, coût), journalisation structurée avec sortie JSON, configurer des tableaux de bord qui montrent le volume de requêtes, les taux d'erreur et le coût par jour, et alerter quand quelque chose casse ou que les coûts montent en flèche.

6. Gestion des prompts et des versions

En production, vos prompts sont du code. Ils ont besoin de contrôle de version, de tests et de capacité de retour arrière.

Modifier un prompt en production sans suivre ce que vous avez changé, c'est la façon de casser des choses sans pouvoir comprendre pourquoi.

Ressources :

1. Gestion des prompts Langfuse (gratuit)

Lien : https://langfuse.com/docs/prompts

Versionnement centralisé des prompts avec un terrain de jeu intégré pour les tests. Versionnez vos prompts séparément de votre code applicatif. Déployez des modifications de prompt sans redéployer votre application.

2. Meilleures pratiques Anthropic pour la gestion des prompts (gratuit)

Lien : https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview

Meilleures pratiques pour organiser, itérer et gérer les prompts à grande échelle.

Ce sur quoi se concentrer : Stocker les prompts en dehors de votre code applicatif, versionner chaque modification de prompt, tester A/B des variantes de prompts en production, et avoir une stratégie de retour arrière quand un nouveau prompt donne de moins bons résultats.

7. Surveillance des coûts et limites de débit

Les API LLM facturent par token. Sans contrôles de coûts, un pic de trafic ou un bug dans votre prompt peut brûler des centaines de dollars en quelques minutes.

Ressources :

1. Tableau de bord d'utilisation OpenAI (officiel)

Lien : https://platform.openai.com/usage

Suivez les dépenses par modèle, par jour et définissez des limites d'utilisation.

2. Tableau de bord d'utilisation Anthropic (officiel)

Lien : https://console.anthropic.com/ Même chose pour l'utilisation de l'API Claude.

3. Helicone (offre gratuite)

Lien : https://www.helicone.ai/

Observabilité basée sur un proxy qui capture chaque appel LLM avec suivi automatique des coûts. Une ligne de code pour configurer : changez simplement votre URL de base.

4. LiteLLM (open source, gratuit)

Lien : https://github.com/BerriAI/litellm

Interface unifiée pour plus de 100 fournisseurs LLM. Inclut la gestion de budget, la limitation de débit et le suivi des dépenses entre fournisseurs.

Ce sur quoi se concentrer : Définir des limites de dépenses strictes par jour/mois, implémenter des limites de débit par utilisateur dans votre API, utiliser des modèles moins chers pour les tâches simples (n'utilisez pas GPT-4/Opus pour tout), mettre en cache les requêtes identiques répétées avec Redis, et surveiller le coût par requête pour détecter rapidement les prompts coûteux.

8. Mise en cache

Si 20 % de vos utilisateurs posent des questions similaires, vous payez pour le même appel LLM 20 fois.

La mise en cache est le moyen le plus simple de réduire les coûts et la latence simultanément.

Ressources :

1. Documentation officielle Redis (gratuit)

Lien : https://redis.io/docs/

Le magasin de données en mémoire standard. Rapide, simple et parfait pour la mise en cache des réponses LLM.

2. GPTCache (open source, gratuit)

Lien : https://github.com/zilliztech/GPTCache

Mise en cache sémantique spécialement conçue pour les applications LLM. Utilise la similarité d'incorporation pour trouver des réponses mises en cache pour des requêtes sémantiquement similaires (pas seulement identiques).

Ce sur quoi se concentrer : Mise en cache par correspondance exacte pour les prompts identiques, mise en cache sémantique pour les requêtes similaires, stratégies d'invalidation de cache (basée sur TTL est la plus simple), et mesurer les taux de succès du cache pour comprendre les économies réelles.

Jalon du Mois 5

À la fin de ce mois, vous devriez être capable de :

• Déployer une application FastAPI + LLM dans Docker avec une configuration de production appropriée.
• Gérer les tâches de longue durée avec des jobs en arrière-plan et des files d'attente.
• Sécuriser votre API avec authentification, limites de débit et gestion des clés API.
• Tracer et déboguer les appels LLM en utilisant Langfuse ou LangSmith.
• Gérer les prompts avec contrôle de version et capacité de retour arrière.
• Surveiller les coûts en temps réel et définir des limites de dépenses.
• Mettre en cache les réponses LLM pour réduire la latence et les coûts.

⏩------------------------------------------------------------------------⏪

Mois 6 : Spécialisez-vous et devenez recrutable

Ces connaissances et compétences que vous avez acquises peuvent être appliquées dans trois directions (bien sûr, ce ne sont que celles que je vois).

Vous devez en choisir une et vous concentrer sur la pratique.

Bien que tout ce qui précède s'apprenne aussi mieux uniquement par la pratique.

Direction 1 : Ingénieur produit IA

Idéal si vous voulez des emplois dans les startups rapidement.

C'est le chemin le plus courant. Vous construisez des produits alimentés par l'IA avec lesquels de vrais utilisateurs interagissent.

Vous avez déjà la plupart des compétences des Mois 1 à 5. Maintenant, approfondissez le côté produit.

Concentrez-vous sur :

• Applications LLM
• RAG
• Agents
• Déploiement
• UX produit

Ce qu'il faut apprendre ce mois-ci :

1. Construction de produits de bout en bout

Arrêtez de construire des tutoriels. Construisez des produits que les gens peuvent utiliser.

Ressources :

1. SDK Vercel AI (gratuit)

Lien : https://sdk.vercel.ai/docs

Le moyen le plus rapide de construire des interfaces utilisateur alimentées par l'IA avec support du streaming. Intégrations React, Next.js et Vue avec composants d'interface utilisateur de streaming intégrés.

2. Streamlit (gratuit)

Lien : https://docs.streamlit.io/

Construisez des applications de données et des démos IA en pur Python. Idéal pour les outils internes et les MVP, pas pour les interfaces utilisateur à l'échelle de la production.

3. Gradio (gratuit)

Lien : https://www.gradio.app/

Le moyen le plus rapide de partager des modèles ML. Parfait pour les démos, les tests utilisateurs rapides et les présentations. Très populaire dans la communauté ML.

4. Bonnes pratiques pour l'interface utilisateur des chatbots IA (gratuit)

Lien : https://www.anthropic.com/engineering/building-chat-interfaces

Guide d'Anthropic sur la conception d'interfaces de chat. Couvre le streaming, la gestion des erreurs, la présentation des sources et l'expérience utilisateur de la messagerie asynchrone et synchrone.

Ce sur quoi se concentrer : Construire d'abord une version la plus simple possible (MVP), puis itérer en fonction des retours. Se concentrer sur l'expérience de streaming (les utilisateurs détestent attendre), gérer les erreurs avec élégance (pas de « Désolé, je n'ai pas compris » générique), et investir dans les évaluations et la surveillance. La plupart des utilisateurs quittent si la réponse n'arrive pas dans les 5 secondes.

Jalon du Mois 6

Si vous suivez le chemin Ingénieur produit IA :

• Livrer un produit IA complet que quelqu'un peut utiliser.
• Construire la logique backend (RAG, agents, workflows) dans LangGraph.
• Déployer avec Docker et FastAPI.
• Ajouter authentification et limitation de débit.
• Mettre en place une instrumentation de base avec Langfuse ou LangSmith.
• Surveiller les coûts et définir des alertes.

Si vous suivez la spécialisation Ingénieur IA (Deep Learning) :

• Terminer le programme complet fast.ai ou un équivalent.
• Affiner au moins un modèle de fondation (même sur un petit jeu de données).
• Comprendre et pouvoir expliquer l'architecture du transformateur.
• Être capable de lire des papiers de recherche et de les implémenter.
• Avoir construit un pipeline de données et un script d'entraînement.

Si vous suivez la spécialisation Ingénieur ML :

• Mettre en œuvre l'ensemble du pipeline MLOps pour un projet.
• Configurer le suivi des expériences (MLflow, Weights & Biases).
• Mettre en place des pipelines de données et de caractéristiques.
• Construire une infrastructure de déploiement de modèles (API de modèle, surveillance).
• Effectuer des tests A/B et une validation de modèle.

Conclusion

Nous avons couvert beaucoup de terrain. Ce guide ne vise pas à être fait rapidement. Chaque mois nécessite du travail réel et de la pratique.

Vous n'avez pas besoin d'apprendre tout cela. Ce dont vous avez besoin, c'est de suivre vos centres d'intérêt. Peut-être que la RAG vous passionne, alors approfondissez le pipeline de récupération. Peut-être que la construction d'agents vous semble magique, alors construisez des agents. Peut-être que vous détestez la partie infrastructure et que vous voulez juste faire du fine-tuning.

La clé est d'être honnête avec vous-même sur ce que vous voulez faire, puis d'y consacrer le temps.

Le domaine de l'IA est vaste. Personne ne peut tout maîtriser. Mais la bonne nouvelle, c'est que vous n'avez pas besoin d'être un expert dans tous les domaines pour être précieux.

Mon conseil : choisissez un chemin à la fin du Mois 6, concentrez-vous sur la pratique, construisez en public, et postulez à des emplois ou proposez des services.

Les entreprises paient pour des personnes capables de construire des choses.

Bon courage.

Lien : https://www.gradio.app/docsQuick Créez des interfaces ML/AI avec un minimum de code. Particulièrement utile pour démontrer des modèles et construire des prototypes.

Ce sur quoi se concentrer : Construire 2 à 3 projets complets ce mois-ci que vous pouvez présenter. Une application « discutez avec vos documents », un outil interne propulsé par l'IA, ou un agent qui automatise un flux de travail réel. Livrez-les. Mettez-les sur GitHub. Déployez-les quelque part où les gens peuvent les essayer.

2. UX produit pour l'IA

Les produits IA échouent quand l'UX ne prend pas en compte les limites du modèle.

Ressources :

1. Google : Guide People + AI (gratuit)

Lien : https://pair.withgoogle.com/guidebook/

La meilleure ressource sur la conception d'interactions humain-IA. Couvre la gestion des attentes, la gestion des erreurs et l'instauration de la confiance.

2. Nielsen Norman Group : Directives UX pour l'IA (gratuit)

Lien : https://www.nngroup.com/topic/artificial-intelligence/

Des directives de recherche pour les interfaces IA.

Ce sur quoi se concentrer : Comment gérer les états de chargement avec le streaming, que montrer quand le modèle se trompe, comment permettre aux utilisateurs de donner leur avis, et concevoir en tenant compte du fait que la sortie IA est probabiliste – elle sera parfois erronée.

Direction 2 : Ingénieur ML / LLM appliqué

Le meilleur choix si vous visez des rôles techniques plus approfondis.

Cette direction s'adresse aux ingénieurs qui souhaitent aller au-delà des appels API et comprendre ce qui se passe sous le capot.

Concentrez-vous sur :

• le fine-tuning
• quand fine-tuner vs. utiliser le prompt
• l'évaluation
• l'optimisation de l'inférence
• les modèles open-source
• les pipelines d'entraînement

Ce qu'il faut apprendre ce mois-ci :

1. Quand fine-tuner vs. faire du prompt engineering

La décision la plus importante en ML appliqué : avez-vous besoin de modifier le modèle, ou simplement de changer la façon dont vous lui parlez ?

Ressources :

1. Google ML Crash Course : Fine-tuning, Distillation et Prompt Engineering (gratuit)

Lien : https://developers.google.com/machine-learning/crash-course/llm/tuning

L'explication la plus claire des trois approches et quand utiliser chacune.

2. Codecademy : Prompt Engineering vs. Fine-Tuning (gratuit)

Lien : https://www.codecademy.com/article/prompt-engineering-vs-fine-tuning

Un cadre de décision pratique avec des cas d'utilisation clairs pour chaque approche.

3. IBM : RAG vs. Fine-Tuning vs. Prompt Engineering (gratuit)

Lien : https://www.ibm.com/think/topics/rag-vs-fine-tuning-vs-prompt-engineering

Couvre l'espace décisionnel complet, y compris quand combiner les approches.

Cadre de décision à mémoriser : Commencez par le prompt engineering (le moins cher, le plus rapide). Ajoutez du RAG si le modèle a besoin d'accéder à des données spécifiques. Ne fine-tunez que lorsque le prompting + RAG ne peuvent pas atteindre la qualité, la cohérence ou la latence requises.

2. Le fine-tuning en pratique

Lorsque vous devez fine-tuner, voici comment procéder.

Ressources :

1. Guide de fine-tuning OpenAI (officiel, gratuit)

Lien : https://platform.openai.com/docs/guides/fine-tuning

Le moyen le plus simple de commencer le fine-tuning. Téléchargez un jeu de données JSONL, lancez un job, obtenez un modèle personnalisé. Idéal pour apprendre le workflow, même si vous passez ensuite à des modèles open-source.

2. Tutoriel de fine-tuning HuggingFace Transformers (gratuit)

Lien : https://huggingface.co/docs/transformers/training

La bibliothèque standard pour travailler avec les modèles open-source. Couvre l'entraînement, l'évaluation et la sauvegarde des modèles.

3. Unsloth (open source, gratuit)

Lien : https://github.com/unslothai/unsloth

Fine-tuning 2x plus rapide avec 80 % de mémoire en moins. Prend en charge LoRA et QLoRA directement. La voie la plus rapide pour fine-tuner des modèles open-source sur du matériel grand public.

4. LLaMA-Factory (open source, gratuit)

Lien : https://github.com/hiyouga/LLaMA-Factory

Cadre unifié pour le fine-tuning de plus de 100 LLM. Inclut une interface web pour le fine-tuning sans code. Prend en charge LoRA, QLoRA, le fine-tuning complet, RLHF et DPO.

Ce sur quoi se concentrer : Préparer des jeux de données d'entraînement (format JSONL), comprendre LoRA et QLoRA (fine-tuning efficace en paramètres), lancer un job de fine-tuning sur OpenAI ou avec HuggingFace, évaluer le modèle fine-tuné par rapport au modèle de base, et savoir quand le fine-tuning n'en vaut pas le coût.

3. Modèles open-source

Tout ne doit pas passer par OpenAI ou Anthropic. Les modèles open-source vous donnent un contrôle total, pas de coûts d'API et la possibilité de fonctionner localement.

Ressources :

1. Ollama (gratuit)

Lien : https://ollama.ai/

Exécutez des LLM open-source localement en une seule commande. Prend en charge Llama, Mistral, Gemma et des dizaines d'autres. Le moyen le plus rapide d'expérimenter avec des modèles open-source.

2. HuggingFace Model Hub (gratuit)

Lien : https://huggingface.co/models

Le plus grand dépôt de modèles open-source. Parcourez, téléchargez et déployez des modèles pour n'importe quelle tâche.

3. vLLM (open source, gratuit)

Lien : https://github.com/vllm-project/vllm

Moteur d'inférence LLM à haut débit. 2 à 4 fois plus rapide que le service HuggingFace basique. La norme pour le déploiement en production de modèles open-source.

Ce sur quoi se concentrer : Exécuter des modèles localement avec Ollama pour les tests, comprendre la quantification (GGUF, GPTQ, AWQ) et pourquoi elle est importante pour le déploiement, comparer les modèles open-source aux modèles API pour votre cas d'usage, et servir des modèles en production avec vLLM.

4. Optimisation de l'inférence

Faire fonctionner les modèles plus rapidement et à moindre coût en production.

Ressources :

1. HuggingFace : Optimisation de l'inférence LLM (gratuit)

Lien : https://huggingface.co/docs/transformers/llm_optims

Couvre l'optimisation du cache KV, la quantification et les stratégies de batching.

2. NVIDIA TensorRT-LLM (gratuit)

Lien : https://github.com/NVIDIA/TensorRT-LLM

Performance d'inférence maximale sur les GPU NVIDIA. Utilisé par la plupart des services LLM en production à grande échelle.

Ce sur quoi se concentrer : Stratégies de batching pour le débit, quantification pour réduire la mémoire et les coûts, optimisation du cache KV pour une génération plus rapide, et choix du matériel adapté à votre charge de travail d'inférence.

Direction 3 : Ingénieur en automatisation IA

Le meilleur choix si vous voulez construire pour les entreprises immédiatement.

Cette direction consiste à automatiser des flux de travail métier réels avec l'IA. Moins de construction de produits, plus de résolution de problèmes opérationnels.

Concentrez-vous sur :

• l'orchestration de workflows
• l'automatisation des processus métier
• les systèmes multi-outils
• les cas d'utilisation CRM, documents, email, support, ops

Ce qu'il faut apprendre ce mois-ci :

1. Orchestration de workflows

L'automatisation métier réelle n'est presque jamais un seul appel LLM. Ce sont des chaînes d'actions à travers plusieurs systèmes.

Ressources :

1. n8n (open source, gratuit à auto-héberger)

Lien : https://docs.n8n.io/

Automatisation visuelle de workflows avec des nœuds IA. Connectez les LLM à plus de 400 intégrations (Slack, Gmail, Notion, CRM, etc.). La meilleure option no-code/low-code pour l'automatisation IA.

2. LangGraph : Workflows multi-agents (gratuit)

Lien : https://langchain-ai.github.io/langgraph/concepts/multi_agent/

Orchestration code-first pour des systèmes multi-agents complexes. Quand n8n ne suffit pas et que vous avez besoin d'un contrôle programmatique complet.

3. Temporal (open source, gratuit)

Lien : https://docs.temporal.io/

Moteur de workflow durable pour des processus longue durée et tolérants aux pannes. Quand votre automatisation doit survivre aux crashs, aux tentatives et aux délais d'attente.

Ce sur quoi se concentrer : Concevoir des workflows qui gèrent les échecs avec élégance, connecter l'IA à des outils métier réels (email, CRM, bases de données, tableurs), mettre en place des étapes d'approbation avec intervention humaine, et journaliser chaque action automatisée pour les pistes d'audit.

2. Automatisation des processus métier

L'argent dans l'automatisation IA réside dans la résolution de problèmes métier spécifiques et coûteux.

Ressources :

1. Zapier AI Actions (niveau gratuit)

Lien : https://zapier.com/ai

Connectez l'IA à plus de 6 000 applications sans code. Idéal pour prototyper des automatisations avant de construire des solutions personnalisées.

2. Make (Integromat) (niveau gratuit)

Lien : https://www.make.com/

Plateforme d'automatisation visuelle avec logique avancée et intégrations IA. Plus puissant que Zapier pour les workflows complexes.

Ce sur quoi se concentrer : Identifier les cibles d'automatisation au meilleur ROI (généralement des tâches répétitives, chronophages et basées sur des règles), construire des automatisations qui augmentent les humains plutôt que les remplacer, et mesurer le temps et l'argent réellement économisés.

3. Automatisation CRM, Documents, Email, Support

Les cas d'utilisation d'automatisation IA les plus courants et les plus précieux.

Ressources :

1. OpenAI Cookbook : Traitement des e-mails propulsé par l'IA (gratuit)

Lien : https://github.com/openai/openai-cookbook

Méthodes pour classer, router et répondre aux e-mails avec l'IA.

2. LangChain : Pipelines de traitement de documents (gratuit)

Lien : https://python.langchain.com/docs/how_to/#document-loaders

Ingestion et traitement de documents provenant de plus de 80 sources.

Ce sur quoi se concentrer : Construire un classificateur et un répondeur automatique d'e-mails alimentés par l'IA, créer un pipeline de traitement de documents qui extrait des données structurées, construire un chatbot de support qui utilise du RAG sur votre base de connaissances, et intégrer l'IA dans les workflows CRM existants (HubSpot, Salesforce, etc.).

Projet pratique pour la Direction 3 : Construisez un système de qualification de leads de bout en bout. Il doit :

Importer ou scraper des leads depuis une source (CSV, API ou formulaire)

Utiliser un LLM pour rechercher chaque lead (infos entreprise, évaluation d'adéquation)

Noter et classer les leads en fonction de votre profil client idéal

Rédiger des messages de prospection personnalisés

Journaliser le tout dans un tableur ou un CRM. C'est une automatisation réelle et vendable pour laquelle les entreprises paient réellement.

⏩------------------------------------------------------------------------⏪

CONCLUSION

À quoi vous attendre après ces 6 mois ???

Je vais être honnête avec vous, sans montagnes d'argent.

Cette feuille de route ne fera pas de vous un ingénieur IA senior en 6 mois.

Mais elle fera de vous quelqu'un qui peut construire, livrer et déployer des systèmes IA réels qui résolvent de vrais problèmes.

Et actuellement, c'est exactement ce que le marché paie.

La demande pour les ingénieurs IA ne ralentit pas. Les offres d'emploi ont augmenté de 25 % d'une année sur l'autre.

PwC a constaté une prime salariale de 56 % pour les postes nécessitant des compétences en IA par rapport aux mêmes postes sans ces compétences.

Seulement 1 % des entreprises sont considérées comme « matures en IA », ce qui signifie que 99 % ont encore besoin d'aide. Le Bureau of Labor Statistics américain prévoit une croissance de 26 % des emplois d'ici 2034.

Ce ne sont pas des chiffres de hype. Ce sont les vrais chiffres basés sur des analyses (tirés de Claude kek).

Si vous travaillez à temps plein aux États-Unis :

Ingénieurs IA juniors commencent entre 90 000 $ et 130 000 $.

Niveau intermédiaire (3-5 ans) se situe entre 155 000 $ et 200 000 $.

Postes seniors vont de 195 000 $ à 350 000 $ et plus.

Selon Glassdoor (mars 2026), la moyenne est de 184 757 $.

La tranche intermédiaire est celle qui croît le plus vite, à 9,2 % d'une année sur l'autre, car les entreprises ont désespérément besoin de personnes capables de livrer des solutions IA en production sans supervision constante.

Si le freelance est plus votre truc :

Développement d'agents IA se facture entre 175 $ et 300 $/heure.

Implémentation RAG entre 150 $ et 250 $/heure.

Intégration LLM entre 125 $ et 200 $/heure.

Un développeur sur Reddit a construit un outil de résumé de documents pour un cabinet d'avocats en deux semaines et a gagné 8 000 $. Un freelance facturant 25 heures/semaine à 150 $/heure gagne 195 000 $/an.

Et si vous optez pour le conseil, comme je l'ai évoqué dans mon précédent post, vous pouvez facturer :

300 $ à 5 000 $ pour mettre en place un agent IA pour une entreprise

500 $ à 2 000 $/mois pour la gestion de contenu IA

1 000 $ à 4 000 $ pour automatiser le support client

500 $ à 2 000 $ pour la mise en place de prospection à froid

L'éventail des services est encore plus large, mais une fois que vous maîtrisez les compétences de cette feuille de route, vous êtes déjà un spécialiste recherché en 2026.

Ce sont des chiffres réels provenant de vraies personnes qui font du vrai travail.

Maintenant, voici ce que je veux vraiment que vous reteniez de tout cela :

Choisissez un projet par mois et construisez-le. Pas en lire. Pas regarder un tutoriel. Construisez-le, cassez-le, réparez-le, déployez-le, mettez-le sur GitHub. Les ingénieurs qui se font embaucher sont ceux qui montrent ce qu'ils ont construit, pas ce qu'ils ont étudié.

Commencez à partager ce que vous apprenez. Écrivez-en sur X, LinkedIn, n'importe où. Enseigner est le moyen le plus rapide d'apprendre et construit votre réputation en même temps. Les meilleures opportunités que j'ai vues viennent de personnes qui étaient visibles, pas de celles qui ont postulé à 500 offres d'emploi.

Et s'il vous plaît, n'attendez pas de vous sentir prêt. Vous ne vous sentirez jamais prêt. Le fossé entre « j'apprends » et « je construis » est l'endroit où la plupart des gens restent bloqués pour toujours.

Commencez à postuler, commencez à freelancer, commencez à offrir des services dès que vous avez des projets fonctionnels. Même s'ils ne sont pas parfaits. Le marché ne récompense pas la perfection. Il récompense les gens qui livrent.

6 mois suffisent pour tout changer si vous mettez réellement le travail.

Et je crois sincèrement que chacun d'entre vous qui lit ceci peut y arriver.

Ne cessez jamais de construire et n'arrêtez jamais d'apprendre.

J'espère que cela vous a été utile, ma famille ❤️