πŸ““ Notebook

Interactive tutorials

Build with LLMs, agents & AWS

Forty-one self-contained, hands-on guides β€” from the transformer under the hood to a fridge that reasons about groceries and orders them itself. Each runs in the browser: dark mode, copyable code, and a knowledge-check quiz.

πŸ€–Foundations

Building LLM Applications

LangChain, LangGraph & LangSmith organized around the three problems you hit as an app grows: glue code, non-linear logic, and observability. Includes RAG, a full agent, and a support-agent capstone.

Start learning
🧠Under the hood

How LLMs & Transformers Work

The forward pass, end to end: tokenization, embeddings, self-attention, the transformer block, and how sampling turns logits into the next token β€” the machinery every LLM app sits on top of.

See inside the model
✍️Core skill

Prompt & Context Engineering

Get the most from a model without training it: prompt anatomy, few-shot & chain-of-thought, structured output, prompt caching, and context engineering β€” what to put in the window and what to leave out.

Write better prompts
🧬Under the hood

How Embedding Models Work

Turning text into vectors: what an embedding is, how models learn the space (contrastive training), similarity metrics, and how to choose & use one well β€” the engine under semantic search.

See the mechanism
πŸ”ΆDeep learning

TensorFlow

Google's end-to-end ML platform: the problem it solves, how it works (tensors, graphs, Keras, autodiff), its unmatched deployment reach (server, mobile, browser, TPU), limits, and vs PyTorch.

Learn TensorFlow
πŸ”₯Deep learning

PyTorch

The research-favorite framework: dynamic, pythonic define-by-run graphs, autograd, explicit training loops, the Hugging Face ecosystem, its limits, and when to pick it over TensorFlow.

Learn PyTorch
βš—οΈModel compression

Knowledge Distillation

Teach a small student model to imitate a big teacher: the core idea & "dark knowledge", soft targets & temperature, the distillation loss, response/feature/relation-based knowledge, offline/online/self schemes, and distillation in the LLM era (DistilBERT, sequence-level & reasoning distillation).

Compress the model
πŸ—œοΈModel compression

Quantization & Pruning

Make a trained model small and fast: quantization lowers the bits per weight (FP32→INT8/INT4, scale & zero-point, PTQ vs QAT), pruning removes weights (unstructured vs structured, the prune→fine-tune loop). Why structure decides real speedups, compressing LLMs (GPTQ, AWQ, GGUF, QLoRA), and the compression stack.

Shrink & speed up
πŸͺͺHands-on CV lab

Lab: Train a Licence Recognizer

From scratch, no ML experience needed: label images, train YOLO weights, and read the fields off NZ/AU driver licences β€” with OCR, an API, and the privacy guardrails ID work demands.

Start the lab
🎯CV tooling

How YOLO & Label Studio Work

The two tools behind the lab, opened up: YOLO's one-pass detection architecture (backbone β†’ neck β†’ head β†’ NMS) and the Ultralytics API, Label Studio's config/annotate/export model, and the label ↔ train loop.

See how they work
πŸ”ŽRetrieval deep-dive

RAG vs CAG vs GraphRAG

How to ground a model in your data: retrieve at query time (RAG), preload & cache a small stable corpus (CAG), when to mix them, and GraphRAG plus the wider family (hybrid, reranking, HyDE, Agentic/Corrective/Self-RAG).

Compare methods
🎚️Decision guide

Fine-tuning vs RAG vs Prompting

Three levers to adapt a model β€” and which to pull when: prompting changes how you ask, RAG changes what it knows now, fine-tuning changes how it behaves. A decision flow, trade-offs, and how to combine them.

Choose the lever
πŸ—„οΈVector store

Vector Databases Compared

Where embeddings live and how nearest-neighbour search works β€” the ANN problem, then Chroma, FAISS, Qdrant, Pinecone, pgvector, Weaviate & Milvus compared, with a landscape map and when to choose which.

Compare stores
βš–οΈFramework choice

LangChain vs LlamaIndex

Which framework to build on: LangChain's breadth (agents, orchestration) vs LlamaIndex's depth on data (ingestion, indexing, retrieval) β€” where they overlap on RAG, and when to use each or both.

Compare frameworks
πŸ§ͺQuality & ops

