Construa um Servidor e Cliente MCP

Problema

O Model Context Protocol (MCP) padroniza como uma aplicação de IA descobre e chama ferramentas expostas por um processo separado — em vez de cada framework de agente inventar sua própria forma particular de conectar ferramentas, um **servidor** MCP expõe um catálogo de ferramentas sobre um protocolo bem definido, e qualquer **cliente** compatível com MCP (um app de chat, uma IDE, um agente) consegue conectar, listar o que está disponível, e invocar, independente da linguagem ou framework de qualquer um dos dois lados. A maioria das pessoas encontra MCP pela primeira vez como consumidor — instalando o servidor de outra pessoa no Claude Desktop ou numa IDE. Este lab faz você construir as duas metades você mesmo usando o SDK oficial `mcp` em Python: um servidor expondo duas ferramentas genuinamente simples (`get_time` e `echo`), e um cliente que conecta a ele via **transport stdio** — o mesmo mecanismo que a maioria das integrações MCP locais usa, onde o cliente lança o servidor como um subprocesso e os dois se comunicam via seu stdin/stdout. Ao final você terá visto uma ida-e-volta MCP completa acontecer — descoberta de ferramenta, depois invocação de ferramenta — sem nada escondido dentro de uma aplicação maior, que é a forma mais rápida de realmente entender o que um cliente MCP está fazendo quando "conecta a um servidor" em qualquer ferramenta real que você use depois.

Objetivos

Ao final deste lab você será capaz de:

Explicar qual problema o MCP resolve e como ele difere de uma API de
tool-calling específica de um provedor.
Construir um servidor MCP mínimo com a API de alto nível FastMCP do
SDK mcp em Python, registrando ferramentas com o decorator
@mcp.tool().
Explicar o modelo de transport stdio: o cliente lança o servidor como
um subprocesso e se comunica via seu stdin/stdout.
Escrever um cliente MCP que conecta via stdio, chama list_tools(), e
chama call_tool() para cada ferramenta descoberta.
Ler e interpretar os resultados de ferramenta que um cliente MCP
recebe de volta de um servidor.

Pré-requisitos

Para completar este lab você vai precisar de:

Python 3.10+ instalado.
pip install mcp (o SDK oficial em Python do Model Context
Protocol).
Um terminal e familiaridade básica com decorators e async/await
em Python.
Nenhuma experiência prévia com MCP é exigida.

As duas metades que você está construindo

┌─────────────┐   stdio (stdin/stdout)   ┌─────────────┐
│  client.py  │ ───────────────────────► │  server.py  │
│             │ ◄─────────────────────── │             │
│ lança       │                          │  expõe:     │
│ server.py   │                          │  - get_time │
│ como um     │                          │  - echo     │
│ subprocesso │                          │             │
└─────────────┘                          └─────────────┘

O servidor não sabe nem se importa com que tipo de cliente conecta a
ele — ele só expõe ferramentas sobre o protocolo. O cliente não precisa
saber que o servidor foi escrito em Python, ou como get_time é
implementado — ele só precisa falar MCP. Esse desacoplamento é o ponto
inteiro.

Por que stdio, especificamente

O MCP suporta múltiplos transports (stdio, SSE/HTTP, e outros), mas
stdio é o mais simples e comum para ferramentas locais: o processo
cliente lança o processo servidor diretamente e conversa com ele sobre
pipes comuns, sem porta de rede, sem handshake de autenticação, e sem
processo separado para manter rodando. É exatamente assim que
ferramentas como o Claude Desktop ou uma IDE compatível com MCP
tipicamente rodam um servidor MCP instalado localmente.

Como trabalhar neste lab

Construa o servidor primeiro e faça uma checagem de sanidade nele
isoladamente, depois construa o cliente contra ele. A prova real de que
tudo isso funciona é o Passo 4: o cliente descobrindo e chamando
ferramentas programaticamente das quais ele nunca teve conhecimento
fixo além dos nomes.