AI Engineer: Course Overview

About AI Engineer

An AI engineer turns models into working products: systems that reason over data, answer questions, call tools, and keep running reliably in production. It starts with the Foundations: Python, the math and statistics behind learning algorithms (linear algebra, probability, optimization), and fluent data work with NumPy and Pandas.

From there, Machine learning with scikit-learn teaches you how models are trained, validated, and compared, which sets up the Deep learning phase: building neural networks in PyTorch and understanding the Transformer architecture that powers modern language models.

Working with LLMs is where most AI engineering happens today: prompting, calling model APIs, enforcing structured output, and grounding answers in your own data with RAG and vector databases. On top of that you add agents that plan, use tools, and carry out multi-step tasks, and learn when fine-tuning with LoRA is worth it compared to better prompting or retrieval.

Shipping is the final phase: serving models behind an API with Docker, tracking experiments and versions with MLOps tooling, and using evaluation, tracing, and guardrails to catch regressions, cost spikes, and unsafe behavior before your users do.

AI engineering moves fast, so this course focuses on the durable skills underneath the tools. It walks through the stack in the order most engineers learn it, so each module builds on the one before it.

Content

13 modules

Python for AI

Python fundamentals for AI work: data structures, functions, classes, virtual environments, async code, and the tooling (Jupyter, pip, uv) you'll use every day.

Python Jupyter Async Virtual Envs

Math & Statistics

The math that makes learning algorithms make sense: vectors and matrices, derivatives and gradients, probability distributions, and the statistics behind evaluating a model.

Linear Algebra Calculus Probability Statistics

Data Handling & Analysis

Loading, cleaning, and reshaping real data with NumPy and Pandas, exploring it with Matplotlib, and building features a model can actually learn from.

NumPy Pandas Matplotlib SQL

Machine Learning

Supervised and unsupervised learning with scikit-learn: regression, classification, trees and ensembles, clustering, cross-validation, and avoiding overfitting.

scikit-learn Regression Random Forest Cross-validation

Deep Learning

Neural networks from first principles and in PyTorch: tensors, backpropagation, training loops, CNNs for images, GPUs, regularization, and transfer learning.

PyTorch Backprop CNNs Transfer Learning

Transformers & NLP

Tokenization, embeddings, and self-attention, then the Transformer architecture end to end, using Hugging Face to work with pre-trained models.

Attention Tokenizers Embeddings Hugging Face

LLMs & Prompt Engineering

How large language models are pre-trained and aligned, what context windows and sampling parameters do, and prompting techniques like few-shot examples, chain-of-thought, and system prompts.

Prompting Context Window Temperature Chain-of-Thought

LLM APIs & Structured Output

Calling hosted model APIs from Python and TypeScript, streaming responses, forcing JSON output with schemas, handling rate limits and retries, and keeping an eye on token costs.

Messages API Streaming JSON Schema Pydantic

RAG & Vector Databases

Grounding a model in your own documents: chunking, embeddings, similarity search, hybrid retrieval, reranking, and query-translation tricks like multi-query and HyDE.

RAG Embeddings pgvector Chroma LangChain

AI Agents & Tool Use

Giving models tools and a loop: function calling, planning and reasoning patterns, memory, multi-step workflows with LangGraph, human-in-the-loop approvals, and connecting tools through MCP.

Tool Calling LangGraph MCP Multi-agent

Fine-Tuning & Evaluation

Knowing when to prompt, retrieve, or fine-tune; adapting open models with LoRA and QLoRA; and measuring quality with test sets, LLM-as-judge, and regression evals.

LoRA QLoRA PEFT LLM Evals

Deployment & MLOps

Serving models behind a FastAPI service, containerizing with Docker, tracking experiments and model versions with MLflow, and automating the path to production.

FastAPI Docker MLflow vLLM

Safety & Observability

Tracing LLM calls, monitoring latency, cost, and quality in production, defending against prompt injection, adding guardrails, and designing for privacy and responsible use.

Tracing Guardrails Prompt Injection Monitoring

What You Can Do After This Course

By the end of the curriculum you'll have built working projects across the whole AI stack and covered the toolchain a professional AI engineering role expects. Concretely, you'll be able to:

Work fluently with data — write clean Python, wrangle datasets with NumPy and Pandas, and understand the math and statistics behind your models.

Train and evaluate models — build classical ML and PyTorch neural networks, and validate them properly so results are trustworthy.

Explain how Transformers work — tokenization, embeddings, and attention, well enough to debug model behavior instead of guessing.

Build with LLM APIs — prompt effectively, stream responses, return structured output, and manage token cost and rate limits.

Ground models in your data — design RAG pipelines with chunking, embeddings, and vector search that stay accurate beyond a demo.

Create agents — give models tools, memory, and multi-step workflows, with human approval where it matters.

Ship and operate AI systems — fine-tune when it pays off, deploy behind an API with Docker, and use evals, tracing, and guardrails to keep quality, cost, and safety under control.