Learn MCP - Pre-Requisites Skills & Environment Setup

#Introduction

Welcome to the Learning MCP series! This series will take you from mastering MCP (Model Context Protocol) — the open standard from Anthropic for connecting AI/LLMs with tools, data, and external systems — starting from the fundamentals, through server/client SDKs, to production deployment.

Before writing your first MCP server, there are some basic skills and tools you need to prepare. Why are these pre-requisites important? Because MCP is not a standalone protocol — it stands on top of LLM/agent concepts, JSON-RPC, HTTP, and the programming language you use. Without that foundation, your MCP code will feel like an incantation that sometimes works for no apparent reason.

Episode 0 is your roadmap: we'll make sure your basic skills are ready, install Node.js and Python in the right versions, set up the official MCP SDKs, and add the MCP Inspector to test your server. After this episode, you're ready to move on to MCP's history and core concepts.

#Basic Skills You Must Have

#LLM & Agent Basics Concepts

MCP exists to answer one problem: how to give an LLM (Large Language Model) access to external data and tools. That's why you need to understand two basic LLM/agent concepts:

• Context window — the number of tokens a model can process in a single conversation. Tools, resources, and prompts in MCP ultimately end up in this context window.
• Tool calling — the model's ability to request the execution of a specific function, then use its result to continue answering. MCP provides the standard for how those tools are exposed to the model.

Here's an analogy: the context window is the model's workbench, and tool calling is the hand that fetches files from the shelf. MCP is the standard format for the shelf and its labels, so all models use the same approach.

#JSON-RPC & HTTP

All MCP communication is based on JSON-RPC 2.0 — a lightweight remote procedure call protocol built on JSON. You should be able to read the structure of JSON-RPC request/response:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

There are three parts always present: jsonrpc (the protocol version), id (an identity used to match responses), and method (the name of the procedure being called). Besides JSON-RPC, also understand the basics of HTTP: methods, status codes, headers, and the streaming concept. The most modern MCP transports run over HTTP, so this knowledge will keep paying off.

#TypeScript or Python

You don't need to master both — just be comfortable with one language. The two main options in the MCP ecosystem:

Since many examples throughout this series use both, make sure you're comfortable with the basics: functions, async/await, data types, and installing dependencies through a package manager.

#OAuth 2.1 & OpenID Connect Basics

Remote MCP servers in the modern era (2026) use OAuth 2.1 for authorization. You don't need to be an expert — just understand the flow: the client requests authorization, the user grants consent, and the client receives a token to call the server. Terms you must know: authorization server, resource server, access token, refresh token, and PKCE. We'll cover the full details in episode 10.

#Software & Tools to Prepare

#Node.js and Python

The official MCP SDKs require specific runtime versions:

• Node.js version 20 or later for the TypeScript SDK.
• Python version 3.11 or later for the Python SDK.

If you haven't installed them, use a version manager so switching versions is easy: nvm for Node.js and pyenv for Python.

#Verifying Your Installation

Check the runtime and package manager versions:

node --version
npm --version

python3 --version
pip3 --version

Expected targets: node --version should print version 20.x or higher, and python3 --version should print 3.11 or higher. If those pass, your environment is ready.

#Installing the Official MCP SDKs

#TypeScript SDK

For a TypeScript project, create a new project folder and install the SDK:

mkdir mcp-lab
cd mcp-lab
npm init -y

npm install @modelcontextprotocol/sdk

This SDK provides the McpServer class for building high-level servers and Server for low-level control. We'll cover both in episode 6.

#Python SDK

For Python, activate a virtual environment and install the SDK:

python3 -m venv .venv
source .venv/bin/activate

pip install mcp

The mcp package includes FastMCP — a high-level helper for building servers quickly — along with the low-level Server and the client.

#MCP Inspector for Testing Servers

Once the SDKs are installed, also set up MCP Inspector — an interactive tool for testing MCP servers without writing a manual client. The Inspector can open both local and remote servers:

npx @modelcontextprotocol/inspector

The Inspector provides a web-based UI in your browser. There you can call tools/list, resources/list, and prompts/list to see what the server exposes, then test each call interactively. This tool will be your faithful companion in episode 7.

#Conclusion

In this episode 0 you've laid the groundwork for the entire series: understanding the basic LLM/agent skills (context window and tool calling), JSON-RPC 2.0 and HTTP, choosing between TypeScript and Python, learning the OAuth 2.1 concept, making sure Node.js 20+ or Python 3.11+ is installed, installing the official MCP SDKs, and preparing the MCP Inspector.

Key takeaways:

• MCP stands on top of JSON-RPC 2.0, HTTP, and the LLM tool calling concept — understand all three.
• Just master one language: TypeScript or Python.
• Node.js version 20 or later and Python 3.11 or later are the official SDK requirements.
• @modelcontextprotocol/sdk (TypeScript) and mcp (Python) are the SDKs you'll be using.
• MCP Inspector (npx @modelcontextprotocol/inspector) is ready to test your server.

In the next episode 1 we'll discuss the history, background, and why the world needs MCP — starting from Anthropic's announcement in November 2024, the fragmented integration problem it set out to solve, and the evolution of the specification up to the stateless era of 2026-07-28. Make sure your environment is ready, because the Learning MCP journey has just begun!