Setup and safety

Outcome

By the end of this lesson you will have five tools installed and one API key saved. You will confirm the install with a set of version checks, and you will prove Docker works by running a single throwaway container. Nothing in this lesson calls a model or creates a billable resource, so you can finish it for free.

The five tools are Git (tracks file changes), Node.js (runs the website build), uv (installs Python and Python packages), Python (runs the agent code), and Docker (runs the agent in the same container you will later build and ship). The one credential is an OpenRouter API key, which authorizes the model calls the rest of the local track makes.

This is the local track’s setup lesson: no AWS account, no AWS CLI, no CDK (Cloud Development Kit). The AWS track’s Lesson 0 covers those instead — see AGENTS.md if you are unsure which track you are on.

Mental model

In a visual automation tool you connect connectors and sign in to each service once before you build a workflow. This lesson is that same “install the connectors and sign in” step, moved to a coding toolchain — just a shorter one, because the local track has one connector (OpenRouter) instead of several AWS services.

The tools map cleanly to ideas you already use:

• Git is your version history, like the run/version history of a saved workflow, but for the files on your computer.
• Docker is the packaged automation: it runs the agent in the exact same container everywhere, so “works on my machine” becomes “works in the container,” full stop.
• The OpenRouter API key is your signed-in connection to the model, the same role a connector’s stored credential plays in a visual tool.

Where the analogy stops: a visual tool’s connector usually lives inside a managed platform you never see the internals of. Docker makes the “container” your workflow runs in visible and inspectable — you can look inside it, which is the point of Lesson 8 later in this track.

Prerequisites and cost

• A computer where you can install software (macOS, Windows, or Linux) with virtualization enabled (needed for Docker; on by default on most modern machines).
• A web browser and an email address, to create an OpenRouter account.

Cost: none in this lesson. You install local tools, run one test container, and save an API key — none of that spends API credit. The first lesson that calls a model (Lesson 2) says so before you run anything.

Steps

Follow these in order. Each install has an official download page; use the official page rather than a search-result link.

1. Install Git. Download it from git-scm.com/downloads and accept the defaults. Git records changes to files so you can undo mistakes and see history.

2. Install Node.js (version 22.12 or newer). Download the LTS build from nodejs.org. LTS stands for Long-Term Support, the stable line. The course website build needs Node 22.12 or newer, and it does not support odd-numbered Node versions such as 23.

3. Install uv. Follow the official install guide. uv manages Python and Python packages for you, so you do not have to install Python separately by hand.

4. Install Python 3.12 with uv. In a terminal, run the two commands in the sample below. The first downloads a managed Python 3.12; the second is the version check.

5. Install Docker. Follow the official install guide for your platform at docs.docker.com/get-started/get-docker (Docker Desktop on macOS and Windows, Docker Engine on Linux). Docker runs containers — small, self-contained packages that bundle an application with everything it needs to run. The “What is OpenRouter” and “Docker Explained” videos below are worth watching if either idea is new to you.

6. Get an OpenRouter API key. Create an account and a key at openrouter.ai/keys. OpenRouter is a hosted service that speaks one API and routes your request to any of many underlying models — the local track’s stand-in for Amazon Bedrock. Copy the key somewhere safe; you paste it into .env in the next step, and OpenRouter shows it to you only once.

7. Set up your environment file. From the agent/ folder of this course, run cp .env.example .env. Open .env and confirm two things: PROVIDER is set to openrouter, and OPENROUTER_API_KEY holds the key you just copied. .env.example is the source of truth for every setting this course uses; .env itself is ignored by Git, so your key is never committed.

Smallest code sample

These are the version checks and the Docker smoke test. Run each one in a terminal from any directory. The Python check runs from inside the agent/ folder of this course, because uv reads the pinned Python version there.

git --version
node --version
uv --version
docker --version

# Install and check Python 3.12 (run these from the repository's agent/ folder)
uv python install 3.12
uv run python --version

# Prove Docker can pull and run a container
docker run hello-world

Expected output

Each version check prints one line. The exact numbers depend on when you install, so treat the format as the checkpoint, not the specific version. These are real outputs from a machine set up for this course; yours may show newer versions:

git version 2.43.0
v22.22.3
uv 0.11.15 (x86_64-unknown-linux-gnu)
Docker version 27.3.1, build ce12230

Python 3.12.3

Any Git 2.x, Node 22.12 or newer (or 24 LTS), uv 0.11 or newer, and Docker 27.x or newer all pass. The Python line must start with 3.12.

The Docker smoke test downloads a tiny image and prints a confirmation message. This is real output; yours will match this shape exactly, since hello-world prints a fixed message:

Hello from Docker!
This message shows that your installation appears to be working correctly.

If you see that message, Docker can pull an image, start a container, run it, and clean it up — everything the later lessons need.

One common failure

Symptom: docker run hello-world fails with something like Cannot connect to the Docker daemon or docker: command not found.

Diagnosis: either Docker is not installed correctly, or the Docker daemon — the background service that actually runs containers — is not running yet. Installing Docker Desktop or Docker Engine does not always start it automatically.

Fix: on macOS or Windows, open the Docker Desktop application and wait for its icon to show “running,” then retry the command. On Linux, start the service with sudo systemctl start docker and confirm it is enabled to start on boot with sudo systemctl enable docker. If the command still is not found, close and reopen your terminal — a terminal loads its PATH once at startup, so a tool installed after you opened it will not be found until you open a new one.

A second common failure is uv run --env-file .env python -m intake.openrouter_call (next lesson) failing with an authentication error because .env still has the placeholder key. Open .env and confirm OPENROUTER_API_KEY holds the real key you copied from openrouter.ai/keys, not the commented-out sample line.

Why this works

Two habits in this lesson remove a whole class of problems before they start.

Pinning tool versions and checking them means every later command runs on a known toolchain. Most “it works on my machine but not yours” problems come from mismatched versions; a version check at the start makes a mismatch visible immediately instead of ten steps later.

Proving Docker works with a disposable hello-world container, before you depend on it, means the first time you meet a Docker problem is now — with a one-line fix — rather than eight lessons from now while debugging your own agent’s container alongside everything else that could be wrong.

Verify it yourself

1. Close every open terminal and open a brand-new one.
2. Run all four version checks (git, node, uv, docker) plus uv run python --version from the agent/ folder. Confirm each prints a version line in the expected format.
3. Run docker run hello-world and confirm you see the “Hello from Docker!” message.
4. Open .env in the agent/ folder and confirm PROVIDER=openrouter and OPENROUTER_API_KEY holds a real key (not the commented-out placeholder).

If all four pass, you are ready for Lesson 1. You have installed the toolchain, proven Docker works, and stored a working credential — all without spending anything.

Cleanup

Nothing to clean up. This lesson creates no billable or standing resource; the hello-world container Docker ran already exited and left nothing running. You can remove the downloaded hello-world image if you want a completely clean slate — docker rmi hello-world — but it is a few hundred kilobytes and harmless to keep. Your .env file stays for the next lesson; it is already ignored by Git, so it will not be committed.