LLM Evaluation & Observability

Prove it works and keep it working: eval datasets, offline vs online evals, LLM-as-judge, tracing & observability, what to measure, and the eval loop that turns every failure into a permanent test.

Measure & monitor
🧰Frameworks

Agent Development Kits

Google ADK vs AWS Strands + Bedrock AgentCore vs LangGraph β€” what problem each solves, its limits, and when to choose it, in a clear Problem β†’ Solution β†’ Limits format.

Compare kits
🀝Multi-agent frameworks

AutoGen vs CrewAI

The two leading multi-agent frameworks compared: conversable agents vs role-based crews, their orchestration models, the same task coded both ways, a head-to-head table, and how to characterise the work to choose.

Compare frameworks
πŸ”Agent architecture

Anthropic Agent Architectures

From Building Effective Agents: the augmented LLM, the five workflow patterns (chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer), and the autonomous agent loop β€” with when to use each.

See the loops
🧭Agent patterns

Google Agent Design Patterns

Google Cloud's taxonomy organized by who decides the route: predetermined (sequential, parallel, loop) vs dynamic (coordinator, hierarchical, swarm), plus human-in-the-loop β€” and how to choose.

Compare patterns
πŸ”„Loop engineering

Getting Started with Loops

Designing agents that repeat cycles of work until a stop condition: the anatomy (trigger Β· stop Β· primitive), the four loop types (turn / goal / time / proactive), a worked example, and best practices.

Engineer loops
πŸ› οΈAgent engineering

Harness vs Loop vs Graph

Three mindsets for building agents on the control-vs-autonomy spectrum: explicit graphs (you draw the flow), agentic loops (you set the cycle), and model-driven harnesses (the model drives) β€” trade-offs and how they compose.

Compare mindsets
πŸ”€API design

REST vs GraphQL vs gRPC

Three ways for services to talk: REST's resources over HTTP, GraphQL's ask-for-exactly-what-you-need queries, and gRPC's fast typed binary RPC β€” the problem each solves, and when to choose which.

Compare API styles
β—ΌAPI design

GraphQL Deep-Dive

One typed endpoint, client-specified queries: the schema & type system, resolvers, the N+1 problem & DataLoader, cursor pagination, caching, the security guardrails a public API needs, and federation.

Query the graph
πŸ”ŒIntegration

APIs vs MCP

How agents connect to tools: the MΓ—N integration problem MCP solves, how it works (hosts, clients, servers, tools/resources/prompts), a direct API-vs-MCP comparison, and when to use which.

Wire it up
🧩MCP hands-on

Build MCP From Scratch

The hands-on companion: build an MCP server (the app that exposes tools/resources/prompts) and an MCP client/task that consumes them β€” with runnable examples, when-to-use scenarios, and how to run & connect them.

Build it
πŸ•ΈοΈAgentic web

WebMCP & A2A

Two emerging protocols: WebMCP brings MCP-style tools into the browser, and A2A lets agents discover and delegate to each other β€” how they differ from MCP and fit together.

Look ahead
πŸ›‘οΈSecurity

Web Β· API Β· AI Security

A defensive guideline across the whole surface: HTTP/TLS, authentication & authorization, OWASP web & API risks, AI/agent threats (prompt injection, excessive agency), and a risk program β€” breach, user & automation.

Harden it
πŸ”OWASP

OWASP β€” Top 10 & Toolbox

The de-facto language of app security: what OWASP is, the three Top 10 lists (Web, API, LLM) detailed, and the wider toolbox β€” ASVS, WSTG, Cheat Sheets, ZAP, Dependency-Check, SAMM & Juice Shop β€” across the SDLC.

Explore OWASP
πŸ•΅οΈCyber security

Cyber Security

The big picture: the CIA triad, security mechanisms & controls, the threat landscape and cyber kill chain, how to prevent attacks (defense in depth, zero trust, MFA), and how to manage a program (NIST CSF, risk, incident response).

Defend & manage
πŸ”—Automation

n8n β€” Workflow Automation

Automate the glue between apps: what problem node-based workflows solve, how they work, n8n's limitations (fair-code licence, self-hosting, scale), and how it compares to Zapier, Make, Node-RED and more.

Automate it
☸️Architecture

