Une feuille de route pour l’ingénierie IA en 2026 : de Python aux agents et aux outils LLMOps.

Pourquoi la plupart des feuilles de route en IA semblent dépassées

« Comment devenir ingénieur en IA ? » est la question que posent sans cesse les nouveaux arrivants ainsi que les développeurs en poste souhaitant se reconvertir dans ce domaine. De nombreux PDF de feuilles de route circulent, et beaucoup ont été rédigés avant même que les agents, MCP et l’ingénierie de contexte ne deviennent des sujets de discussion. De nos jours, on attend même des débutants qu’ils connaissent quelques bases sur RAG, ce qui rend difficile de savoir par où commencer. Les développeurs expérimentés se sentent également dépassés, car chaque nouvelle étape doit s’ajouter à ce qu’ils savent déjà grâce à leurs expériences professionnelles et à leur connaissance de la conception de systèmes.

Ce qui suit est un ensemble de phases, et non un programme détaillé. Les sujets sont regroupés avec des ressources et des projets afin qu’un débutant puisse suivre le parcours depuis le début, tandis qu’un ingénieur expérimenté peut l’utiliser pour combler des lacunes ou se perfectionner. Une grande partie du contenu relatif aux feuilles de route de l’IA en ligne correspond à une feuille de route d’apprentissage automatique de 2019, se terminant par un chapitre sur les LLM. Cela peut convenir à un débutant, mais un ingénieur expérimenté a besoin de plus.

Le titre du poste a beaucoup évolué en seulement deux ans. D’ici 2026, on s’attend à ce que les ingénieurs en IA accomplissent des tâches qui n’étaient pas incluses dans leurs responsabilités auparavant, des tâches que ceux qui sont déjà dans le secteur ont probablement déjà observées.

Faut-il craindre que l’IA prenne les emplois dans le domaine technologique ? Pas si l’on continue à évoluer avec elle.

Il y a deux ans, il n’existait pas un seul poste intitulé « prompt engineering », et pourtant regardez combien de postes liés à ce domaine sont apparus depuis. Toute personne qui compte consacrer des mois à cette matière mérite un plan d’études qui reflète ce que les équipes recrutent aujourd’hui, et non un document obsolète.

Phase 1 : Python et bases de l’ingénierie logicielle

Ne cherchez pas des outils en priorité. Construisez d’abord des fondations solides en ingénierie logicielle. Ceux qui maîtrisent déjà Python peuvent passer directement à Git, aux environnements virtuels et au débogage.

C’est ici que Python pour l’IA commence vraiment. Des mois passés à regarder des tutoriels ne valent guère plus que de simples connaissances théoriques, tandis que la capacité de réfléchir clairement se développe lorsque l’on pratique les structures de données et les algorithmes en les écrivant soi-même. Maîtrisez donc le Python pur, ou un autre langage que vous préférez. Le C++ peut être utile pour apprendre les DSA s’il vous est plus facile, mais vous devrez probablement passer au Python par la suite. La maîtrise du Python est ce qui empêche les bibliothèques spécifiques à l’IA de sembler être une langue étrangère.

Faites-vous à ces éléments :

• les structures de données telles que les listes, les dictionnaires et les ensembles
• les fonctions et les classes
• les compréhensions de listes et de dictionnaires
• les générateurs et les décorateurs, qui apparaissent partout dans les frameworks d’IA

Pour les matériaux d’apprentissage, un cours d’introduction universitaire comme CS50 Python de Harvard ou un bootcamp complet pour débutants conviennent tous deux. Consacrez le moins de temps possible à la sélection et commencez simplement par l’un d’eux. Une fois les bases maîtrisées, passez aux problèmes de DSA sur une plateforme de pratique comme LeetCode.

Puis il y a les outils associés au langage :

