🛠️ Development Environment

Python is a high-level programming language known for its simple syntax and readability. It's the primary language for developing MCP Servers thanks to Anthropic's official SDK and the vast library of available integrations.

The official MCP SDK for Python is the most mature and well-documented. Most examples and tutorials use Python, making it the most practical choice for getting started.

Python 3.11+, interpreted language, dynamic typing, package ecosystem, MCP SDK for Python.

Python 3.11+ can be installed by downloading the official installer from python.org or using version managers such as pyenv. Version 3.11 or later is required for compatibility with the MCP SDK and its modern typing features.

Without Python installed correctly, no Python MCP Server will work. A clean installation prevents permission issues and version conflicts in the future.

python.org, pyenv, system PATH, minimum version 3.11, operating-system-specific installer.

uv is an ultrafast Python package and virtual environment manager, written in Rust. It replaces pip, venv, and pip-tools with a single tool that is 10-100x faster at resolving and installing dependencies.

uv is the tool recommended by the MCP ecosystem for managing Python projects. Its speed and simplicity make development much more productive.

uv, Astral, Rust, dependency resolution, virtual environments, pip replacement.

uv can be installed via curl (on Linux/Mac) or pip (on any system). The curl command is recommended because it installs the compiled binary directly, without relying on an existing Python installation.

uv must be installed and available in the PATH before creating any MCP project. A correct installation prevents permission problems and conflicts.

curl, pip install uv, standalone binary, PATH, installation permissions.

After installing Python and uv, you need to check that both are accessible in the terminal. The python --version, python3 --version, and uv --version commands confirm that the tools are on the PATH and working correctly.

Checking the installation right away prevents future frustration. Many errors in MCP tutorials happen because Python or uv aren't configured correctly.

python --version, uv --version, PATH, environment variables, installation troubleshooting.

The first hands-on test is to use uv to create an isolated virtual environment, install a test package, and run a simple script. This verifies that the entire Python + uv toolchain is working correctly on your system.

Creating a virtual environment is the first step in any MCP project in Python. Practicing now ensures you'll know how to do this automatically when you start building servers.

uv venv, uv pip install, virtual environment, dependency isolation, venv activation.

Node.js is a runtime that lets you run JavaScript outside the browser. Based on Chrome’s V8 engine, it makes it possible to create server-side applications, including MCP Servers using TypeScript with the official SDK.

Node.js is the second official option for developing MCP Servers. If you already know JavaScript or TypeScript, it may be the fastest way to start building servers.

Node.js, JavaScript runtime, V8, server-side, TypeScript, event loop, non-blocking I/O.

Node.js can be installed via nvm (Node Version Manager), which lets you manage multiple versions, or with the official installer from nodejs.org. nvm is recommended for developers who work on different projects.

A correct Node.js installation prevents permission issues and version conflicts. nvm makes it easy to switch between versions as needed for different projects.

nvm, nodejs.org, LTS vs Current, installation by operating system, version management.

npm (Node Package Manager) is Node.js's default package manager. It lets you install, update, and manage JavaScript/TypeScript libraries, including the MCP SDK for TypeScript and all its dependencies.

Every Node.js project uses npm to manage dependencies. Understanding how it works is essential for installing the MCP SDK and keeping your projects organized.

npm, package.json, node_modules, npm install, npm init, package registry, semver.

npx is a tool that comes with npm and lets you run Node.js packages without installing them globally. It automatically downloads, runs, and cleans up, and is widely used to run test MCP Servers and scaffolding tools.

npx is often used to run MCP Servers directly, without requiring permanent installation. It's the fastest way to test third-party servers.

npx, temporary execution, no global installation, package cache, npm vs npx.

Checking the installation with node -v, npm -v, and npx --version confirms that all the tools are available in the terminal. The versions must be compatible: Node.js 18+ is recommended for the TypeScript MCP SDK.

Validating each tool individually ensures there are no PATH or version issues. A quick checklist saves hours of debugging later.

node -v, npm -v, npx --version, minimum version, compatibility, validation checklist.

The first hands-on test is to run a simple package via npx to verify that Node.js and npm are working correctly. This simulates the workflow you'll use to run TypeScript MCP Servers later.

Testing the complete Node.js + npm + npx chain with a real example ensures your environment is ready for MCP Server development in TypeScript.

npx create-*, package execution, test workflow, environment validation, troubleshooting.

The terminal (or command line) is a text-based interface that lets you interact with the computer by typing commands. Unlike a graphical interface, the terminal offers precise, automatable control over the operating system.