Cloud Native

Building apps to fully exploit the cloud: containers, microservices, Kubernetes orchestration, CI/CD and observability β€” the pillars, the benefits, the real complexity cost, and when (not) to adopt it.

Go cloud native
🧡Scalability

Concurrency Design

Balance security, idempotency, latency & capacity: architecture options and trade-offs, sizing with Little's Law, load-testing to the knee, retries for isolated failures, and AI-agent context isolation.

Design for scale
🐘Database

PostgreSQL Query Performance

Stop guessing why a query is slow: how the planner works, reading EXPLAIN ANALYZE, indexes & statistics, the common anti-patterns and their fixes, and a worked 4.2 s β†’ 0.3 ms optimisation.

Tune queries
🧹Database

PostgreSQL VACUUM

Why MVCC leaves dead tuples behind, what VACUUM actually reclaims, VACUUM vs VACUUM FULL, tuning autovacuum, transaction-ID wraparound & freezing, and detecting bloat β€” with a worked queue-table cleanup.

Beat the bloat
πŸ—‚οΈDatabase

PostgreSQL Indexing Strategies

Match the index to the query: how a B-tree works, the six index types and when to use each, multicolumn column order, covering & partial & expression indexes, building safely with CONCURRENTLY, and auditing what to drop.

Index deliberately
🧩Database & scale

Sharding & Partitioning

Scale data past one machine: partitioning vs sharding, partition strategies (range/list/hash), choosing a shard key, sharding strategies, cross-shard joins & transactions, consistent hashing, and the ladder to climb before you shard.

Scale the data
☁️Cloud

AWS Services Field Guide

An architect's tour of 40 core AWS services across 9 categories β€” the problem each one solves, its real limits and quotas, and when to reach for it. Plus a look-alikes cheat sheet.

Explore services
🌩️Cloud & IaC

GCP Services & Infrastructure as Code

A field guide to Google Cloud β€” the resource hierarchy, core services by category (Cloud Run, BigQuery, Cloud SQL, Pub/Sub…), a GCP↔AWS map β€” then an intro to Infrastructure as Code with a Terraform-on-GCP walkthrough.

Provision in code
πŸ—οΈIaC tools

Terraform vs Pulumi vs OpenTofu

Which IaC tool to build on: the model all three share, what each is, the 2023 licence change that forked OpenTofu from Terraform, the same stack written three ways, and a decision guide.

Compare IaC tools
πŸ“‘End-to-end example

IoT Γ— Agents: a self-restocking fridge

Wire AWS IoT Core to a Strands agent on Bedrock AgentCore: a fridge detects low milk and auto-orders groceries β€” with architecture, five tabbed source files, and the guardrails auto-purchasing needs.

See it work

Suggested reading order