• Environnements : venv, pip et de plus en plus uv. Les ignorer entraîne des heures de conflits de dépendances.
• Git et GitHub : branches, commits, demandes de fusion et résolution des conflits de fusion. Personne n’a besoin de s’en souvenir, car l’utilisation progressive en fait une habitude.
• Fichiers et données : JSON, CSV et texte brut pour l’entrée et la sortie, car la plupart des données réelles ressemblent à cela bien avant de devenir un dataframe bien structuré.
• Le terminal : bash de base, navigation entre les dossiers et enchaînement de commandes.
• Débogage : lisez le message d’erreur avant de le coller dans un chatbot, et utilisez les outils de votre éditeur, tels que les points d’arrêt de VS Code. Les instructions print restent d’une grande utilité.

Un piège dans lequel tombent de nombreux débutants est de considérer cette phase comme une simple vision de tutoriels jusqu’à ce que tout devienne évident. Cela ne fonctionne pas en regardant seulement ; cela fonctionne en tapant, en corrigeant et en répétant le processus.

L’image ci-dessus mène à un site proposant des idées de projets Python pour débutants. Un bon premier projet peut être quelque chose de simple comme un calculateur de IMC, un Sudoku ou un jeu de tic-tac-toe, puis, par la suite, un projet utilisant des données réelles ou abordant un problème concret, par exemple :

• un outil en ligne de commande qui récupère des données depuis une API publique, les nettoie et les enregistre dans un fichier structuré
• un script qui analyse son propre fichier CSV de relevé bancaire ou les exportations de partage de dépenses et classe les dépenses par catégorie
• Un outil de scraping plus efficace pour un ensemble de données qui vous intéresse personnellement

Le résultat final n’est pas l’objectif. La véritable valeur réside dans la résolution de problèmes fastidieux : enregistrements endommagés, erreurs de type « off-by-one », ainsi qu’une API dont le format de réponse change pendant l’exécution du script.

Phase 2 : Mathématiques, outils de données et premier modèle

Quelles que soient les mathématiques abordées à cette phase, essayez de les mettre en œuvre dans du code. C’est ainsi que vous découvrirez quelles bibliothèques utiliser et quand.

Les gens ont peur des mathématiques en intelligence artificielle plus que nécessaire. Il n’est pas nécessaire d’utiliser toute la théorie de l’algèbre linéaire au début, seulement une petite partie spécifique, qui pourra toujours être étendue par la suite.

Algèbre linéaire

• Vecteurs, matrices et tenseurs, ainsi que l’effet géométrique de leur multiplication
• Produits scalaires, multiplication de matrices et valeurs propres, qui reviennent fréquemment dans les mécanismes d’attention et les embeddings

Les cours illustrés et visuels sont utiles pour ceux qui préfèrent apprendre de cette manière.

Calcul différentiel

La plupart des gens ont abordé ce sujet à l’école, donc les thèmes présentés ci-dessous servent principalement de rappel.

• pré-calcul différentiel, calcul différentiel, calcul intégral et calcul multivarié
• derivées, en particulier le concept de gradient

Probabilités et statistiques

• distribution, moyenne et variance, ainsi que probabilité conditionnelle
• c’est le langage utilisé pour exprimer les résultats des modèles, l’incertitude et les métriques d’évaluation

Optimisation

• descendeur de gradient, taux d’apprentissage et fonctions de perte : mécanisme permettant de réduire progressivement les erreurs

Ne vous surchargez pas et n’allez pas trop profond. Faire des énigmes de sudoku, puis appliquer des concepts de probabilités à celles-ci, est un moyen pour ceux qui n’aiment pas les mathématiques de développer de l’admiration pour elles.

L’image ci-dessus montre où chaque concept mathématique devient nécessaire.

Outils pour travailler avec les données

• Apprenez Pandas et NumPy pour la manipulation et l’analyse des données.
• Maîtrisez une bibliothèque de visualisation telle que Matplotlib ou Seaborn, en commençant par Matplotlib car elle est plus simple.

Une bonne visualisation élargit votre façon de penser aux données et vous permet de raconter des histoires à leur sujet ; cherchez donc des ressources qui l’enseignent bien.

