Courses to Take — Ordered Path
External courses are the engine of this learning path. The markdown files in this repo are the GPS — these courses are what you actually study and code along with.
Total time: ~13 weeks at 5-8h/week. Run in parallel with project builds.
🧭 Mental model — pourquoi cet ordre (lis ça avant tout le reste)
Un dev de 7 ans qui passe à l'IA agentique a un piège : collectionner des certificats au lieu de construire un modèle mental. Les recruteurs seniors ne te paient pas pour avoir suivi 15 cours — ils te paient pour savoir quand utiliser quoi, combien ça coûte, et comment ça casse en prod. Cette liste est ordonnée autour d'une thèse, pas d'un catalogue.
La thèse : tu montes la pile dans l'ordre où la valeur business arrive.
Prompting & API brute → RAG → Agents & MCP → Voice → Cert cloud
(parle au modèle) (ground-le) (donne-lui des (interface (signal ESN)
mains) temps réel)
semaine 2 semaine 6 semaine 12 semaine 18 semaine 23
coût ~0 coût infra coût × latence coût × concurrence coût examChaque étage suppose le précédent. Un agent (étage 3) sans maîtrise du prompting et du coût par token (étage 1) produit des boucles d'outils qui brûlent plusieurs dollars par requête sans que tu saches pourquoi. Un système RAG (étage 2) sans compréhension de l'éval (cours #5) est un générateur d'hallucinations confiantes. Ne saute pas d'étage pour faire joli sur LinkedIn.
Le coût par token : le réflexe que personne n'enseigne dans ces cours
Aucun de ces cours ne te fera vraiment internaliser le coût. C'est pourtant le premier chiffre qu'un staff engineer a en tête avant d'écrire une ligne. Garde cette grille de référence 2026 sous les yeux pendant tout le parcours — c'est elle qui transforme « ça marche » en « ça marche en prod sans ruiner la boîte » :
| Modèle (alias API) | Rôle | Input $ / Mtok | Output $ / Mtok | Quand un senior le choisit |
|---|---|---|---|---|
claude-opus-4-8 | Flagship (Opus 4.8) | 5 | 25 | Raisonnement dur, agents long-horizon, code review, build |
claude-sonnet-4-6 | Milieu de gamme | 3 | 15 | 80 % du travail : RAG, extraction, chat, orchestration |
claude-haiku-4-5 | Économique | 1 | 5 | Classif, routing, sous-agents, pré-filtrage, gros volume |
Trois réflexes que tu dois avoir avant la fin du parcours, et qu'aucun cours n'insiste assez :
- L'output coûte ~5× l'input. Un prompt de 50k tokens qui sort 500 tokens coûte surtout… l'input. Mais une boucle d'agent qui génère 20 réponses de 4k tokens chacune, c'est l'output qui te tue. Optimise le bon côté.
- Le prompt caching divise l'input par ~10 sur le préfixe stable (système + outils + few-shot). Un système RAG sans cache sur son préfixe paie plein tarif à chaque requête — c'est la première chose qu'un senior audite (
usage.cache_read_input_tokensà zéro = bug silencieux). - Le bon modèle par étage, pas le flagship partout. Router une classification triviale vers Opus 4.8, c'est payer 5× le prix de Haiku pour un résultat identique. Le pattern « Haiku trie → Sonnet traite → Opus tranche les cas durs » est la base de toute archi rentable.
⚠️ Hygiène de fraîcheur des identifiants. Les cours ci-dessous datent : tu y verras des
gpt-4, des anciens IDs Claude, des prix périmés. Ne copie jamais un model id depuis un notebook de cours sans le vérifier. Pour Claude en 2026, les seuls alias valides sontclaude-opus-4-8,claude-sonnet-4-6,claude-haiku-4-5(sans suffixe de date). Le paramètretemperature/top_pet l'ancienthinkingavecbudget_tokenssont retirés sur Opus 4.8/4.7 (HTTP 400) : on utilise désormais l'adaptive thinking (thinking: {type: "adaptive"}) +output_config: {effort: ...}. Si un cours t'apprend la syntaxebudget_tokens, c'est du legacy — note-le et passe à l'adaptive.Le levier
effort(le vrai bouton coût/intelligence en 2026). Ce n'est pas binairelow/high— l'échelle complète estlow<medium<high<xhigh<max(lexhighintroduit avec Opus 4.7, etmaxréservé à l'Opus-tier et Sonnet 4.6, pas Haiku). Le réflexe senior :highpar défaut,xhighpour le code et l'agentique long-horizon,medium/lowpour le travail trivial et les sous-agents. Le piège que ces cours n'enseignent pas : sur Opus 4.8, uneffortplus élevé en amont réduit souvent le nombre de tours et le coût total sur une tâche agentique (le modèle planifie mieux et boucle moins), alors qu'unefforttrop bas sur un raisonnement dur produit du sous-raisonnement qu'il faut re-prompter.effortn'est donc pas un curseur de coût linéaire — c'est un arbitrage intelligence × latence × tokens à recalibrer par route, pas une constante globale.
Le piège du framework vs. la primitive
La majorité de ces cours enseignent un framework (LangChain, LangGraph, crewAI). Un staff engineer apprend le framework pour deux raisons seulement : (1) déboguer le code legacy d'un client, (2) comprendre quelle primitive le framework cache. La primitive sous LangChain/LangGraph, c'est une boucle while autour de messages.create() avec tool-use. La primitive sous un « vector store », c'est un produit scalaire sur des embeddings normalisés. Apprends le framework, mais garde toujours en tête : « si je devais réimplémenter ça en 50 lignes avec le SDK brut, qu'est-ce que je perdrais ? » La réponse est presque toujours « du state management et du logging », jamais « de la magie ».
⚠️ Avertissement de fraîcheur (2026). Le paysage des frameworks d'agents bouge vite. LangGraph est populaire mais n'est pas un standard universel — beaucoup d'équipes sérieuses shippent en SDK brut + MCP (le protocole d'intégration outil↔agent), ou avec des Managed Agents côté provider. Apprends LangGraph pour la culture et le legacy, mais ta valeur marché vient de savoir construire la boucle agentique toi-même et de la rendre observable.
Les trois niveaux d'abstraction agentique, et quand un staff engineer descend d'un cran
Un cours te jette dans un framework sans te montrer le spectre complet. Le voici, du plus brut au plus managé :
| Niveau | Ce que tu écris | Tu le choisis quand… |
|---|---|---|
Appel unique (messages.create) | Une requête, une réponse. Classif, extraction, résumé, Q&A. | La tâche tient en un aller-retour. 80 % des « features IA » sont ici — ne sur-architecture pas. |
| Workflow (boucle de code + outils) | Toi qui orchestres la boucle while stop_reason == "tool_use", tool-results renvoyés. | Le pipeline est multi-étapes mais déterministe — tu sais à l'avance la séquence d'outils. |
| Agent ouvert (le modèle décide sa trajectoire) | Même boucle, mais le modèle choisit quels outils et dans quel ordre. | La tâche est vraiment ouverte et difficile à spécifier d'avance (« transforme ce design doc en PR »). |
Le réflexe staff : descends au niveau le plus simple qui résout le problème. Router une classification triviale vers une boucle d'agent ouverte, c'est payer la latence et le coût d'un agent pour ce qu'un messages.create() faisait. Le test à quatre questions avant de construire un agent : (1) la tâche est-elle multi-étapes et difficile à spécifier ? (2) la valeur justifie-t-elle le coût et la latence ? (3) le modèle en est-il capable ? (4) le coût d'une erreur est-il rattrapable (tests, review, rollback) ? Un « non » à l'une des quatre = reste à un niveau plus simple. Un cours qui te fait construire un multi-agent crewAI pour résumer un PDF t'a appris le comment sans le quand — c'est exactement le trou que tu combles.
Note 2026 — les Managed Agents. Une quatrième option existe désormais côté provider : tu déclares un agent (modèle, system, outils, MCP) une fois, puis tu lances des sessions qui tournent dans un conteneur géré par le provider (la boucle agentique tourne sur l'orchestration du provider, les outils s'exécutent dans un sandbox). C'est le « serverless de l'agent ». Tu n'as pas à connaître l'API par cœur, mais tu dois savoir que ça existe et le distinguer du SDK brut : le SDK brut quand tu veux héberger le compute et maîtriser la boucle ; les Managed Agents quand tu veux que le provider gère la boucle + le sandbox d'exécution. C'est un sujet de discussion d'archi en entretien senior.
Phase 1 — Fundamentals (weeks 2-5)
1. Anthropic Prompt Engineering Tutorial 🚀 START HERE
- Time: 1 week (5-7h)
- Cost: Free
- Link: Anthropic Prompt Engineering Interactive Tutorial
- Why: Foundation for working with Claude (which you'll use heavily). Hands-on with real prompting patterns.
- Output to produce:
- [ ] Notebook with 10 prompt patterns you tested
- [ ] LinkedIn post: "10 things I learned from Anthropic's prompt engineering course"
2. DeepLearning.AI — Generative AI with LLMs (Coursera Specialization)
- Time: 3 weeks (10h/week)
- Cost: ~$49/month Coursera (1 month is enough)
- Link: Coursera — Generative AI with LLMs
- Why: Solid theory foundation. Tokenization, attention, fine-tuning concepts, RLHF. You don't need to do fine-tuning IRL but understanding the concepts matters for credibility.
- Output to produce:
- [ ] All quizzes passed
- [ ] Final lab notebook archived
- [ ] Coursera certificate added to LinkedIn
3. HuggingFace NLP Course — Chapters 1-4
- Time: 2 weeks (5h/week)
- Cost: Free
- Link: HuggingFace NLP Course
- Why: Embeddings, tokenizers, transformers — practical hands-on with the dominant ML library.
- Output:
- [ ] Embedding comparison script (chapter exercises)
- [ ] 1 model fine-tuned on a small dataset (chapter 3 exercise)
Phase 2 — RAG Production (weeks 6-11)
4. DeepLearning.AI — LangChain for LLM Application Development
- Time: 1 week (5h)
- Cost: Free
- Link: DL.AI — LangChain for LLM Apps
- Why: Get up to speed on LangChain basics. Even if you ship with raw SDK + MCP later, you need to know LangChain to debug client codebases.
- Output:
- [ ] Notebooks completed
- [ ] Simple Q&A bot built (50 lines)
5. DeepLearning.AI — Building and Evaluating Advanced RAG
- Time: 1 week (5h)
- Cost: Free
- Link: DL.AI — Building Evaluating Advanced RAG
- Why: Sentence-window retrieval, auto-merging, evaluation triad. Production patterns.
- Output:
- [ ] Triad eval script working on your own data
- [ ] Notes integrated into
02-rag-production/03-eval-observability.md
6. DeepLearning.AI — Preprocessing Unstructured Data for LLM Applications
- Time: 1 week (3h)
- Cost: Free
- Link: DL.AI — Preprocessing Unstructured Data
- Why: Chunking, PDF/HTML/image extraction. Real-world RAG dies on bad preprocessing.
- Output:
- [ ] Preprocessing pipeline reusable for project 1
7. Pinecone Learning Center — RAG Fundamentals
- Time: Self-paced (2-3h)
- Cost: Free
- Link: Pinecone Learning
- Why: Best-written vendor docs on RAG. Even if you use pgvector, read this.
Phase 3 — Agentic + MCP (weeks 12-17)
8. DeepLearning.AI — AI Agents in LangGraph
- Time: 1 week (5h)
- Cost: Free
- Link: DL.AI — AI Agents in LangGraph
- Why: LangGraph est un framework d'agents répandu (pas un standard universel — voir l'avertissement de fraîcheur plus haut). Ce que tu viens vraiment y chercher : le modèle mental de la machine à états (nœuds + arêtes conditionnelles), du checkpointing (reprendre une boucle après crash) et de la mémoire de thread. Garde le réflexe primitive : sous chaque nœud, il y a un
messages.create(); sous chaque arête conditionnelle, unif stop_reason == "tool_use". Tu apprends le framework pour débugger du legacy client, pas pour en dépendre. - Output:
- [ ] Multi-step agent built (search + summarize + write)
9. DeepLearning.AI — Functions, Tools and Agents with LangChain
- Time: 1 week (3h)
- Cost: Free
- Link: DL.AI — Functions Tools Agents
- Why: Tool use, function calling, OpenAI-style agents. Foundational concepts.
10. Anthropic — Build with Claude (MCP focus)
- Time: 1 week (4-6h)
- Cost: Free
- Link: Anthropic MCP Docs + Anthropic Cookbook
- Why: CRITICAL 2026 SKILL. MCP (Model Context Protocol) est le protocole standardisé d'intégration outil↔agent — la primitive sous la plupart des « managed agents » côté provider. Un serveur MCP expose des capabilities (GitHub, Linear, ta base interne) qu'un agent consomme sans que tu recodes une couche de glue par client. Sache distinguer les deux moitiés du modèle de sécurité : le serveur déclare l'URL et le schéma, jamais le secret ; l'auth (OAuth, bearer) vit dans un vault côté provider et n'entre jamais dans le sandbox de l'agent. C'est exactement ce qu'un recruteur senior te fera dessiner au tableau. (Le « 78 % des équipes en prod » qui traînait ici était un chiffre inventé — un senior ne cite pas une stat qu'il ne peut pas sourcer ; on a viré.)
- Output:
- [ ] 1 MCP server built (matches project 2 spec)
- [ ] Schéma au tableau : agent → orchestration layer → tool call → vault injecte le secret à l'egress, le sandbox ne voit qu'un placeholder
11. DeepLearning.AI — Multi AI Agent Systems with crewAI
- Time: 1 week (3h)
- Cost: Free
- Link: DL.AI — crewAI Multi-Agent
- Why: Alternative paradigm to LangGraph. Useful to know — some clients use crewAI.
Phase 4 — Voice Agents (weeks 18-22)
12. OpenAI Realtime API — Official Docs + Tutorial
- Time: 1 week (4h)
- Cost: Free (+ small API usage)
- Link: OpenAI Realtime API Docs
- Why: Direct path to production voice agents. Cedar/Marin voices, low latency.
13. LiveKit Agents — Documentation + Quickstart
- Time: 1 week (5h)
- Cost: Free
- Link: LiveKit Agents Quickstart
- Why: Production-grade WebRTC + AI agents. Voice + video. The pattern serious teams use.
14. ElevenLabs Conversational AI — Demo + Docs
- Time: 2-3h hands-on
- Cost: Free tier
- Link: ElevenLabs Conversational AI
- Why: Best voice quality. Premium option for paid demos.
Phase 5 — Cloud Cert (weeks 23-26)
15. GCP Generative AI Leader — Skills Boost Path
- Time: 3-4 weeks (5h/week)
- Cost: ~$30 Skills Boost subscription + $99 exam
- Link: Skills Boost Generative AI Path
- Why: Filter signal for enterprise/ESN missions.
- Output:
- [ ] All modules completed
- [ ] Exam passed
- [ ] Cert added to LinkedIn
Always-on Reading (background)
Not "courses" but read regularly while learning :
- Anthropic blog + research : anthropic.com/research
- OpenAI blog : openai.com/blog
- LangChain blog : blog.langchain.dev
- HuggingFace blog : huggingface.co/blog
- AI Engineer newsletter (Swyx) : latent.space
- Sequoia / a16z AI essays — track market trends
- r/LangChain, r/LocalLLaMA — pulse from practitioners
How to actually do this
- One course at a time. No parallel courses. Finish before starting next.
- Code along. Skip a course's exercises = you didn't take the course.
- Take notes in
_notes/of this repo. 1 markdown per course with takeaways. - Post about each course on LinkedIn when finished. Reinforces learning + builds audience.
- Skip what you already know. If you already understand attention/transformers, skim DL.AI course faster.
Total cost estimate
| Item | Cost |
|---|---|
| Coursera 2-3 months | ~$100 |
| GCP Skills Boost (1 month) | ~$30 |
| GCP exam | ~$99 |
| API usage (testing) | ~$50-100 |
| TOTAL | ~$280-330 |
ROI : 1 mission at €5k = 17× return.
⚠️ Le coût caché qui manque dans ce tableau : l'API usage en mode agent. Les ~50-100 $ ci-dessus supposent du prompting et du RAG sage. Dès que tu attaques l'étage 3 (agents, projet 2, cours #8-11), une seule boucle d'agent mal bornée peut brûler ton budget mensuel en une après-midi de debug — une boucle d'outils qui tourne en rond à 25 $/Mtok d'output sur Opus 4.8, ça monte vite. Mitige dès le premier agent : (1)
max_tokensbas et un compteur d'itérations qui coupe la boucle, (2) route le travail trivial versclaude-haiku-4-5, (3)effort: "low"sur les sous-tâches, (4) prompt caching sur le préfixe système+outils, (5) logusageà chaque appel et regarde la facture avant de dormir. Un staff engineer ne « découvre » jamais sa facture le 1er du mois.
🎓 Comment un staff engineer juge un cours (méta-compétence)
Tu vas suivre 15 cours. Le risque n'est pas d'en apprendre trop peu, c'est d'en absorber le périmé sans filtre. Applique cette grille à chaque cours, surtout les plus anciens (DL.AI, HuggingFace) :
| Signal dans le cours | Ce qu'un senior en fait |
|---|---|
Un model="..." codé en dur | Suspect par défaut. Vérifie l'alias actuel, ne copie jamais aveuglément. |
temperature=0 « pour du déterministe » | Sur les modèles 2026 (Opus 4.8/4.7), le param est retiré → 400. Le déterminisme se pilote par prompt + effort: "low". |
| Prompt XML/JSON hand-rolled pour forcer un format | Remplacé par les structured outputs natifs (messages.parse() + schéma Pydantic/Zod, ou output_config.format). |
thinking avec budget_tokens | Legacy. C'est l'adaptive thinking maintenant (thinking: {type: "adaptive"} + effort). |
| « le vector store fait de la magie » | Non : produit scalaire sur embeddings normalisés. Sache réimplémenter en 30 lignes. |
| Pas un mot sur le coût/token, la latence, le caching | Le trou exact que tu dois combler toi-même — c'est là qu'est ta valeur marché. |
requests.post(...) à la main vers une API LLM | En Python/TS, utilise le SDK officiel (retries typés, streaming, exceptions typées). Le raw HTTP n'est justifié qu'en shell/cURL. |
La règle d'or : un cours t'apprend un modèle mental, jamais une vérité d'API. Le modèle mental (qu'est-ce qu'une attention, un embedding, une machine à états d'agent) ne périme pas. L'API (le model id, le prix, la syntaxe du thinking) périme tous les trois mois — c'est ta doc de référence qui fait foi, pas le notebook de 2024.
Production-readiness : la checklist que ces cours n'ont pas
Aucun de ces cours ne te fera shipper du production-grade. Voici les 5 axes qu'un senior ajoute par-dessus, et que tes projets doivent démontrer :
- Coût —
usageloggé à chaque appel, prompt caching sur le préfixe stable, routing multi-modèle (Haiku → Sonnet → Opus),effortcalibré. Tu dois pouvoir défendre le chiffre de ta facture. - Latence — streaming pour tout output long ou
max_tokensélevé (sinon timeout HTTP du SDK), appels d'outils parallèles viaasyncio.gather, sous-agents Haiku pour le fan-out. - Observabilité — trace par requête,
stop_reasoninspecté (end_turn/tool_use/max_tokens/refusal),usage.cache_read_input_tokenssurveillé (zéro = cache cassé silencieusement). Le piège du débutant : croire queinput_tokensest le total. Faux —input_tokensest le reste non caché. Le vrai total =input_tokens + cache_creation_input_tokens + cache_read_input_tokens. Un agent qui a tourné des heures avecinput_tokensà 4k n'a pas un bug d'affichage : le reste a été servi du cache. Regarde la somme, pas le champ isolé. - Sécurité — secrets jamais dans le prompt ni le system (ils persistent dans l'historique de session, relisibles via l'API), MCP auth en vault (le secret est injecté à l'egress côté provider, jamais dans le sandbox), validation des entrées d'outils, confirmation humaine sur les actions destructrices et non-réversibles. Le réflexe : promouvoir une action en outil dédié (et non
bash) dès qu'elle doit être gatée, auditée ou rendue — unsend_emailtypé se gate, unbash -c "curl -X POST..."ne se gate pas. - Scale —
AsyncAnthropiccôté serveur,max_retries+ backoff surRateLimitError/OverloadedError/APITimeoutError, batch API (-50 %) pour le non-latency-sensitive, idempotence des outils à effet de bord. Pour les conversations longues : prompt caching sur le préfixe stable (gain ~10× sur l'input, mais attention — tout changement d'octet dans le préfixe, undatetime.now()dans le system, invalide tout ce qui suit), et compaction server-side quand on approche la fenêtre de contexte.
🏋️ Exercices
Ces exercices ne sont pas « change une constante ». Ils sont conçus pour révéler ce que les cours cachent : le coût, les modes de panne, la défense du chiffre. Fais-les en parallèle des cours correspondants, pas après.
Exercice 1 — Le filtre anti-périmé (après cours #1)
Objectif : prouver que tu sais distinguer un modèle mental durable d'une vérité d'API périmée.
Prends 3 notebooks de cours de cette liste (DL.AI LangChain, HuggingFace ch.3, un cookbook). Pour chacun, dresse un tableau à deux colonnes : « ce qui ne périme pas » (concept) vs « ce qui a déjà périmé » (model id, prix, syntaxe). Corrige chaque ligne périmée vers l'état 2026 (alias d'aujourd'hui, structured outputs natifs, adaptive thinking). Indice/Solution : le tell le plus fréquent est un model="gpt-..." ou un ancien id Claude codé en dur, et un format de sortie forcé par prompt XML au lieu d'un schéma natif. Si tu ne trouves rien à corriger dans un notebook de 2024, tu n'as pas regardé assez fort.
Exercice 2 — Réimplémente la primitive (après cours #4)
Objectif : démystifier le framework en réécrivant sa primitive en SDK brut.
Reproduis le « Q&A bot » du cours #4 (LangChain), puis réécris-le sans LangChain : un appel client.messages.create() avec le contexte récupéré injecté en messages, et un embedding-search maison (produit scalaire sur embeddings normalisés, top-k). Mesure les lignes de code et liste précisément ce que LangChain t'apportait. Indice/Solution : la réponse honnête est « du state management et du logging », jamais « de la magie ». Ta version brute devrait tenir en ~50 lignes. Ajoute le prompt caching sur le préfixe système : c'est gratuit et ça change la facture.
Exercice 3 — La boucle d'agent qui ne te ruine pas (après cours #8/#10)
Objectif : construire une boucle agentique bornée et observable, puis la rendre production-grade.
Écris la boucle minimale : while stop_reason == "tool_use" → exécute les outils → renvoie les tool_result. Puis durcis-la jusqu'à ce qu'elle survive à un audit senior : (1) compteur d'itérations max qui coupe net, (2) usage agrégé et affiché à chaque tour, (3) appels d'outils parallèles via asyncio.gather, (4) AsyncAnthropic + max_retries + gestion typée de RateLimitError/OverloadedError, (5) prompt caching sur le préfixe système+outils, (6) routing du sous-travail trivial vers claude-haiku-4-5. Indice/Solution : le piège classique est la boucle infinie quand le modèle redemande le même outil — d'où le compteur. Vérifie que usage.cache_read_input_tokens est non nul après le 2e tour, sinon ton préfixe varie (timestamp, ordre de clés JSON non déterministe).
Exercice 4 — Casse-le, puis répare-le (après cours #5)
Objectif : provoquer les modes de panne d'un RAG et les diagnostiquer comme un senior.
Prends ton pipeline RAG. Provoque délibérément trois pannes : (a) chunking trop gros → le top-k rate le passage pertinent, (b) embeddings non normalisés → similarité cosinus faussée, (c) pas d'éval → hallucination confiante non détectée. Pour chacune, écris le symptôme observable et la métrique d'éval qui l'aurait attrapée (triade fidélité/pertinence/answer-relevance du cours #5). Indice/Solution : (a) se voit en loggant les chunks récupérés vs la réponse attendue ; (b) se voit en comparant les scores de similarité avant/après normalisation ; (c) c'est tout l'intérêt de la triade — sans elle, tu crois que ça marche.
Exercice 5 — Défends le chiffre (transversal, avant tout entretien)
Objectif : savoir justifier une facture et un choix de modèle avec des nombres, pas des vibes.
Pour un de tes projets, produis un mini cost model : nombre de requêtes/jour, tokens input/output moyens par requête, taux de cache hit visé, répartition Haiku/Sonnet/Opus. Calcule le coût mensuel, puis explique en une phrase où tu couperais en premier si on te demandait −40 %. Indice/Solution : l'output coûte ~5× l'input — donc le premier levier est souvent de réduire la verbosité (effort plus bas, instruction de concision) ou de router plus de trafic vers Haiku, pas de raboter l'input. Si ta réponse à « −40 % » est « je sais pas », tu n'es pas encore senior sur ce projet.
Exercice 6 — Le serveur MCP gating-aware (après cours #10, production-grade)
Objectif : construire un serveur MCP et démontrer que tu comprends sa frontière de sécurité.
Construis le serveur MCP du projet 2, puis ajoute une démo de sécurité : un outil à effet de bord (envoi de message, écriture) derrière une confirmation, l'auth en vault (jamais dans le prompt), et un placeholder opaque à la place du secret dans le sandbox. Documente au tableau le chemin : agent → orchestration → tool call → injection du secret à l'egress. Indice/Solution : la faute qui te grille en entretien, c'est de mettre la clé API dans le system prompt « pour que l'agent y ait accès » — elle persiste alors dans tout l'historique de session, lisible via l'API. Le secret ne doit jamais entrer dans le sandbox ; il est injecté côté provider après que la requête a quitté le conteneur.
Exercice 7 — Remplace le prompt XML par un schéma natif, puis prouve que c'est plus robuste (après cours #5/#6)
Objectif : internaliser pourquoi les structured outputs natifs battent le prompt-engineering de format, avec des chiffres.
Prends une étape d'extraction de ton pipeline RAG ou preprocessing (ex. extraire {titre, date, montant} d'un document). Implémente-la deux fois : (a) à l'ancienne, en demandant du JSON dans le prompt avec un exemple XML/JSON hand-rolled, puis json.loads() sur la sortie ; (b) en natif via client.messages.parse() avec un schéma Pydantic (ou output_config: {format: ...}). Lance les deux sur 50 documents bruités (champs manquants, formats de date mélangés, caractères Unicode). Compte les JSONDecodeError, les champs hallucinés, et les retries. Indice/Solution : la version (a) casse sur les préambules (« Voici le JSON : … ») et l'échappement Unicode/slash que les modèles 2026 produisent différemment — d'où le réflexe « jamais de raw-string-match, toujours json.loads/JSON.parse ». La version (b) garantit un schéma valide ou un refusal explicite, et tu peux la combiner avec le prompt caching sur le préfixe. Si ton taux d'échec en (b) n'est pas quasi nul, ton schéma est trop laxiste (manque additionalProperties: false, types trop ouverts).
Exercice 8 — Le cache cassé qu'on ne voit pas (transversal, production-grade)
Objectif : diagnostiquer un cache silencieusement invalidé — le bug de coût le plus courant et le plus invisible.
Construis un système RAG avec un préfixe système + outils stable et un cache_control dessus. Puis sabote-le délibérément de trois façons et observe usage.cache_read_input_tokens rester à zéro à chaque requête : (a) un datetime.now() interpolé dans le system prompt, (b) un json.dumps(tools) sans sort_keys=True (ordre de clés non déterministe), (c) un ID de session injecté en tête du system au lieu de la fin des messages. Pour chacune, montre le diff d'octets entre deux requêtes consécutives et répare. Indice/Solution : le cache est un préfixe-match — un seul octet qui change au rang N invalide tout ce qui suit (ordre de rendu : tools → system → messages). Le contenu volatil (timestamp, ID, question) doit vivre après le dernier breakpoint, jamais avant. Le tell : cache_read_input_tokens = 0 sur des requêtes au préfixe « identique ». Bonus : implémente le pre-warming avec un appel max_tokens: 0 au démarrage pour tuer la latence de premier hit.
🎤 En entretien
Sept questions que ce parcours t'arme pour affronter — avec la réponse senior en une ligne.
« Pourquoi Opus 4.8 ici plutôt que Sonnet 4.6 ou Haiku 4.5 ? » Parce que la tâche est intelligence-sensitive / long-horizon ; sinon je route vers Sonnet (80 % du travail) ou Haiku (classif, fan-out) — payer 5× le prix d'Opus pour une classification triviale est un anti-pattern de coût.
« Ton RAG hallucine en prod. Tu débugges comment ? » Je logge les chunks récupérés vs la réponse, je vérifie la triade d'éval (fidélité / pertinence / answer-relevance), et je remonte la chaîne : preprocessing → chunking → normalisation des embeddings → top-k, avant de toucher au prompt.
« LangGraph ou SDK brut pour cet agent ? » Le framework pour le legacy et la culture, mais la primitive sous-jacente est une boucle
whileautour demessages.create()avec tool-use ; je choisis le brut quand je veux maîtriser le state, le logging, le caching et le coût — c'est-à-dire en prod.« Comment tu bornes le coût d'un agent qui boucle ? » Compteur d'itérations qui coupe,
max_tokensserré,effort: "low"sur les sous-tâches, routing Haiku, prompt caching sur le préfixe stable, etusageloggé à chaque appel — je ne découvre jamais la facture en fin de mois.«
effort: "low"partout pour économiser, non ? » Non — c'est un arbitrage par route, pas une constante.highpar défaut,xhighpour le code/agentique long-horizon ; sur Opus 4.8 uneffortplus haut en amont réduit souvent le nombre de tours et donc le coût total, tandis qu'unefforttrop bas sur un raisonnement dur produit du sous-raisonnement qu'il faut re-prompter — fausse économie.« Tu forces une sortie JSON comment ? » Schéma natif via
messages.parse()+ Pydantic/Zod (ououtput_config: {format}), pas un prompt XML hand-rolled — ça garantit un schéma valide ou unrefusalexplicite, et je ne raw-string-match jamais la sortie d'outil :json.loads/JSON.parse, parce que l'échappement Unicode/slash varie selon le modèle.« Ton cache hit rate est à zéro. C'est quoi le bug ? » Un invalidateur silencieux dans le préfixe —
datetime.now()dans le system,json.dumpsnon trié, ID de session en tête. Le cache est un préfixe-match : un octet qui change au rang N tue tout ce qui suit ; le volatil doit vivre après le dernier breakpoint. Je diffe les octets de deux requêtes pour le trouver.« Agent maison ou Managed Agents ? » SDK brut quand je veux héberger le compute et maîtriser la boucle (state, logging, caching, gating) ; Managed Agents quand je veux que le provider gère la boucle et le sandbox d'exécution — sessions versionnées, conteneur par run. Le bon réflexe avant les deux : est-ce qu'un simple
messages.create()ou un workflow déterministe ne suffirait pas déjà ?
Mise à jour : 2026-06-16