Essential prerequisites

You must be comfortable with all six of these before starting. Each is broken into the specific sub-skills the book leans on, with a self-check question and one resource per sub-skill — a short video where a good one exists, otherwise a course, book, or official guide. This expands on Prerequisite_Knowledge.md; see Prerequisites for the tier overview and study paths.

On this page
  1. Large Language Model (LLM) fundamentals
    1. What a neural network is
    2. Transformer architecture
    3. Attention and context windows
    4. Generation in practice: decoding, sampling, capabilities and limits
    5. Prompting paradigms
  2. Python programming
    1. Functions and keyword arguments
    2. Classes and object composition
    3. Exception handling
    4. Nested data structures and comprehensions
  3. REST APIs, HTTP, and API design
    1. HTTP verbs and status codes
    2. JSON and endpoint design
    3. Timeouts and failure modes
    4. Authentication and rate limiting
    5. Idempotency and API gateways
  4. Command line and shell scripting
    1. Filesystem navigation and search
    2. Bash scripting
    3. Process management and environment variables
    4. Remote access
  5. Docker and containerization basics
    1. Images, containers, and isolation
    2. Writing a Dockerfile
    3. Volumes, networking, and ports
  6. Machine learning fundamentals
    1. Training vs. inference, supervised vs. unsupervised
    2. Embeddings and vector similarity
    3. Evaluation metrics
    4. Overfitting and generalization

Large Language Model (LLM) fundamentals

Every agent architecture in this book uses an LLM as its reasoning engine. You’ll design around context limits, plan for inference latency, and choose models by reasoning capability — all of which assume you already know how an LLM generates text. Load-bearing throughout: decoding parameters (temperature, nucleus sampling) reappear in 5.2, 5.3 and 6.6; context windows and attention in 5.9; quantization and precision depend on transformer internals throughout Part 7.

What a neural network is

Can you explain, in your own words, what a neural network computes and why training it is different from running it?

Video

Transformer architecture

Can you sketch, at a block-diagram level, how a transformer turns a sequence of tokens into a prediction for the next one?

Video

Attention and context windows

Can you explain what the attention mechanism computes, and why a longer context window costs more compute?

Video

Generation in practice: decoding, sampling, capabilities and limits

Can you explain the difference between greedy decoding and nucleus sampling and when you’d choose each, and describe what temperature controls?

Video

Prompting paradigms

Do you know the practical difference between zero-shot, few-shot, and chain-of-thought prompting, and when each is worth the extra tokens? (Depth on this is in Prompt Engineering below.)

Python programming

All code examples and every framework in the book (LangChain, LangGraph, AutoGen, CrewAI) are Python. You’ll read framework internals, implement agents, and debug failures — copying code you don’t understand won’t get you through Part 2, Part 7, or Part 8.

Functions and keyword arguments

Can you write a function that accepts keyword arguments and returns a dictionary?

Classes and object composition

Can you read class-based code and follow method calls, inheritance, and composition without tracing through a debugger first?

  • Fluent Python by Luciano Ramalho, chapters 1–4 (functions and objects as first-class citizens)

Exception handling

Do you reach for try/except/finally naturally, or do you write code that assumes nothing ever fails?

Nested data structures and comprehensions

Can you work with a dictionary containing a list of dictionaries, and write a list or dict comprehension without reaching for a for loop first?

  • Practice: implement 5–10 small programs manipulating nested JSON-shaped data (this is exactly the shape framework configs and tool responses take)

REST APIs, HTTP, and API design

Agents call tools through APIs. Multi-agent communication, orchestration protocols, and every production deployment in this book assume you’re fluent in HTTP. Load-bearing in 1.2 (tool-use architecture), 2.6 (framework tool calling), Part 4 (microservice deployment), and Part 7 (inference endpoints).

Core — needed from Part 1 onward:

HTTP verbs and status codes

Can you explain the difference between GET and POST, and what a 4xx versus a 5xx status code tells you about who’s at fault?

JSON and endpoint design

Can you parse a JSON response with nested objects, and design a REST endpoint for a tool — verb, parameters, response shape?

  • Practice: call 3–5 public APIs with Python’s requests library and handle their responses

Timeouts and failure modes

Do you understand what an API timeout is, why it matters for an agent calling a tool, and what should happen when one fires?

Going deeper — matters once you’re designing tool interfaces or deployment architecture, not just calling existing APIs (Part 2 tool integration, Part 4 deployment):

Authentication and rate limiting

Do you understand OAuth/JWT at a conceptual level, and why an API enforces rate limits?

  • Stripe API reference — read as a worked example of a well-designed, well-documented production API

Idempotency and API gateways

Do you know what idempotency means and why it matters for retries, and what an API gateway adds in front of a set of services?

Video

Command line and shell scripting

Part 4 (deployment and scaling) and Part 8 (operations) assume terminal fluency for SSH access, container management, kubectl, and infrastructure automation. Every deployment step in this book involves a terminal.

Can you navigate a Linux filesystem and locate files with find or grep without opening a file manager?

Bash scripting

Can you write a bash script with variables, a loop, and a conditional — say, one that processes every file in a directory?

  • Practice: write 3–5 small bash scripts against your own filesystem

Process management and environment variables

Can you manage a background process, redirect its output to a file, and set/read an environment variable with export?

  • Same source as above, chapters on job control and environment

Remote access

Can you ssh into a remote server and work there as comfortably as locally?

  • Practice: spin up a free-tier cloud VM and do a day’s work over SSH

Docker and containerization basics

4.1 teaches containerization directly, 4.3 builds container orchestration on top of it, and Part 7 deploys every inference server as a container. You cannot skip this and follow the deployment chapters.

Images, containers, and isolation

Can you explain how a Docker image differs from a running container, and what isolation (filesystem, process, network) a container actually provides?

Video

Covers Docker fundamentals before moving into Kubernetes — watch the Docker portion now, come back for the rest when you reach Kubernetes Fundamentals.

Writing a Dockerfile

Can you write a Dockerfile using FROM, COPY, RUN, and CMD from a blank file, not by copying one you found?

Volumes, networking, and ports

Can you run a container, map a port, mount a volume, and view its logs?

  • Practice: build 2–3 Dockerfiles yourself, run them, and deliberately break something to debug it

Machine learning fundamentals

Part 6 (RAG and knowledge integration) runs on embeddings and vector similarity. Part 7 optimizes inference in ways that assume you know what a model’s outputs mean. Part 9 addresses algorithmic bias, which assumes evaluation-metric literacy.

Training vs. inference, supervised vs. unsupervised

Can you explain the difference between training a model and running inference on it, and between supervised and unsupervised learning?

Embeddings and vector similarity

Can you explain why semantic similarity works as a distance calculation in vector space?

Video

Evaluation metrics

Do you know what precision and recall each measure, and why a model can have high accuracy and still be useless?

  • Hands-On Machine Learning by Aurélien Géron, chapter 3 (classification and metrics)

Overfitting and generalization

Can you explain overfitting and why a model that scores perfectly on its training data can still fail in production?

  • Hands-On Machine Learning by Aurélien Géron, chapter 4; practice by training a scikit-learn classifier and deliberately overfitting it

Continue to Recommended or Beneficial prerequisites, or back to the tier overview.