En pratique : construisez une régression linéaire à partir de zéro

De tout ce qui figure dans ce plan, cet exercice est le plus bénéfique, mais il est souvent sauté car il semble trop basique. Résistez à cette tentation.

import numpy as np
class LinearRegressionScratch:
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.learning_rate = learning_rate
        self.n_iterations = n_iterations
        self.weights = None
        self.bias = None
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0
        for _ in range(self.n_iterations):
            y_pred = np.dot(X, self.weights) + self.bias
            # Gradients
            dw = (1 / n_samples) * np.dot(X.T, (y_pred - y))
            db = (1 / n_samples) * np.sum(y_pred - y)
            # Update
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
    def predict(self, X):
        return np.dot(X, self.weights) + self.bias

Lorsque la classe s’exécute et produit des prédictions, exécutez sklearn.linear_model.LinearRegression sur des données identiques et comparez les résultats. Une fois que les deux approches coïncident approximativement, vous comprendrez de première main ce qui se passe à l’intérieur de chaque modèle que vous utiliserez par la suite. Faites de l’habitude de réimplémenter l’algorithme derrière toute technique que vous rencontrez. Les bibliothèques facilitent la tâche, mais l’algorithme et les mathématiques qui le sous-tendent méritent toujours une attention particulière.

Phase 3 : Apprentissage automatique classique

Apprenez les méthodes classiques avant d’aborder les réseaux de neurones, car un grand nombre de problèmes réels en apprentissage automatique sont encore mieux et plus économiquement résolus par ces dernières que par l’apprentissage profond. L’objectif est de comprendre pourquoi telle technique est choisie par rapport à une autre et comment elle traite le problème.

Sujets principaux

• Apprentissage supervisé : régression, classification, arbres de décision, forêts aléatoires et boosting de gradient avec XGBoost ou LightGBM.
• Apprentissage non supervisé : clustering avec k-means et réduction de dimensionnalité avec PCA.
• Évaluation des modèles : séparation en données d’entraînement et de test, validation croisée, précision, rappel, F1 et ROC-AUC, ainsi que la capacité à déterminer quelle métrique est pertinente pour un problème métier donné.
• Ingénierie des caractéristiques, compétence qui distingue un bon modèle d’un modèle médiocre.
• Maîtrise de scikit-learn, y compris les pipelines, le prétraitement des données et le choix des modèles.

Un cours en ligne interactif et adapté aux débutants couvre bien les bases, tandis qu’un cours plus long de type Udemy approfondit les sujets si vous en souhaitez davantage. Toute ressource abordant les concepts des premières étapes conviendra.

Projet de portfolio 1 : prédiction du churn des clients

Presque tout le monde travaille sur ce projet, et pour de bonnes raisons : il vous guide à travers un cycle de vie réaliste de données tabulaires complexes, de classes déséquilibrées, de l’ingénierie des caractéristiques, ainsi que de la comparaison et de l’évaluation des modèles en lien avec les besoins métier. Ici, un faux négatif signifie qu’un client a été perdu.

Une version complète comprend :

• une explication claire du choix d’une métrique d’évaluation particulière, car la précision est presque toujours la mauvaise réponse pour analyser le taux de désabonnement
• au moins deux modèles comparés, plutôt que de dire simplement « XGBoost parce qu’il est populaire »
• des éléments permettant d’expliquer les prédictions, grâce aux valeurs SHAP, à une matrice de confusion ou aux importances des caractéristiques, afin que les prédictions du modèle puissent être justifiées

Projet de portfolio 2 : un système de recommandation

La leçon de ce projet est de penser en termes de similarité, et les embeddings ainsi que le RAG s’appuieront sur ce principe encore et encore. Créez un système de recommandation simple basé sur le contenu ou sur le filtrage collaboratif pour des films, des livres ou des produits. Comprenez que les éléments deviennent des vecteurs et que la distance entre eux peut être mesurée, car la Phase 5 revient exactement sur cette même idée.

