AI Engineer Notebooks

Dit zijn uitvoerbare Colab-notebooks voor de skillset van de AI Engineer / Forward Deployed Engineer (FDE): het bouwen van werkende systemen bovenop foundation models — model API's, RAG, evaluaties, agents, adaptatie en serving — gebruikmakend van raw API's in plaats van frameworks.

Wat dit project onderscheidt

• Bewust framework-vrij: Je schrijft de agent loop, RAG en evaluaties eerst via raw API-calls. Hierdoor begrijp je wat LangChain/LlamaIndex daadwerkelijk doen voordat je ze gebruikt (en kun je beoordelen wanneer je ze juist niet moet gebruiken). Patronen zijn duurzaam; wrappers veranderen voortdurend.
• Evaluaties (Evals) vormen de ruggengraat: Het principe "meten voordat je optimaliseert" wordt vroeg geïntroduceerd en komt in elke sectie terug. Dit is de gewoonte die een engineer die een echt systeem heeft opgeleverd onderscheidt van iemand die slechts een demo heeft gebouwd.
• Gratis uit te voeren, van begin tot eind: Alles draait op de gratis Groq API (geen creditcard nodig). De twee onderwerpen die Groq niet kan hosten — LoRA fine-tuning (06) en self-hosted serving (09) — zijn concept-gericht, met optionele, afgeschermde Colab-GPU appendices die zijn geverifieerd op een echte Colab T4.
• Echte casestudies, geen speelgoed-demo's: Drie end-to-end casestudies laten zien hoe de vaardigheden worden gecombineerd onder echte restricties: een support-assistent die in productie wordt gedebugd, een showdown tussen pipeline- versus agent-kosten, en een red-team robuustheidsbenchmark.
• Overal OpenAI-compatibel: Elk patroon is direct overdraagbaar naar OpenAI en (met kleine aanpassingen) naar Anthropic. De aansluiting is vervangbaar, de vaardigheden niet.

Dit project is gebouwd als de praktische begeleiding bij Plan: Transitioning to Forward Deployed Engineer / AI Engineer. Waar het plan uitlegt wat je moet leren en waarom, zijn deze notebooks de plek waar je het uitvoert.

Voor wie dit bedoeld is

Backend- of full-stack engineers die overstappen naar rollen als AI Engineer, FDE, Applied AI, of Solutions Engineer (AI) — verschillende titels, maar grotendeels dezelfde baan. Je kunt productiekode schrijven en wilt nu de toegepaste model-laag daarbovenop beheersen.

Leervolgorde

Werk van boven naar beneden. Elke notebook is zelfvoorzienend (installeert eigen dependencies, leest API-keys via Colab secrets) en eindigt met oefeningen.

00 — Setup

• Wat je leert: Omgeving en kostenhygiëne; API-keys via Colab secrets, uitgavenbewaking en modelkeuze.

01 — Model API's

• Prompting-basis: Duidelijke instructies, few-shot, output-formaat specificaties, stap-voor-stap redeneren — de goedkoopste knop om aan te draaien, waarbij elke aanpassing een meetbaar resultaat geeft.
• Gestructureerde output: Betrouwbare JSON uit een model krijgen en begrijpen waar dit fout gaat.
• Tool calling: Function/tool calling van begin tot eind, inclusief foutpaden.
• Streaming: Streaming responses en wat UI's hiervan nodig hebben.
• Context & caching: Context-window budgettering, prompt caching, batch- versus real-time prijzen.

02 — Evals I: outputs meten

• Het meten van outputs: Golden sets en metrieken op de taak uit sectie 01. De gewoonte "meten voordat je optimaliseert" wordt hier geïnstalleerd voordat je iets bouwt dat optimalisatie vereist. Evals vormen de ruggengraat en keren terug in elke volgende sectie.

03 — RAG

• Wat is RAG? De retrieve → augment → generate loop, waarom RAG beter is dan een gewone LLM, en waarom RAG niet hetzelfde is als embeddings — inclusief een werkende demo van 15 regels.
• Embeddings & retrieval: Keuze van embeddings, vector search, valkuilen bij similarity — eerst retrieval werkend krijgen.
• Hybride & reranking: Keyword + vector hybride retrieval, rerankers en wanneer de extra kosten gerechtvaardigd zijn.
• Chunking: Chunking-strategieën op een echt rommelig corpus — dit wordt als laatste behandeld, zodra je ze kunt toetsen aan de retrieval.
• Waarom RAG faalt: Het diagnosticeren van slechte antwoorden: meestal is de retrieval-kwaliteit, niet de generatie, de bottleneck.

04 — Evals II: het onderscheidende vermogen

• Golden sets: Het bouwen van een golden set voor het RAG-systeem uit sectie 03.
• LLM als judge: Judge-prompts, overeenstemming met mensen en de eigen faalmodi van de judge.
• Regressie-evals: Evals als CI: kwaliteitsregressies detecteren wanneer je een prompt of model wijzigt.

05 — Agents

• Agent loop vanaf nul: Een werkende agent loop in raw API calls — zonder framework.
• Tool design: Tools ontwerpen die het model daadwerkelijk goed kan gebruiken.
• Guardrails & budgetten: Stopcondities, kosten/latentie-budgetten en wanneer een pipeline beter is dan een agent.
• MCP & het tool-ecosysteem: Concept: wat het Model Context Protocol standaardiseert, hoe dit zich verhoudt tot de raw tool loop, en wanneer je ernaar grijpt.
• Skills & progressive disclosure: Concept: het verpakken van herbruikbare kennis die een agent on-demand laadt — het SKILL.md patroon, de payoff van het context-budget, en Tools/MCP/Skills als één verhaal.
• Harness engineering: Synthese: het steigerwerk rond de call — context assemblage & compactie, tool-resultaat shaping, en verificatie-loops.

