AI Engineering course

A hands-on course on AI engineering. Each session pairs the concepts with a real working project, so you learn by building — roughly an even split between understanding how things work and putting them into practice.

Who it's for

Anyone curious about building with AI — from people with solid AI experience to those newer to the field. It's designed to stay interesting for people with prior AI knowledge while remaining understandable for those at a more basic level. It's a well-organized tour of today's AI-engineering landscape, paired with hands-on practice — useful whether you're catching up or filling in gaps.

Prerequisite: basic Python. If you need to get up to speed first, a good starting point is Learn Python the Hard Way.

The sessions

Each session pairs a theory lesson with a hands-on workshop. The course starts with practical builds, then moves into deeper theory, evaluation, prompt engineering, and safety — closing with an ethics capstone.

What each session covers

A short look at the theory and the practice in each session. (The hands-on guides and deeper notes live in each session's folder.)

1 · The AI landscape

• Theory — A panorama of the AI field and where foundation models sit within it: what a foundation model is, the probabilistic nature of AI, and what "AI engineering" means as a discipline — plus the responsibilities that come with building this technology.
• Practice — Build a chatbot that runs on your own machine, talking to a small LLM served locally with Ollama. Bonus task: wire it up to Telegram.

2 · Tools & MCP

• Theory — What "tools" are for an AI, and how the Model Context Protocol (MCP) lets a model use them over a shared, standard protocol.
• Practice — Build an MCP server that gives your AI real capabilities to act on.

3 · Agents

• Theory — What turns a model into an agent: the reason → act → observe loop, orchestration, planning, and the ways agents fail.
• Practice — Build a basic agent that uses the tools from Session 2 — a real loop, not just a chat.

4 · Memory

• Theory — How agents remember: kinds of memory, why memory is genuinely hard, and how it sets up the need for retrieval.
• Practice — Build a simple memory system for your agent.

5 · RAG

• Theory — Giving a model access to knowledge it was never trained on: embeddings, vector stores, and retrieval-augmented generation.
• Practice — Add RAG to a chatbot so it can answer from your own documents.

6 · Foundation models, up close

• Theory — Under the hood: training data, architecture, model size, post-training / fine-tuning, and sampling — the detailed version of Session 1's high-level pass.
• Practice — Hands-on with foundation models.

7 · Evaluation

• Theory — How to tell whether your AI system is actually any good: evaluation methodology, metrics, AI-as-judge, and evaluating whole systems rather than single answers.
• Practice — Evaluate the chatbot you built.

8 · Prompt engineering & experiments

• Theory — Prompting techniques — especially for small / local models — and using frameworks to iterate on prompts and run real experiments.
• Practice — Iterate on prompts and run your own experiments.

9 · Guardrails & safety

• Theory — Keeping AI systems safe and secure: guardrails, agent harnesses, and the security concerns that come with putting AI into the world.
• Practice — Add guardrails to your AI system.

10 · Ethics

• Theory — The societal impact of what we build: effects on human cognition and mental health, on organizations, on energy and ecology, and the big-picture view.
• Debate — A structured debate on the ethics of what we make.

The book, and credits

The course follows Chip Huyen's AI Engineering (O'Reilly) for its concepts — the book is the map. But we don't follow it chapter by chapter, for two reasons.

The order is a teaching choice. We start with hands-on builds that are useful right away — getting you building, and comfortable with the tools you build with. Once that clicks, you start wanting to make what you built better, and that's when the deeper theory — how models actually work, evaluation, prompting — becomes genuinely interesting and useful. So the practical sessions come first and the deep theory comes later.

The Agents part is expanded. We split the book's agents and RAG chapter (Ch 6) into four sessions (Tools, Agents, Memory, RAG), reflecting how much agents have grown in importance over the last two years.

Roughly, where each session draws from:

Credits

• Chip Huyen, AI Engineering (O'Reilly) — the conceptual backbone of the course.
• The workshops reuse and simplify code from two open-source projects:
  • Gary's Economics chatbot — the local chatbot (Session 1) and the RAG pipeline (Session 5).
  • MCP server workshop — the Tools & MCP session (Session 2).