Cette section est une formation gratuite à l'IA générative avec Python : 75 leçons réparties en sept modules et trois niveaux, qui mènent d'un premier modèle de langage à une stack d'agents observée et sécurisée. Elle est écrite avec un angle assumé, celui d'un ingénieur infrastructure et sécurité : l'objectif n'est pas d'appeler une API, c'est de comprendre, servir, sécuriser et exploiter des applications IA, du modèle de langage jusqu'à la production, en open source et auto-hébergeable.
Appeler une API de LLM prend cinq minutes. Comprendre pourquoi votre agent hallucine, pourquoi votre RAG répond à côté ou pourquoi votre serveur d'inférence sature, c'est une autre affaire. Cette section vise la seconde compétence, celle qui tient en production, et c'est ce qui explique qu'elle commence par les concepts plutôt que par un premier appel d'API.
Par où commencer en IA générative ?
Section intitulée « Par où commencer en IA générative ? »Le chemin le plus court va du panorama au premier RAG en quatre étapes, soit environ 1 h 25 de lecture et de manipulation ; la cinquième relève déjà de la mise en production. Ce n'est pas un raccourci qui remplace les 75 leçons : c'est l'ordre dans lequel les prendre pour obtenir quelque chose qui tourne avant de creuser. Lisez le tableau de haut en bas, chaque ligne suppose la précédente acquise.
| Étape | Guide | Durée | Ce que vous obtenez |
|---|---|---|---|
| 1. Situer les briques | Panorama IA | 10 min | Une carte mentale : LLM, RAG, agents, tool calling, MCP |
| 2. Comprendre le modèle | Anatomie d'un LLM et l'inférence | 25 min | Tokens, attention, prefill, decode, KV cache |
| 3. Faire son premier appel | Ollama ou LiteLLM | 20 min | Un modèle qui répond depuis Python |
| 4. Construire un RAG | RAG par la pratique | 30 min | Un LLM qui répond sur vos propres documents |
| 5. Servir en production | vLLM ou llama.cpp | variable | Une API d'inférence dimensionnée pour votre matériel |
Le choix de l'étape 5 dépend uniquement du matériel : vLLM exige un GPU et vise le débit sous charge, llama.cpp tourne sur CPU et vise la frugalité. Le comparatif des backends d'inférence détaille cet arbitrage.
Que contient la formation ?
Section intitulée « Que contient la formation ? »La formation compte 75 leçons réparties en sept modules, soit environ 44 heures annoncées par le plan de cours. Le plan de cours, dans la colonne de gauche, en donne la liste complète ; cette page en donne la logique. Elle suit un fil unique : comprendre le modèle, le faire tourner, lui donner vos documents, puis le laisser agir et l'exploiter sans perdre le contrôle.
| Module | Leçons | Durée annoncée | Ce que vous y faites |
|---|---|---|---|
| Introduction | 2 | 28 min | Situer la formation (cette page) et suivre votre progression |
| Fondamentaux | 4 | 2 h 50 | Construire le modèle mental : LLM, tokens, prompts |
| Inférence | 21 | 13 h 55 | Faire tourner et servir un modèle, en local ou sur GPU |
| RAG | 16 | 8 h 20 | Faire répondre un modèle à partir de vos documents |
| Agentique | 24 | 14 h 20 | Donner des outils au modèle : agents, MCP, interface |
| Fil rouge, stack souveraine | 5 | 3 h 10 | Assembler l'ensemble en une stack auto-hébergée |
| Observabilité, évaluation et sécurité | 3 | 1 h 30 | Tracer, évaluer et sécuriser l'application |
Ces sept modules se regroupent en trois niveaux, que le plan de cours affiche tels quels. Chaque niveau se lit dans l'ordre pour un apprentissage progressif, mais se consulte aussi indépendamment selon votre besoin.
Niveau 1, intégrer un LLM
Section intitulée « Niveau 1, intégrer un LLM »Avant de manipuler un outil, il faut un modèle mental correct. Les modules Fondamentaux et Inférence posent d'abord ce qu'est un LLM, comment il génère du texte et ce que coûte l'inférence : Panorama IA, Anatomie d'un LLM, prompt engineering, puis l'inférence et la quantification.
Comprendre ne suffit pas : il faut ensuite faire tourner un modèle. Le module Inférence l'appelle depuis Python avec LiteLLM et son proxy, l'exécute en local avec Ollama (installation, dépannage et SDK Python) et llama.cpp, puis le sert sur GPU avec vLLM et SGLang. Le comparatif des backends d'inférence aide à trancher.
Niveau 2, construire un RAG
Section intitulée « Niveau 2, construire un RAG »Un LLM ne connaît que ses données d'entraînement. Le RAG (Retrieval-Augmented Generation, génération augmentée par la recherche) lui donne accès à vos documents. Le module RAG suit la chaîne complète, de l'introduction au RAG à RAG en production, en passant par l'extraction de contenu web, le chunking, les embeddings et les bases vectorielles comme FAISS ou Chroma. Un RAG raté vient presque toujours de l'ingestion ou du découpage, rarement du choix de la base vectorielle.
Le module se termine par la question qui se pose une fois le RAG compris : faut-il fine-tuner le modèle, ou s'en passer ? La leçon donne l'arbre de décision entre prompt, RAG et fine-tuning.
Niveau 3, construire des agents et une stack complète
Section intitulée « Niveau 3, construire des agents et une stack complète »Un prototype qui marche sur votre poste n'est pas une application exploitable. Le module Agentique apprend à construire des agents (le parcours agents IA) et à les relier à des outils par le protocole MCP (comprendre le MCP, créer un serveur MCP), avec une interface Chainlit ou une API exposée par reShapr.
Le fil rouge assemble ensuite ces briques en une stack souveraine auto-hébergée. Le dernier module la rend exploitable : observer un LLM, tracer avec OpenTelemetry GenAI et sécuriser l'application. Rendre vos propres documents citables par les moteurs d'IA relève d'une autre formation : Écrire pour les IA, une leçon facultative de la formation Documenter.
Prérequis
Section intitulée « Prérequis »Inutile d'être expert. Quelques bases suffisent pour suivre les exemples et réaliser les labs.
- Python : variables, boucles, conditions, fonctions. Tout est couvert dans la section Python du site.
- Ligne de commande : les commandes de base,
cd,ls,mkdir, navigation dans un terminal. - Environnements virtuels : savoir isoler des dépendances avec
venvetpip.
Côté outils, prévoyez Python 3.12, un éditeur (VSCode convient bien) et Docker pour les services self-hosted. Toute la section reste utilisable hors ligne, sur CPU ou GPU, et sans cloud commercial.
À qui s'adresse cette section
Section intitulée « À qui s'adresse cette section »Cette section s'adresse aux développeurs et aux profils infrastructure qui savent écrire du Python et veulent exploiter des LLM en autonomie, sans dépendre d'un fournisseur cloud. Le contenu sert trois profils, à des profondeurs différentes.
- Débutant : commencez par le niveau 1. L'objectif est de faire tourner votre premier LLM et de saisir ce qui se passe.
- Intermédiaire : vous savez appeler un LLM. Visez le niveau 2 (construire un RAG) et le comparatif des backends pour passer du script jouet à une application structurée.
- Avancé : votre enjeu est la production. Le niveau 3, le serving GPU et la quantification sont pour vous.
Mon parti pris : l'IA générative vue côté infra
Section intitulée « Mon parti pris : l'IA générative vue côté infra »La plupart des formations IA s'arrêtent à « comment appeler OpenAI ». C'est le début, pas la fin. Ce qui m'intéresse, et ce que je pratique, c'est ce qui vient après : faire tenir un modèle sur le bon matériel, mesurer son débit réel, le sécuriser, le mettre en production sans se ruiner ni exposer ses secrets.
C'est pourquoi cette section privilégie l'open source self-hostable. Non par dogmatisme, mais parce qu'un ingénieur infra a besoin de comprendre et contrôler sa pile, pas de la louer en boîte noire. Tous les outils présentés tournent sur votre machine ou votre serveur.
Ce que cette section défend
Section intitulée « Ce que cette section défend »Cinq positions structurent le contenu et expliquent des choix que vous retrouverez dans chaque guide, du plan des chapitres au choix des outils présentés.
- Comprendre avant d'outiller. Choisir entre vLLM et llama.cpp sans savoir ce qu'est le prefill ou le KV cache, c'est choisir au hasard. Les modules commencent toujours par les concepts.
- Mesurer, pas croire. Les chiffres de débit et de qualité de ces guides sont relevés en lab, pas recopiés d'une plaquette commerciale. Un bench reproductible vaut mille promesses.
- L'ingestion fait le RAG. Un RAG décevant se répare presque toujours en amont, extraction, nettoyage, découpage, pas en changeant de base vectorielle.
- La sécurité dès le départ. Prompt injection, fuite de secrets dans les prompts, agent trop permissif : ces risques se traitent à la conception, pas après l'incident.
- Le coût est une métrique d'ingénierie. Tokens, cache, choix du modèle : une application LLM se pilote au budget comme n'importe quel système.
Ce que je vous déconseille
Section intitulée « Ce que je vous déconseille »Quatre erreurs reviennent systématiquement chez ceux qui découvrent l'IA générative. Les deux premières coûtent du temps, les deux dernières coûtent de l'argent ou des données.
- Coller du code LLM sans le comprendre. Un exemple trouvé en ligne qui « marche » cache souvent un coût, une latence ou une faille que vous découvrirez en production.
- Mettre un agent en production sans garde-fous. Un agent qui exécute des actions doit avoir des permissions limitées, une validation humaine sur les opérations sensibles et un périmètre clair. Un agent DevOps n'est jamais un script root avec un LLM au volant.
- Croire qu'un gros modèle résout tout. Un modèle plus gros est plus lent et plus cher. Souvent, un modèle moyen bien outillé (RAG, bons prompts) fait mieux qu'un géant lâché seul.
- Envoyer n'importe quoi dans un prompt. Secrets, données personnelles, code propriétaire : ce qui entre dans un prompt peut ressortir, être journalisé, ou servir ailleurs. Traitez le prompt comme une frontière de confiance.