New here? They build on each other β€” foundations first, then the systems and protocols that tie them together.

  1. Building LLM Applications

    Start with the fundamentals β€” chains, RAG, stateful agents, and tracing. Everything else assumes this vocabulary.

  2. How LLMs & Transformers Work

    Look under the hood β€” tokens, embeddings, attention and sampling β€” so the rest stops being a black box.

  3. Prompt & Context Engineering

    The highest-leverage skill β€” steer the model with instructions, examples and the right context before reaching for anything heavier.

  4. How Embedding Models Work

    Understand the vectors under the hood β€” what retrieval and semantic search are actually built on.

  5. TensorFlow

    The framework layer beneath the models β€” Google's platform, strongest on deployment reach.

  6. PyTorch

    The other giant β€” dynamic, pythonic, and dominant in research and the LLM ecosystem.

  7. Knowledge Distillation

    Shrink the model without losing its mind β€” train a small student to match a large teacher's whole output distribution, not just the labels.

  8. Quantization & Pruning

    Compress the weights themselves β€” fewer bits each (quantization) and fewer of them (pruning) β€” the other two levers that pair with distillation.

  9. Lab: Train a Licence Recognizer

    Put it into practice β€” a full from-scratch computer-vision lab: label, train weights, detect, OCR, serve.

  10. How YOLO & Label Studio Work

    Open up the two tools the lab uses β€” YOLO's detection architecture and Label Studio's labeling model.

  11. RAG vs CAG vs GraphRAG

    Go deep on grounding β€” how to get your data into the model reliably, and which retrieval method fits which corpus and question.

  12. Fine-tuning vs RAG vs Prompting

    Zoom out on the levers β€” when to prompt, when to retrieve, when to fine-tune, and how they stack together.

  13. Vector Databases Compared

    Where the vectors are stored and searched β€” from a one-line library to a distributed cluster.

  14. LangChain vs LlamaIndex

    Pick the framework to build on β€” orchestration-first (LangChain) or data/RAG-first (LlamaIndex), and when to combine them.

  15. LLM Evaluation & Observability

    Before you scale up to agents β€” learn to measure and monitor quality, so every later change is provable, not a guess.

  16. Agent Development Kits

    Now zoom out: how the frameworks for building agents differ, and how to pick one for the job.

  17. AutoGen vs CrewAI

    Two multi-agent frameworks head-to-head β€” conversation-first vs role-and-task-first, and which shape fits your work.

  18. Anthropic Agent Architectures

    The architectural vocabulary β€” workflows vs agents, the five patterns, and the agent loop.

  19. Google Agent Design Patterns

    The complementary taxonomy β€” predetermined vs dynamic routing, and the multi-agent topologies.

  20. Getting Started with Loops

    Put agents to work unattended β€” trigger, verify, stop β€” with the four loop types and their guardrails.

  21. Harness vs Loop vs Graph

    Step back β€” the three engineering mindsets for agents and when to impose structure vs trust the model.

  22. Agent Topologies

    Wire the agents together β€” the five shapes multi-agent systems take, their trade-offs, and how to grow the topology to fit the problem.

  23. REST vs GraphQL vs gRPC

    How services actually talk over the network β€” the API-design choices beneath every app and agent.

  24. GraphQL Deep-Dive

    Go deep on one API style β€” schema, resolvers, the N+1 fix, pagination, caching, and the guardrails a public graph needs.

  25. APIs vs MCP

    How those agents reach the outside world β€” and why MCP standardizes connecting them to tools.

  26. Build MCP From Scratch

    Get hands-on β€” build an MCP server (app) and an MCP client (task), with examples and scenarios.

  27. WebMCP & A2A

    Where it's heading: tools in the browser, and agents that discover and delegate to each other.

  28. Web Β· API Β· AI Security

    Secure everything you've built β€” transport, identity, web/API risks, and the new AI/agent attack surface.

  29. OWASP β€” Top 10 & Toolbox

    The shared vocabulary of app security β€” the Top 10 risk lists and the standards/tools that operationalize them.

  30. Cyber Security

    Zoom out to the whole program β€” mechanisms, attack prevention, and how to govern & manage security.

  31. n8n β€” Workflow Automation

    Zoom out to the practical: wire apps and APIs into automated workflows β€” low-code, self-hosted, with code when you need it.

  32. Cloud Native

    The architectural approach beneath modern cloud apps β€” containers, microservices and orchestration, vendor-neutral.

  33. Concurrency Design

    Make it handle load safely β€” capacity, resilience, failure isolation, and per-run agent isolation.

  34. PostgreSQL Query Performance

    Make the database keep up β€” read the query plan, add the right indexes, and fix the slow statements underneath it all.

  35. PostgreSQL VACUUM

    Keep the database from bloating β€” reclaim dead tuples, tune autovacuum, and stay clear of transaction-ID wraparound.

  36. PostgreSQL Indexing Strategies

    Make reads fast without over-taxing writes β€” pick the right index type, column order, and partial/covering shape for each query.

  37. Sharding & Partitioning

    Scale data past one box β€” partition on one server, shard across many, and know which rung of the ladder you actually need.

  38. AWS Services Field Guide

    Learn the cloud building blocks β€” compute, storage, messaging, Bedrock β€” that agents and apps actually run on.

  39. GCP Services & Infrastructure as Code

    The other major cloud β€” plus how to provision any of it in code with Terraform, not console clicks.

  40. Terraform vs Pulumi vs OpenTofu

    Pick the IaC tool itself β€” the shared model, the licence fork behind OpenTofu, and Terraform vs Pulumi's real-language approach.

  41. IoT Γ— Agents

    Put it all together in one end-to-end system: a device event triggers an agent that reasons and acts in the real world.