D’autres idées de projets méritent d’être explorées une fois ces deux projets terminés.

Phase 4 : Apprentissage profond

Ici, vous découvrirez si l’apprentissage profond est fait pour vous. De nombreux autodidactes et ingénieurs en activité soit se passionnent pour ce domaine à ce stade, soit abandonnent après avoir maîtrisé les bases. Essayez-le sérieusement avant de vous décider.

Sujets clés

• Fondements des réseaux neuronaux : couches, fonctions d’activation et passes avant/arrière.
• Dynamiques d’entraînement : surajustement, régularisation, dropout et normalisation par lots.
• Optimiseurs : SGD et Adam, et pourquoi le choix est important en pratique.
• GPU : passez outre la théorie et apprenez juste assez pour comprendre pourquoi une machine chauffe lorsqu’un modèle avec des milliards de paramètres est exécuté.

Un style pédagogique visuel et ludique peut faciliter la compréhension de ce matériel, alors cherchez un cours adoptant cette approche.

PyTorch ou TensorFlow ?

Les débutants posent cette question en permanence, et la réponse courte est PyTorch. Il est désormais la norme en recherche, parmi la plupart des modèles open source modernes, ainsi que dans l’essentiel du travail d’ingénierie en intelligence artificielle en 2026. TensorFlow conserve une présence, principalement dans certains environnements d’entreprise et sur mobile via TensorFlow Lite, mais toute personne limitée à un seul framework devrait se consacrer pleinement à PyTorch. Les modèles Hugging Face, les frameworks d’agents et la plupart des codes de recherche que vous lirez reposent sur lui.

NLP, vision par ordinateur et transformateurs

Des connaissances de base sont nécessaires dans les trois domaines :

• Les fondements du NLP : tokenisation, embeddings et modèles de séquences.
• Les fondements de la vision par ordinateur : CNN, prétraitement d’images et apprentissage transféré.
• L’architecture des transformateurs : attention et auto-attention, ainsi que la raison pour laquelle cette conception spécifique explique l’existence de tous les LLM en usage aujourd’hui.

Je comprends vraiment comment fonctionne l’attention dans un modèle transformer, car tout ce qui se passe en phase 5 s’appuie sur elle. Le diagramme ci-dessous, tiré d’une discussion sur Kaggle, montre une façon de l’illustrer.

Projet de portfolio 3 : analyse du sentiment

Ajustez finement un modèle transformer préentraîné sur un ensemble de données de classification du sentiment. Une version simplifiée de BERT constitue un bon point de départ peu coûteux. Ce projet présente en miniature l’ensemble du processus moderne d’ajustement fin : charger un modèle préentraîné, tokeniser correctement les données, effectuer un ajustement fin et évaluer les résultats, ce qui correspond au même processus utilisé par les équipes de production à plus grande échelle.

Projet de portfolio 4 : transcription de réunions

Créez un pipeline bout en bout avec l’audio en entrée, une transcription en sortie et un résumé en sortie. Il combine la reconnaissance vocale, pour laquelle Whisper est évidemment le choix idéal, avec une étape de résumé grâce à un LLM. Cela constitue la première véritable application d’IA, et non simplement un modèle, et c’est un outil que vous pourrez continuer à utiliser par la suite.

Phase 5 : Ingénieur en IA

Tout ce qui a été fait jusqu’à présent vise cette phase, qui est celle où a lieu la véritable ingénierie en IA. Ceux qui se préparent à des postes dans le domaine de l’apprentissage automatique verront leur parcours diverger ici, car les phases précédentes sont communes aux voies IA et apprentissage automatique, ainsi qu’aux développeurs débutants et expérimentés.

Ingénierie du contexte

Le génie de contexte est le successeur de 2026 du génie de prompts. Un ingénieur en prompts se demande quels mots insérer dans le prompt. Un ingénieur en contexte se demande quel ensemble complet d’informations le modèle a besoin dans sa fenêtre pour accomplir la tâche correctement, qu’il s’agisse de documents récupérés, de résultats d’outils, d’historique de conversation, d’instructions système ou de mémoire, ainsi que de la manière de structurer et de prioriser tout cela. En bref, il s’agit de penser en termes de systèmes.