06 — Het model aanpassen

• Fine-tune vs RAG vs prompt: Wanneer je de gewichten van het model wijzigt versus de inputs; wat LoRA/QLoRA zijn en de kosten hiervan; de argumentatie die je in een teamoverleg voert — inclusief een optionele echte LoRA fine-tune op een gratis GPU.

07 — Security

• Prompt-injectie & de trust boundary: Directe & indirecte prompt-injectie, output handling, PII, excessieve agency — de OWASP LLM Top 10 risico's; live falen en vervolgens verdedigen.

08 — Operations

• Observability & LLMOps: Elke call tracen, veilig prompt-loggen, kosten/latentie/fout-metrieken, drift-detectie en de observe → eval feedback-loop.
• Betrouwbaarheid & fallbacks: Retries met backoff, timeouts, fallback-modellen, output-validatie, circuit breakers en graceful degradation.
• Experiment tracking & registry: MLflow end-to-end: runs/params/metrieken loggen vanuit de eval-harness uit sectie 04, een model registeren en versioneren, en promoten per stage.

09 — Serving & inference performance

Opmerking: Omdat de gratis Groq API dit niet kan draaien (deze frameworks vereisen een GPU), wordt dit eerst conceptueel behandeld met een optionele Colab-GPU appendix.

• Serving frameworks: De serving stack waar een AI engineer uit kiest — vLLM, TGI, Triton, TensorRT-LLM — wat elk optimaliseert, hoe ze zich verhouden tot de raw API en wanneer je welke kiest.
• Inference performance: De knoppen achter throughput en latentie: continuous batching, de KV cache, quantization, en de trade-off tussen throughput en latentie — inclusief de rekensom voor het bepalen van de omvang van een deployment.

10 — ML system design & performance

• Het ontwerpen van een inference service: Concept: het ML system design interview, uitgewerkt van begin tot eind — schattingen van QPS/VRAM/latentie/kosten, replica scaling, queueing, caching en SLA trade-offs voor een realistische LLM-serving prompt.

11 — Customer craft (de FDE differentiator)

• Scoping & discovery: Een vage klantvraag omzetten in een gescoped, evalueerbaar systeem: discovery-vragen, een scoping-document van één pagina, de demo-discipline — de customer-scenario interviewronde waar de meeste engineers geen bewijslast voor hebben.

12 — Case Studies & Capstone

Hier komen de vaardigheden samen in projecten. Eerst een case study (een realistisch scenario end-to-end uitgewerkt en uitvoerbaar), daarna de capstone (het deployed repo dat je zelf bouwt).

• Case study A — Customer-support assistant: Een scenario dat wordt gescoped → gebouwd → served → gedebugd in productie. Een vage vraag wordt een deployed, geëvalueerde RAG+agent assistent, waarna een live kwaliteitsregressie (een verouderde index na een corpusmigratie) wordt gediagnosticeerd en opgelost.
• Case study B — Contractextractie: pipeline vs agent: De afweging waar interviewers dol op zijn: bouw dezelfde extractietaak als zowel een agent als een pipeline, en bewijs met accuratesse + tokenkosten dat de pipeline wint wanneer de stappen bekend zijn.
• Case study C — Red-team robuustheidsbenchmark: Een ander soort systeem — een harness die een model evalueert in plaats van serveert: een attacker → target → judge (PAIR) loop die de attack success rate meet.
• Capstone: De opdracht voor het deployed project voor op je cv — een echt repo met een serving-component en een evaluatierapport. Casestudies zijn om te leren; de capstone is om aangenomen te worden.

Conventies

• Raw model API's, geen frameworks. Patronen zijn duurzaam; wrappers veranderen voortdurend.
• Eén gedeeld corpus (data/) over RAG- en eval-secties, zodat evaluaties de retrieval meten die je daadwerkelijk hebt gebouwd.
• Zelfvoorzienende notebooks. De eerste cel installeert dependencies, de tweede cel gebruikt from aien import setup; client, MODEL = setup() om je key uit Colab secrets (of een lokale env var) te laden. Geen verborgen state tussen notebooks.
• aien is het kleine gedeelde setup-pakket in dit repo — één plek om credential-loading te wijzigen — automatisch geïnstalleerd door de eerste cel.
• Elke notebook eindigt met oefeningen — maak deze voordat je verder gaat.

Installatie

1. Verkrijg een gratis API-key bij console.groq.com (geen creditcard vereist).
2. In Colab: gebruik het sleutel-icoon in de linkerzijbalk → voeg GROQAPIKEY toe als secret en zet de toegang voor de notebook aan.
3. Open een notebook via de badge en run deze van boven naar beneden.
4. Lokaal draaien:

pip install -r requirements.txt && pip install -e . (De tweede actie installeert de aien setup helper), export GROQAPIKEY=..., open met Jupyter.

Aanbevolen literatuur

• Plan: Transitioning to FDE / AI Engineer — de roadmap die deze notebooks implementeren.
• Guide: Building a Real LLM Project for Your Resume — de kwaliteitseisen voor de capstone.
• Walkthrough: Designing a RAG System — het system-view van sectie 03.
• Walkthrough: Designing an AI Agent Orchestration System — het system-view van sectie 05.