Formation IA Générative : LLM, RAG et Agents

Cette section est une formation gratuite à l'IA générative avec Python, composée de 32 guides pratiques répartis en quatre parcours : comprendre, exécuter, construire un RAG, industrialiser. 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 ?

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 32 guides : 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.

Les quatre parcours

Les 32 guides se répartissent en quatre parcours : Comprendre (7 guides), Exécuter (9 guides), Construire un RAG (10 guides) et Industrialiser (7 guides). Le proxy LiteLLM apparaît dans deux parcours, ce qui explique l'écart avec la somme. Ils se suivent dans l'ordre pour un apprentissage progressif, mais chacun se lit aussi indépendamment selon votre besoin.

Parcours 1, Comprendre

Avant de manipuler un outil, il faut un modèle mental correct. Ce parcours pose les fondations : ce qu'est un LLM, comment il génère du texte, ce que coûte l'inférence, et comment un modèle se compresse.

Panorama IA, la vue d'ensemble.
Anatomie d'un LLM, tokens, attention, entraînement.
Prompt engineering et prompting avancé.
Comprendre l'inférence d'un LLM, prefill, decode, KV cache.
Servir un LLM : batching et débit.
Comprendre la quantification.

Parcours 2, Exécuter

Comprendre ne suffit pas : il faut faire tourner un modèle. Ce parcours couvre l'appel d'un LLM depuis Python, l'exécution locale et le serving GPU de production.

LiteLLM, appeler n'importe quel LLM depuis Python, et son proxy.
Ollama et llama.cpp, l'inférence locale.
Hugging Face Transformers, charger des modèles open source.
vLLM et SGLang, le serving GPU.
Comparatif des backends d'inférence et quantification pratique.

Parcours 3, Construire un RAG

Un LLM ne connaît que ses données d'entraînement. Le RAG (Retrieval-Augmented Generation) lui donne accès à vos documents. Ce parcours suit la chaîne complète : un RAG raté vient presque toujours de l'ingestion ou du découpage, rarement du choix de la base vectorielle.

Introduction au RAG, le principe.
Extraire du contenu web et nettoyer les textes.
Chunking et indexation, embeddings.
Bases vectorielles : FAISS et Chroma.
RAG par la pratique, RAG avancé et RAG en production.

Parcours 4, Industrialiser

Un prototype qui marche sur votre poste n'est pas une application exploitable. Ce parcours traite le passage à l'échelle : routage multi-modèles, interface, et, sujets en cours d'enrichissement, observabilité, évaluation, sécurité et agents.

LiteLLM Proxy Server, la passerelle LLM gouvernée : clés, budgets, routage.
Construire des agents IA, le parcours complet : la boucle à la main, le function calling, PydanticAI et LangGraph.
Comprendre le MCP et créer un serveur MCP, connecter les agents aux outils.
Chainlit, donner une interface à votre assistant.
reShapr, exposer une API comme serveur MCP.
Optimiser vos docs pour l'IA générative.

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 venv et pip.

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

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 parcours « Comprendre », puis « Exécuter ». L'objectif est de faire tourner votre premier LLM et de saisir ce qui se passe.
Intermédiaire : vous savez appeler un LLM. Visez « Construire un RAG » et le comparatif des backends pour passer du script jouet à une application structurée.
Avancé : votre enjeu est la production. Le parcours « Industrialiser », le serving GPU et la quantification sont pour vous.

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

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 parcours 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

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.

Questions fréquentes

Faut-il un GPU pour suivre cette formation ?

Non. Toute la partie « Comprendre » et une grande part d'« Exécuter » tournent sur CPU (Ollama, llama.cpp). Le GPU ne devient nécessaire que pour le serving haute performance.

Faut-il connaître le machine learning ?

Non. Cette section porte sur l'usage des modèles génératifs, pas sur leur entraînement. Des bases de Python suffisent.

RAG ou fine-tuning pour mes données ?

Dans la grande majorité des cas, RAG : plus simple, moins cher, et les données restent à jour. Le fine-tuning vise surtout le style ou un format de sortie, pas l'apport de connaissances.

Quel modèle local choisir pour commencer ?

Un modèle 7B à 14B quantifié (Qwen, Llama) via Ollama est un excellent point de départ : il tient sur un poste correct et suffit pour apprendre.

Pour aller plus loin

Panorama IA : La carte mentale de l'écosystème avant d'entrer dans le détail.
Anatomie d'un LLM : Ce qui se passe réellement à l'intérieur du modèle.
Comparatif des backends d'inférence : Choisir l'outil qui exécutera vos modèles.
Introduction au RAG : Faire répondre un LLM sur vos propres documents.