Concepts fondamentaux :

• Décider ce qui fait partie du contexte et ce qui constitue du bruit qui affaiblit le signal
• Structurer le contexte par ordre, mise en forme et compression afin que le modèle puisse l’utiliser efficacement
• Gérer la capacité de la fenêtre de contexte, car les tokens ne sont pas infinis et ajouter tout et n’importe quoi par précaution entraîne souvent de pires résultats

des sorties structurées, c’est-à-dire des réponses de LLM selon un schéma prédéfini tel que JSON ou Pydantic et non du texte libre, ce qui rend les applications plus fiables et plus faciles à intégrer ultérieurement

Génération augmentée par la récupération d’informations (RAG)

RAG est la technique qui permet à un LLM de répondre à des questions à partir d’informations sur lesquelles il n’a jamais été entraîné.

• Chunking : chunking naïf à taille fixe versus chunking sémantique, et pourquoi ce choix détermine indirectement la qualité de la récupération des informations.
• Embeddings et bases de données vectorielles : comment le texte devient un vecteur, ainsi que des outils tels que Pinecone, Weaviate, Chroma ou pgvector pour les stocker et les rechercher.
• Récupération : recherche de similarité, recherche hybride combinant correspondance par mots-clés et correspondance sémantique, et réclassement des résultats.
• Techniques : réécriture des requêtes pour améliorer la question de l’utilisateur avant la recherche, RAG agent où des agents planifient et récupèrent des informations de manière itérative, ainsi que Graph RAG, qui utilise des graphes de connaissances pour capturer les relations entre les entités.
• Évaluation : mesure de la qualité de la recherche et des hallucinations, et pas seulement de l’aspect visuel de la réponse finale, en utilisant des métriques telles que la précision et le rappel contextuel.

Un cours dédié au RAG vaut la peine d’être suivi, suivi plus tard de matériel sur les stratégies RAG. Un projet amusant consiste à appliquer le RAG à ses propres journaux personnels.

Model Context Protocol (MCP)

MCP offre aux applications basées sur des LLM une méthode standard pour accéder à des outils et des données externes, permettant ainsi aux équipes d’éviter d’écrire une intégration personnalisée pour chaque outil utilisé par un agent. Lorsque ChatGPT ou Claude écrit dans ou lit depuis Canva, Notion ou tout autre outil externe, c’est souvent MCP qui gère cette opération.

• Comprendre le modèle client et serveur MCP.
• Connecter un serveur MCP existant à un agent que vous avez développé.
• Créer un serveur MCP personnalisé minimal pour un outil qui n’en possède pas encore un.

Agents IA

Un agent est un système dans lequel un LLM réfléchit à un objectif, choisit un outil, agit, observe le résultat et recommence le processus, au lieu de produire une réponse statique comme un chatbot.

• Le cycle de réflexion composé de planification, d’action, d’observation et de répétition, selon des schémas de type ReAct.
• Utilisation d’outils et appels de fonctions : manière dont le modèle décide quand et quoi appeler.
• Mémoire, divisée en mémoire à court terme au sein d’une session et en mémoire à long terme entre les sessions.
• Règles de contrôle qui empêchent un agent de faire quelque chose de destructeur, coûteux ou incorrect.

Avant d’adopter un framework comme LangChain ou LangGraph, écrivez au moins un agent directement à partir d’appels API bruts. Cela montre ce qu’un framework fait à votre place, au lieu de ne vous laisser que son interface API. Les concepts ont la priorité sur les frameworks, mais il reste utile d’examiner les options modernes telles que l’OpenAI Agents SDK, LangGraph, CrewAI, Google ADK, Agno, AutoGen et Smolagents pour voir comment chacune aborde les systèmes d’agents en production.

Systèmes multi-agents

