Setting Up Your AI Toolkit

An AI agent is a program that can read files, execute commands, make API calls, and talk to databases. Before you can build one, your machine needs to speak the same languages the agent does. This lesson walks through installing Python, Node.js, git, Docker, and PostgreSQL -- the five pieces of tooling that every other course on this portal assumes are already on your system -- in a single sitting.

What you'll learn

• uv replaces conda and pip: one tool for Python version management, virtual environments, and package installation, installed with a single curl command
• NVM keeps Node.js version-switching painless: no sudo npm install -g disasters, no version conflicts between projects
• Docker does not need the official GPG key dance: the system package or the convenience script works for development
• Every tool has a verify command at the end of its install block -- if the verify passes, the tool is ready

The problem

You open a tutorial for building an AI agent. The first step says "create a virtual environment and install the dependencies." You type python3 -m venv .venv and get back command not found: python3. You try pip install -r requirements.txt and hit a permissions error because pip wants to install into the system Python. You install Node for the agent's web dashboard, but it is version 12 and the tool you want needs version 20. Docker is listed as optional, but the examples use docker compose up to spin up a local database, and without it you are copy-pasting connection strings for a cloud Postgres instance instead of getting work done.

Every one of these failures has the same root cause: the tutorial assumes a baseline toolchain that you do not have yet. The fix is not to learn everything about every tool. It is to install exactly the pieces every agent-building workflow needs, in a way that does not break next week when a new project asks for a different Python version.

Options & when to use each

You do not need to understand every Python tool in the ecosystem. You need to pick one path and get back to building. Here is the landscape and what we recommend.

Python: uv vs conda vs system pip

Path	Good for	Costs you	When to pick it
uv (our pick)	Everything: version management, virtual environments, package installs	Learning one new tool, but it replaces three	Most people, most of the time. Installs in seconds, manages Python itself plus packages, and is fast enough that you stop waiting for pip install to finish
conda / Miniconda	Data science workflows that need non-Python system libraries	Slower, heavier, more to configure, and its own package ecosystem that sometimes fights with pip	You already use conda and have environments you want to keep, or you need packages like GDAL or CUDA that conda handles better
System pip + venv	You already have Python installed and only need one version	Version conflicts between projects, permissions headaches on Linux, Python upgrades break everything	You have a single project and do not plan to touch another Python version

We use uv. It installs with one command, manages Python versions so you are never stuck on whatever your OS shipped, creates virtual environments without ceremony, and installs packages faster than any alternative.

Node.js: NVM vs system package

Path	Good for	Costs you	When to pick it
NVM (our pick)	Per-project Node versions, no sudo for global installs	One extra tool to install first	Almost always. When you clone a project that needs Node 18 and your system has Node 22, NVM switches in one command
System package (apt install nodejs)	One less tool, one less step	You get whatever version your distro ships, often ancient. Upgrading means a distro upgrade or adding a PPA	You only need Node for one specific tool and do not care about the version
fnm (Rust rewrite of NVM)	Faster shell startup, same workflow as NVM	Smaller community, fewer troubleshooting resources online	You are comfortable with NVM and want the faster alternative

We use NVM. It is the most widely documented option, and when something goes wrong, someone else has already hit the same error and posted the fix.

Docker: convenience script vs system package vs official repo

Path	Good for	Costs you	When to pick it
System package (apt install docker.io)	One command, no GPG keys, no foreign repos	Gets a slightly older version than Docker's official repo	Development and learning. The version in Ubuntu's repos runs containers fine and this is not a production deployment
Convenience script (get.docker.com)	The Docker team's own one-liner, up-to-date version	Runs a script from the internet as root, which is the same thing the official manual steps do but without the illusion of auditing	You want the latest Docker without the multi-step repo setup
Official Docker repo (GPG key + apt source)	The exact version Docker publishes, signed with their key	Five or six commands, fragile, distro-version dependent	You are deploying to production and your ops team requires the official repo

We use the system package. The version in Ubuntu 22.04 and 24.04 runs containers, Compose files, and everything needed for local development. If you want the latest version, the convenience script at https://get.docker.com is a single command that handles the same thing.

Build it

Work through these sections in order. Each tool depends on the shell being functional, but the tools themselves are independent -- if you already have Python and Node set up, skip ahead to Docker and Postgres.

Before you start: update your system

Run this once so your package manager knows about the latest versions of everything.

sudo apt update && sudo apt upgrade -y

On macOS, these commands use Homebrew. If you do not have Homebrew, install it first: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)". The rest of this lesson shows Ubuntu commands; macOS equivalents are noted where they differ.

1. Python and uv

uv manages Python itself, creates virtual environments, and installs packages. One tool replaces three.

Install uv:

curl -LsSf https://astral.sh/uv/install.sh | sh

This downloads the uv binary and adds it to your PATH. Close and reopen your terminal, or source your shell config:

source ~/.bashrc    # or ~/.zshrc on macOS

Install Python through uv:

uv python install 3.12

This fetches a fresh Python 3.12 without touching your system Python. You can install multiple versions and switch between them.

Verify:

uv python list        # shows installed Python versions
uv --version          # should print uv 0.x.x or later

Create your first project environment:

mkdir -p ~/projects/test-env && cd ~/projects/test-env
uv init
uv venv
source .venv/bin/activate
uv pip install requests
python -c "import requests; print('Python and uv are working')"

If the last command prints "Python and uv are working," Python is ready.

2. Node.js via NVM

NVM installs per-user and per-shell, which means no sudo and no version conflicts.

Install NVM:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash

Close and reopen your terminal, or load NVM into the current session:

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"

Install Node:

