Setup Guide — Environment for MCP Engineering

Curso MCP Engineering · M0

This guide gets your computer ready for the whole course, taking nothing for granted. We're going to install four things (you already have the terminal, plus Python, Node.js, and VS Code), understand why each one is needed, and create a virtual environment so this project doesn't get mixed up with anything else. Follow the steps in order. At the end there's a checklist to confirm that everything responds.

Golden rule: always install from the official sites named here — python.org, nodejs.org, code.visualstudio.com. Never from a search-engine link that isn't the official one: that's where fake installers with malware show up.

Before you start: what is each thing and why do we install it?

You don't need to memorize anything. It's enough to follow the steps and verify that each thing responds with a version number.

Step 0 — Open the terminal

The terminal (or "command line") is a window where you type instructions as text instead of clicking. It's a bit intimidating at first, but it's just another way — a more direct one — to tell the computer what to do.

These four commands are the only ones you need to get around. A command is a word that gives an order to the terminal:

Concrete example — create the course folder. Type, one line at a time:

mkdir mcp-course   # creates a folder called mcp-course
cd mcp-course      # you enter that folder
ls                 # it's still empty: shows nothing

cd stands for change directory. When you "are inside" a folder, all the commands you type act there. That's the point of creating a course folder first: all your work lives in a single place.

Step 1 — Install Python 3.11+

Python is the course's language. Download it only from python.org (the Downloads section). We ask for 3.11 or higher because modern MCP libraries require it; older versions will give you errors that are hard to diagnose.

The most important checkbox in the whole guide (Windows): check "Add Python to PATH". The PATH is the list of folders where your system looks for programs. If Python isn't in the PATH, the terminal responds "not recognized" even though it's installed. Checking that box avoids the number-one error.

Verify it turned out right:

python --version     # should say 3.11 or higher
pip --version        # pip is Python's package installer

If you see something like Python 3.12.1 and a pip line, you're all set.

If python doesn't respond, try python3 and pip3 (on many macOS and Linux systems multiple versions coexist and the "number-less" name points to an old one). On Windows, if it says "not recognized", close and reopen the terminal; if it persists, reinstall checking Add Python to PATH.

Step 2 — Install Node.js LTS

Some MCP tools run on Node.js. Download the LTS version from nodejs.org. LTS stands for Long-Term Support: it's the stable, recommended version, the one that won't surprise you with weird changes. Avoid the "Current" version, which is experimental.

Verify:

node --version     # e.g.: v20.x (an LTS version)
npx --version      # npx runs tools without installing them permanently

npx is a command that comes with Node and is used to download and run a tool on the fly, without leaving it permanently installed. You'll use it, for example, to launch the MCP inspector later on.

Step 3 — Install VS Code

A code editor is like a word processor, but designed for programming: it colors the code, warns you of errors as you type, and comes with an integrated terminal. We use VS Code because it's free, lightweight, and works the same on macOS, Windows, and Linux. Download it from code.visualstudio.com.

• Open your course folder with File → Open Folder and choose mcp-course.
• Recommended: install Microsoft's Python extension (from the extensions panel, the blocks icon on the left). It gives VS Code autocompletion and error detection for Python.
• Tip: open the terminal inside VS Code with Terminal → New Terminal. That way you edit and run in the same window.

Step 4 — Create and activate a virtual environment (venv)

A virtual environment is an isolated "little box" where you install the packages for this project without cluttering the rest of your computer. Why does it matter? Without venv, everything you install with pip gets mixed at the global level: two projects that need different versions of the same library clash, and one day something stops working without you knowing why. With venv, each project has its own versions and nothing gets stepped on. It's one of the best habits from day one.

From your course folder (mcp-course):

python -m venv .venv        # creates the environment inside the .venv folder

This creates a hidden .venv subfolder. Now you have to activate it so the terminal uses that box:

When it's active, you'll see (.venv) at the start of the line, like this:

(.venv) user@computer mcp-course %

That (.venv) is your confirmation that you're "inside the box". Everything you install with pip from here on stays only in this project. To exit, type deactivate and the (.venv) disappears.

Windows — permissions: if PowerShell blocks the activation script with a message about "execution policy", run just once: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned and confirm with S/Y. This authorizes PowerShell to run trusted local scripts; it's safe and only affects your user.

Common errors (and how to get out of them)

The lesson from the list: if something just installed "can't be found", 90% of the time it's fixed by closing and reopening the terminal, because the PATH is read on open.

Final environment checklist

Copy these commands and confirm that all four respond with a number:

python --version    # 3.11 or higher
pip --version
node --version      # an LTS version (e.g.: v20.x)
npx --version

And check off each item:

• [ ] I can open the terminal on my system.
• [ ] cd, ls/dir, and mkdir work.
• [ ] python --version shows 3.11 or higher.
• [ ] pip --version responds.
• [ ] node --version shows an LTS version.
• [ ] npx --version responds.
• [ ] VS Code installed and opens my course folder.
• [ ] I created the environment with python -m venv .venv.
• [ ] When I activate it I see (.venv) at the start of the line.

If you checked everything, your workshop is ready for the rest of the course.

Glossary

• Terminal: the window where you type text commands and the computer runs them.
• Command: an order you type in the terminal (for example cd or ls).
• Python 3.11+: the course's language; in it you'll write your MCP servers.
• Node.js LTS: environment for running MCP tools written in JavaScript; LTS = stable version.
• VS Code: the code editor where you'll write and organize your files.
• pip: Python's package installer (pip install <package>).
• npx: Node.js command that downloads and runs a tool on the fly, without installing it permanently.
• venv (virtual environment): an isolated "little box" with this project's packages.
• PATH: the list of folders where the system looks for programs; if something "can't be found", it's usually missing here.

To remember

1. Install only from the official sites: python.org, nodejs.org, code.visualstudio.com.
2. On Windows, check "Add Python to PATH" — it avoids the most common error.
3. Always choose Node.js's LTS version (stable), not the "Current" one.
4. Work inside a venv: look for the (.venv) before installing anything with pip.
5. If a command "can't be found" right after installing, close and reopen the terminal.
6. The final checklist confirms the environment: all four commands must respond with a version number.

Turning Point Academy · MCP Engineering Course · Module 0 · Setup Guide