Un système multi-agents divise une tâche complexe entre plusieurs agents spécialisés qui coordonnent leurs actions. Un agent isolé rencontre des limites dans les tâches complexes à plusieurs étapes, car son contexte est surchargé, tandis qu’un agent généraliste qui fait tout finit par être médiocre dans la plupart des cas. Des spécialistes à compétences étroites disposant de leur propre contexte performent généralement mieux, de la même manière que les personnes se spécialisent.

Modèles à connaître :

• Orchestrateur-travailleur, où un agent attribue des sous-tâches à des travailleurs spécialisés.
• Pipelines séquentiels, où la sortie d’un agent devient l’entrée du suivant.
• Débat ou critique, où la sortie d’un agent est examinée et remise en question par un autre avant d’être finalisée.

Évaluation de l’IA

L’évaluation est sans doute ce qui distingue une démonstration d’un système de production, et il est impossible de trop insister sur son importance.

• Créez un ensemble de tests avec des entrées représentatives avant de livrer le produit.
• Définissez ce que signifie « bon » pour la tâche spécifique, que ce soit la correction, la fidélité aux sources consultées, le ton ou la latence.
• Utilisez des approches où l’LLM agit comme juge lorsque l’examen humain devient impossible, tout en comprenant les biais que cette méthode introduit.

Évaluer et suivre les régressions liées aux prompts, au RAG et aux workflows d’agents à l’aide d’outils tels que DeepEval, Promptfoo, LangSmith, Ragas ou Arize Phoenix.

Surveiller les régressions au fil du temps lorsque les prompts, les modèles ou la logique de récupération évoluent.

Un bon matériel pédagogique couvre des métriques telles que le score de pertinence, la précision, le rappel, ROUGE et BLEU, ainsi que des techniques d’évaluation, des outils et des frameworks.

LLMOps

Lorsque les systèmes d’IA deviennent des applications en production, LLMOps devient de plus en plus important. Il englobe la gestion des versions des prompts, l’acheminement des modèles, le traçage et l’observabilité, le suivi des coûts, le cache et le suivi des expériences, tout cela dans le but de créer des systèmes fiables et scalables.

Déploiement des applications d’IA

Les bases du déploiement à connaître :

• API : envelopper le modèle ou l’agent avec FastAPI ou un outil similaire.
• Conteneurs : Docker, suffisamment pour comprendre pourquoi il existe et comment l’utiliser.
• Inférence et déploiement : vLLM pour un déploiement à haut débit des modèles de langage, et LiteLLM pour acheminer les requêtes vers plusieurs fournisseurs via une seule interface.
• Cloud : déployez en mode bout en bout auprès du fournisseur que vous connaissez le mieux.
• Surveillance et coûts : chaque token coûte de l’argent, donc en environnement de production il est nécessaire de disposer d’une visibilité sur la latence ainsi que sur les coûts, une compétence très recherchée par les employeurs.
• Principes de CI/CD pour automatiser les pipelines de déploiement.

Erreurs courantes des débutants

• Passer directement aux modèles de langage et aux agents en sautant les phases 1 à 3.
• Considérer des frameworks comme LangChain comme des choses à apprendre en soi, plutôt que comme des couches basées sur des concepts qui doivent d’abord être compris.
• Collecter des tutoriels au lieu de créer des projets. Regarder ne suffit pas, et c’est là que la plupart des gens stagnent silencieusement.
• Reporter l’évaluation à plus tard. Construire le pipeline d’évaluation en tant que partie intégrante du projet afin que chaque petite modification montre si les choses se sont améliorées ou détériorées.

La version courte

Devenir ingénieur en IA ne signifie pas maîtriser chaque nouvel outil. De solides fondements, appliqués de manière constante, comptent davantage.

Pour ceux qui cherchent une référence concernant l’aspect Claude Code de ce travail, le sommaire ci-dessous montre comment un guide détaillé divise ses chapitres en sujets pratiques tels que les agents, RAG, les serveurs MCP et l’évaluation.