All MCP development happens in the terminal — from installing dependencies to running servers and configuring Claude Desktop. Mastering the terminal is a fundamental prerequisite.

Terminal, shell, bash, zsh, PowerShell, command prompt, CLI interface.

Navigation commands let you move between directories in the terminal. cd (change directory) changes folders, ls (list) shows a directory’s contents, and pwd (print working directory) shows where you are currently.

Navigating the file system is the most basic and most frequently used terminal skill. You’ll need to access project folders, find configuration files, and organize your MCP Servers.

cd, ls, pwd, absolute vs. relative paths, home directory (~), parent directory (..).

File manipulation commands let you create (touch, mkdir), copy (cp), move/rename (mv), and delete (rm) files and directories directly from the terminal, without needing a graphical interface.

Managing files through the terminal is faster and more precise than using a graphical interface. You will constantly create project folders, copy templates, and organize your MCP Servers.

touch, mkdir, cp, mv, rm, rm -r, flags, deletion confirmation, permissions.

You can edit files in the terminal with editors like nano (simple, runs in the terminal), code (opens VS Code), or view content with cat. Each tool has an ideal use case.

You’ll need to edit configuration files such as claude_desktop_config.json directly. Knowing how to use at least one terminal editor is essential for configuring MCP Servers.

nano, vim, code (VS Code), cat, less, more, output redirection (>, >>).

Search commands like find (locates files by name or type) and grep (searches for text inside files) are powerful allies. The pipe (|) lets you chain commands, sending one command’s output as the next command’s input.

Searching configuration files, finding errors in logs, and filtering results are routine tasks in MCP development. These commands save significant time.

find, grep, pipe (|), regular expressions, filters, command chaining.

Keyboard shortcuts make using the terminal much more efficient. Tab autocompletes commands and paths, arrow keys navigate history, Ctrl+C cancels processes, and Ctrl+R searches previous commands.

Shortcuts turn the terminal from an intimidating tool into a smooth experience. Ctrl+C in particular is essential for stopping MCP Servers during development.

Tab completion, up/down arrows, Ctrl+C, Ctrl+D, Ctrl+R, Ctrl+L, command history.

Claude Desktop is Anthropic's official application that lets you interact with Claude directly on your computer. It functions as an MCP Host and can connect to local and remote MCP Servers to extend Claude's capabilities.

Claude Desktop is the primary MCP Host for development and testing. It's where you'll connect your MCP Servers and see the tools working in practice.

Claude Desktop, MCP Host, native application, Anthropic, chat interface, MCP support.

Claude Desktop is downloaded from Anthropic's official website (claude.ai/download). Installation varies by operating system: on Windows, it's an .exe installer; on Mac, a .dmg; and on Linux, a .deb or .AppImage, depending on the distribution.

Without Claude Desktop installed, you won't be able to test your MCP Servers visually and interactively. It's the primary environment for development and validation.

claude.ai/download, installer by OS, installation permissions, system requirements, updates.

Initial setup of Claude Desktop involves signing in with your Anthropic account, accepting the terms of use, and adjusting basic preferences. After signing in, the application is ready to use with Claude, but no MCP Servers are connected yet.

A correct initial setup ensures that the application runs smoothly. Errors at this stage can prevent connections to MCP Servers later.

Anthropic account, login, terms of use, preferences, subscription plan, usage limits.

MCP Servers are registered in the claude_desktop_config.json file, located at system-specific paths: ~/Library/Application Support/Claude/ on Mac, %APPDATA%/Claude/ on Windows, and ~/.config/Claude/ on Linux.

Knowing where the configuration file is located is essential for adding, editing, and debugging MCP Servers. It’s the file you’ll edit most often during development.

claude_desktop_config.json, paths by OS, configuration directory, Application Support, AppData.

The validation checklist includes: the application opens without errors, login works, you can send messages to Claude, the settings menu is accessible, and the config file exists at the correct system path.

Validating each checklist item prevents problems when you start connecting MCP Servers. A healthy environment is the foundation for productive development.

Checklist, validation, troubleshooting, error logs, restart, technical support.

For your first use, start a conversation with Claude in Desktop, try different types of questions, and explore the interface. This confirms that the application works and familiarizes you with the environment where you'll test your MCP Servers.

Familiarizing yourself with the Claude Desktop interface before adding MCP Servers helps you quickly spot changes when the servers are connected—such as new tools appearing in the interface.