nvm install --lts
nvm use --lts
nvm alias default lts/*

The --lts flag grabs the latest long-term-support release. The alias makes it your default every time you open a terminal.

Verify:

node --version    # should print v20.x.x or later
npm --version     # should print 10.x.x or later

3. Git

Git tracks changes to your code. It is almost certainly already installed, but verify and configure it.

Install (if missing):

sudo apt install git -y       # Ubuntu / Debian
brew install git              # macOS

Configure your identity:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Verify:

git --version     # should print 2.x or later
git config --list | grep user  # should show your name and email

4. Docker

Docker runs services in isolated containers. You will use it to spin up databases, web servers, and local AI tools without installing each one directly on your system.

Install via system package (Ubuntu):

sudo apt install docker.io docker-compose-v2 -y

On macOS, install Docker Desktop from docker.com -- the system package approach is Linux-only.

Add your user to the docker group so you can run containers without sudo:

sudo usermod -aG docker $USER

Log out and back in for the group change to take effect. On most systems you can use newgrp docker to apply it in the current session without logging out.

Verify:

docker run --rm hello-world

If you see "Hello from Docker!" followed by a status message, Docker is working. The --rm flag cleans up the container after it exits.

5. PostgreSQL

PostgreSQL is the database most agents use to store state, conversation history, and structured data.

Install:

sudo apt install postgresql postgresql-contrib -y

On macOS:

brew install postgresql@16
brew services start postgresql@16

Start the service and enable it to run on boot:

sudo systemctl start postgresql     # Ubuntu
sudo systemctl enable postgresql    # starts on boot

Create a database user that matches your system username:

sudo -u postgres createuser --superuser $USER

This lets you run psql without specifying a user every time.

Verify:

psql -c "SELECT version();"

You should see the PostgreSQL version string. If you see psql: error: connection to server failed, the service is not running -- check sudo systemctl status postgresql.

Recap: everything you installed

Tool	What it does	Verify command
uv	Python versions, environments, and packages	uv --version
Python 3.12	The language runtime	uv run python --version
NVM + Node LTS	JavaScript runtime and version manager	node --version
Git	Version control	git --version
Docker	Container runtime	docker run --rm hello-world
PostgreSQL	Relational database	psql -c "SELECT version();"

What goes wrong

When you see this	It probably means	Try this
uv: command not found after install	The install script added uv to PATH but your current shell does not know about it yet	source ~/.bashrc (or ~/.zshrc), or close and reopen the terminal
nvm: command not found	Same PATH issue as uv, or the NVM install script did not add the loader lines to your shell config	Check that ~/.bashrc or ~/.zshrc contains the NVM loader block. If not, the install script prints the lines you need -- run the install again and copy them
docker: permission denied after adding yourself to the docker group	The group change has not taken effect in your current shell session	newgrp docker to apply it in the current session, or log out and back in
docker: command not found on macOS	Docker Desktop was not installed -- the apt package approach is Linux-only	Install Docker Desktop from docker.com, or brew install --cask docker
psql: FATAL: role "youruser" does not exist	You skipped the createuser step, or your system username does not match what PostgreSQL expects	Run sudo -u postgres createuser --superuser $USER again
psql: could not connect to server	PostgreSQL is installed but the service is not running	sudo systemctl start postgresql then sudo systemctl status postgresql to confirm it started
git config changes do not appear to stick	You ran git config without --global and are checking in a different directory	Use git config --global for settings you want everywhere, and git config --list --show-origin to see where each value is set
A Python package fails to build with a C compiler error	The package has native extensions and you are missing build tools	sudo apt install build-essential python3-dev -y (Ubuntu) or xcode-select --install (macOS)
NVM is slow to load when you open a new terminal	NVM runs its initialization script every time a shell starts	Add --no-use to the NVM loader line in your shell config: NVM is available on demand but does not slow down shell startup

Confirm it worked

Run this script in your terminal. It checks every tool installed in this lesson and prints a pass or fail for each one. Copy the whole block and paste it into your terminal.

#!/bin/bash
# Toolkit verification script
# Run this after completing all install steps. Every line should print "PASS".
set -e

echo "=== Checking your AI development toolkit ==="
echo ""

# Python & uv
uv --version > /dev/null 2>&1 && echo "PASS  uv" || echo "FAIL  uv not found"
uv run python --version > /dev/null 2>&1 && echo "PASS  Python (via uv)" || echo "FAIL  Python -- run: uv python install 3.12"

# Node
node --version > /dev/null 2>&1 && echo "PASS  Node.js" || echo "FAIL  Node.js -- run: nvm install --lts"

# Git
git --version > /dev/null 2>&1 && echo "PASS  Git" || echo "FAIL  Git -- run: sudo apt install git"

# Docker
docker run --rm hello-world > /dev/null 2>&1 && echo "PASS  Docker" || echo "FAIL  Docker -- check that the service is running and your user is in the docker group"

# PostgreSQL
psql -c "SELECT 1;" > /dev/null 2>&1 && echo "PASS  PostgreSQL" || echo "FAIL  PostgreSQL -- check: sudo systemctl start postgresql"

echo ""
echo "If every line says PASS, your toolkit is ready."
echo "If anything says FAIL, the table above tells you which step to revisit."

If every line prints PASS, you have everything needed to work through any course on this portal. If a line prints FAIL, the message tells you which tool is missing and the command to fix it.

Where next

Your machine can now run Python in isolated environments, switch Node versions per project, track code with git, spin up containers, and talk to a local database. That is the baseline for building AI agents.

If you are new to the terminal or want a faster shell setup, the rest of the Practical Fundamentals course covers Linux navigation, Python environments in depth, git workflows, PostgreSQL, and Docker. If you already feel comfortable with the command line, jump straight to AI Agents & Vibe Coding and start building.