Get hands-on: install Claude Desktop, connect your first MCP Server, and watch the protocol work live.
The first step to seeing MCP in action is to install Claude Desktop — Anthropic's official app that works as an MCP Host. Unlike Claude on the web, Desktop supports direct connections to local MCP Servers, allowing the model to access tools on your computer. The download is available at claude.ai/download, with versions for Windows, Mac, and Linux.
O Claude Desktop is Anthropic’s native application, which works as a MCP Host. It’s not just an interface for chatting with Claude—it’s the environment that manages the connection between the AI model and the MCP Servers installed on your machine. When you use Claude Desktop, you have access to a built-in MCP Client that communicates with local servers, allowing Claude to interact with files, databases, APIs, and any other tool that has an MCP Server available.
Access claude.ai/download in your browser. Choose the version for your operating system (Windows, macOS, or Linux). Download the installer, run it, and follow the on-screen instructions. When you open Claude Desktop for the first time, sign in with your Anthropic account. That’s it—you now have a working MCP Host on your computer.
Go to claude.ai/download and download the installer for your operating system (Windows, macOS, or Linux).
Run the installer and follow your system’s default instructions. On macOS, drag it to the Applications folder. On Windows, follow the wizard. On Linux, use the .deb or .rpm package.
Open Claude Desktop, sign in with your Anthropic account, and check that the interface loads correctly. You're ready to configure MCP Servers.
For Claude Desktop to know which MCP Servers are available, you need to register them in a configuration file called claude_desktop_config.json. This file is the heart of the integration: it’s where you declare which servers Claude can access, how to run them, and which arguments to pass. Without this file configured correctly, Claude Desktop won’t know that MCP tools are available.
O claude_desktop_config.json is the file where you register all the MCP Servers you want to make available to Claude Desktop. It’s located in a specific system directory: on macOS, in ~/Library/Application Support/Claude/; in the Windows, in %APPDATA%/Claude/. The main structure is a JSON object with the field "mcpServers", where each key is the server name and the value contains the run command and its arguments.
The basic file structure is simple. Here’s the skeleton:
{
"mcpServers": {
"nome-do-server": {
"command": "comando-para-executar",
"args": ["argumento1", "argumento2"]
}
}
}
Each server is an entry inside "mcpServers". The field "command" defines how to run the server (e.g., npx) e "args" are the arguments passed to the command.
Be careful when editing the JSON manually— commas and quotation marks matter! A common mistake is to forget a comma between servers or leave an extra comma after the last item. Another frequent mistake is to use single quotes instead of double quotes (JSON requires double quotes). If Claude Desktop doesn’t recognize your servers, the first thing to check is the JSON syntax. Use an online validator such as jsonlint.com to check whether the file is correct before restarting the application.
O @modelcontextprotocol/server-filesystem is one of the most popular official MCP Servers. It lets Claude access, read, create, and edit files on your computer—but only in the directories you explicitly authorize. It’s the perfect server to start with because it’s easy to configure and clearly demonstrates the power of MCP: Claude can now “see” your local files.
O Filesystem Server is an MCP Server that exposes file system operations as MCP tools. It offers tools such as read_file (read a file's contents), write_file (create or overwrite files), list_directory (list files in a folder), and others. The server only allows access to the directories specified in the configuration arguments — ensuring that Claude cannot access data outside the authorized scope.
Add this configuration to your claude_desktop_config.json:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/seu-usuario/Documents"
]
}
}
}
Replace /Users/seu-usuario/Documents with the path to the directory you want Claude to access. You can specify multiple directories by adding more paths to the list of args. Prerequisite: have the Node.js installed (npx comes with Node).
After configuring the JSON file, it’s time to test whether everything is working. Claude Desktop needs to be restarted to read the new settings. When the MCP server loads successfully, a tools icon (hammer) appears in the interface, indicating that tools are available. If the icon doesn't appear, there's a configuration problem that needs to be investigated.
Claude Desktop reads the configuration file only at startup. This means that after any change to the claude_desktop_config.json, you need to completely close and reopen the app. When MCP Servers load successfully, Claude Desktop displays a hammer icon in the input area, indicating that external tools are available. When you click this icon, you can see the full list of tools offered by the connected servers.
Completely close Claude Desktop (don’t just minimize it—quit the process) and reopen it.
Look at the message input area. A hammer icon (🔨) should appear, indicating that MCP Servers have been loaded.
Click the hammer icon to see the list of available tools. You should see tools such as read_file, write_file, list_directory, etc.
Common problems and how to solve them:
node --version in the terminal.With the Filesystem Server connected, it's time to test the tools in practice. The most interesting thing is that you does not need to tell Claude which tool to use — simply ask questions in natural language, and the model autonomously decides when and which tool to use. It's the model's intelligence combined with the capabilities of MCP tools.
When Claude Desktop has MCP Servers connected, the model receives the description of all available tools in your context. From there, the model analyzes each user prompt and autonomously decides whether any tool is needed to respond. You don’t need to use special commands or specific syntax—just write in natural language. Claude chooses the right tool, runs it through the MCP Client, receives the result, and formulates the final response.
Try these prompts to test the Filesystem Server tools:
"Liste os arquivos na pasta Documents" — uses list_directory"Leia o conteúdo do arquivo notas.txt" — uses read_file"Crie um arquivo teste-mcp.txt com a frase: MCP está funcionando!" — uses write_file"Quantos arquivos .json existem na pasta do projeto?" — combines list_directory + reasoningObserve how Claude asks for your permission before executing each tool — a protocol security mechanism.
The model decides autonomously when to use tools — this is one of MCP’s pillars. The process works like this: Claude receives the list of available tools, along with their descriptions and parameters. When the user asks a question, the model evaluates whether any tool would help answer it. If so, it generates a tool call (tool call) with the appropriate parameters. There are no fixed rules — the model's intelligence decides. This is fundamentally different from traditional chatbots that rely on explicit commands like "/search" or "/create".
When you asked Claude to list files and it responded with the actual contents of your directory, a sophisticated sequence of events took place behind the scenes. Understanding this flow is essential to mastering MCP—because this is exactly the mechanism you’ll build and customize in the next modules.
What seems magical on the surface follows a precise, standardized flow underneath. Every interaction with an MCP tool goes through 6 well-defined steps: the user's prompt reaches the Host (Claude Desktop), the model identifies the need to use a tool, the MCP Client sends a request to the Server, the Server performs the operation, the result returns along the same path, and Claude formulates the final response incorporating the data retrieved. This entire flow happens in seconds, transparently to the user.
You type "List the files in the Documents folder" in Claude Desktop. The prompt is sent to the model along with the list of available tools.
The model (Host) analyzes the prompt and decides it needs the "list_directory" tool to respond. It generates a tool call with the directory parameter.
The MCP Client built into Claude Desktop receives the tool call and turns it into a JSON-RPC request, sending it to the Filesystem Server.
The Filesystem Server receives the request, verifies that the directory is on the allowlist, lists files in the operating system, and collects the results.
The Server sends the response (list of files) back to the MCP Client, which passes it on to the model. Your computer’s actual data is now in Claude’s context.
The model processes the received data, formats the response in natural language, and displays it for you—as if it had looked at the folder itself.
Notice that during execution, Claude Desktop shows exactly which tool is being called and with which parameters—before asking for your permission. This transparency is intentional: the MCP protocol was designed so people always know what’s happening and can approve or reject each action. Pay attention to these details during your tests—they reveal the protocol’s actual flow in action.
Next Module: 1.5 — Resource Types: Tools, Resources, Prompts