Chat interface, new conversation, available models, usage limits, baseline experience.

The claude_desktop_config.json is Claude Desktop’s central configuration file for MCP. It contains the list of all registered MCP Servers, their execution commands, arguments, and required environment variables.

This file is the bridge between Claude Desktop and your MCP Servers. Without it configured correctly, the application won’t detect or run any server.

claude_desktop_config.json, declarative configuration, server registration, JSON, mcpServers.

The configuration file is in different locations depending on the system: ~/Library/Application Support/Claude/claude_desktop_config.json on Mac, %APPDATA%\Claude\claude_desktop_config.json on Windows, and ~/.config/Claude/claude_desktop_config.json on Linux.

Finding the file quickly is essential for productivity. You'll edit this file often while developing and debugging MCP Servers.

Paths by OS, Application Support, AppData, .config, hidden directory, terminal access.

The config.json structure has a root object with the "mcpServers" key, which contains an object where each key is a server name and the value defines command (required), args (optional), and env (optional environment variables).

Understanding the JSON structure prevents syntax errors and ensures your servers are registered correctly. One wrong field can prevent the server from starting.

mcpServers, command, args, env, JSON structure, required keys, correct format.

Registering a server involves adding a new entry to the mcpServers object with an identifying name, the command to run it (such as "python" or "npx"), the required arguments (such as the script path), and optional environment variables.

This is the action you'll take every time you create or install a new MCP Server. Mastering registration ensures your servers appear and work correctly in Claude Desktop.

Server registration, identifying name, command, args, env, restarting Claude Desktop.

The most common errors in config.json include missing or extra commas (invalid JSON), incorrect absolute paths, unescaped backslashes on Windows, missing execution permissions, and undefined environment variables.

Knowing common errors before you encounter them saves hours of frustration. Most issues with MCP Servers come from simple mistakes in the configuration file.

Invalid JSON, trailing comma, absolute paths, escaping slashes, permissions, debugging.

Validating the configuration involves checking the JSON with an online linter or local tool, testing command paths in the terminal, restarting Claude Desktop, and checking whether the servers appear in the list of available tools.

A systematic validation process ensures that changes to the config work before you start using the server. This creates a fast feedback loop during development.

JSON linter, path testing, restart, tool list, Claude Desktop logs, validation.

There are several official reference MCP Servers maintained by Anthropic and the community. For a first test, it’s recommended to use a simple server such as the filesystem server or the everything server, which demonstrate the basic features without complex dependencies.

Starting with a proven reference server ensures that any problems are with your environment, not the code. It’s the best way to validate the complete installation.

Reference servers, filesystem server, everything server, official repositories, minimal complexity.

Cloning a repository means downloading all the source code for an MCP Server using git clone. The command copies the repository from GitHub to a folder on your computer, ready to install and run.

Most MCP Servers are distributed via GitHub. Knowing how to clone repositories is the standard way to get and install community servers.

git clone, GitHub, repository, repository URL, destination directory, default branch.

After cloning the repository, you need to install the server dependencies. For Python servers, use uv pip install or pip install -r requirements.txt. For Node.js servers, use npm install. This downloads all the necessary libraries.

Installing dependencies correctly is the step that causes the most errors for beginners. Understanding the process helps you avoid missing or incompatible packages.

pip install, npm install, uv pip install, requirements.txt, package.json, dependency resolution.

Configuring the server in Claude Desktop means adding an entry to claude_desktop_config.json with the run command, script path, and any required environment variables. After saving, you need to restart Claude Desktop.

This is where theory becomes practice. Configuring a real server in Claude Desktop brings together all the concepts covered so far in a working experience.

Editing config.json, server entry, run command, absolute path, restart.

Testing the connection involves opening Claude Desktop after restarting and checking whether the MCP Server tools appear in the interface. You can see the connected servers and their available tools under the tools icon in the chat interface.

Checking the connection confirms that the entire pipeline works: correct config.json, executable server, and established MCP communication. This is the final checkpoint before using the server.

Available tools, tools icon, server list, connection status, error logs.

For your first real use, ask Claude to use a tool from the connected MCP Server. For example, ask it to list files in a folder (filesystem server) or perform a specific operation. Claude will identify the tool and ask for your approval before using it.

This is the course’s “aha!” moment — seeing Claude use a tool running on your computer. This validates your entire setup and motivates you to create your own servers.

Tool invocation, user approval, tool result, complete workflow, debugging, next steps.