O que é MCP (Model Context Protocol) e como usar em Python

✅ Artigo atualizado em Setembro 2026 Revisado para a especificação atual do MCP (2026-07-28) e para o SDK Python 2.x (MCPServer), com servidor testado, tabela de decisão, erros comuns, exercícios e FAQ.

1
2
3
4
5
6
7
8
9
10

from mcp.server import MCPServer  # pip install "mcp[cli]"

mcp = MCPServer("calculadora")

@mcp.tool()
def somar(a: int, b: int) -> int:
    """Soma dois números inteiros."""
    return a + b

mcp.run()  # o host (ex.: Claude) passa a enxergar a ferramenta "somar"

Salve salve Pythonista

Neste artigo, vamos ver o que é esse tal MCP (Model Context Protocol), suas características, arquitetura e casos de uso, e depois colocar a mão na massa criando um servidor MCP em Python e conectando ele ao Claude.

O MCP foi apresentado pela Anthropic (criadora do Claude) em um anúncio de novembro de 2024 e ganhou muita tração desde então. Em dezembro de 2025, a Anthropic doou o protocolo à Agentic AI Foundation, um fundo da Linux Foundation cofundado por Anthropic, Block e OpenAI.

Sem mais delongas, vamos ao texto!

Vá Direto ao Assunto…

• Introdução
• Arquitetura e Funcionalidades Essenciais do MCP
• Casos de Uso Práticos do MCP
• O Crescente Ecossistema MCP
• Análise Comparativa: MCP vs. Tecnologias Existentes
• MCP vs function calling: qual a diferença
• Perspectivas de Especialistas e Tendências Futuras
• Como criar um servidor MCP em Python
• Exemplo Prático: MCP Server em Python
• Como usar um servidor MCP no Claude Desktop ou Claude Code
• Erros comuns
• Exercícios resolvidos

Introdução

O MCP (Model Context Protocol) é um padrão aberto fundamental projetado para conectar assistentes de IA a diversas fontes de dados (repositórios, ferramentas empresariais, IDEs).

A própria documentação oficial compara o MCP a uma “porta USB-C para aplicações de IA”: assim como o USB-C padroniza a conexão de dispositivos, o MCP padroniza a conexão entre aplicações de IA e sistemas externos, para gerar respostas mais pertinentes e de alta qualidade.

Sem um padrão, cada modelo de IA fica isolado e exige integrações personalizadas para cada fonte de dados, o que dificulta a escalabilidade.

O MCP oferece um protocolo universal e aberto, substituindo integrações fragmentadas por uma abordagem padronizada.

Essencialmente, permite que desenvolvedores conectem fontes de dados e ferramentas (servidores MCP) a aplicações de IA (hosts, que usam clientes MCP), com controle do usuário sobre o que é acessado.

É crucial entender que MCP é um protocolo (como HTTP ou SMTP), não um framework.

Similar ao LSP (Language Server Protocol), que inspirou o projeto, ele visa criar uma interface universal para a IA interagir com recursos externos, simplificando a integração e promovendo a interoperabilidade.

Ele resolve o problema “N x M” de conectar múltiplas IAs a múltiplas fontes e visa capacitar agentes de IA a executar ações em sistemas externos, indo além da simples recuperação de dados.

Novidade: quer criar ebooks profissionais usando IA, com capa gerada automaticamente, infográficos e exportação em PDF? Crie sobre qualquer tema no Ebookr.ai!

Arquitetura e Funcionalidades Essenciais do MCP

O MCP opera em uma arquitetura cliente-servidor com três participantes, segundo a especificação oficial:

• Hosts MCP: aplicações de IA com as quais o usuário interage e que iniciam as conexões (ex.: Claude Desktop, Claude Code, IDEs).
• Clientes MCP: componentes dentro do host que mantêm a conexão com um servidor. O host cria um cliente para cada servidor, cada um com sua conexão dedicada.
• Servidores MCP: programas que expõem dados e funcionalidades por meio do protocolo. Podem rodar na sua máquina ou em um serviço remoto.

Primitivos que um servidor MCP pode oferecer:

• Ferramentas (Tools): funções que o LLM pode invocar (similar a function calling). Ex.: consultar um banco de dados, criar uma issue no GitHub. São controladas pelo modelo, mas a especificação exige que o host peça consentimento do usuário antes de executar.
• Recursos (Resources): fontes de dados para contexto, geralmente só leitura. Ex.: arquivos, registros de banco, esquemas. São controlados pela aplicação, que decide o que entra no contexto (a mesma ideia de “buscar contexto relevante” que usamos em RAG na prática com Python).
• Prompts: modelos de mensagem reutilizáveis para guiar a interação. São controlados pelo usuário, que escolhe quando usar (ex.: um comando “revisar código”).

Recursos que o cliente pode oferecer ao servidor:

• Elicitation: o servidor pede uma informação extra ou uma confirmação ao usuário.
• Sampling: o servidor pede ao host uma geração do LLM. Atenção: na especificação 2026-07-28 o Sampling (assim como Roots e Logging) foi marcado como obsoleto (deprecated); a recomendação para projetos novos é integrar direto com a API do provedor de LLM.

A comunicação usa mensagens JSON-RPC 2.0 (JSON puro; se quiser revisar o formato, veja como manipular JSON com Python) sobre dois transportes padrão:

• stdio: o host inicia o servidor como subprocesso e troca mensagens pela entrada e saída padrão. Ideal para servidores locais.
• Streamable HTTP: cada mensagem é um POST HTTP para um único endpoint, e a resposta chega como JSON ou como um fluxo SSE. Ideal para servidores remotos.

O antigo transporte HTTP+SSE está obsoleto desde a versão 2025-03-26 e não deve ser usado em projetos novos.

Sobre o ciclo de vida: até a versão 2025-11-25, toda conexão começava com um handshake initialize (inicialização, operação, encerramento). Na versão 2026-07-28 o protocolo ficou sem estado (stateless): o handshake foi removido, cada requisição carrega a versão do protocolo e as capacidades do cliente no campo _meta, e o servidor anuncia o que suporta pelo método server/discover. Os SDKs oficiais cuidam dessa negociação para você.

A autorização é opcional. Quando existe, servidores via HTTP devem seguir o fluxo da especificação, baseado em OAuth 2.1; servidores via stdio não usam esse fluxo e leem credenciais do ambiente (variáveis de ambiente, por exemplo).

Casos de Uso Práticos do MCP

Diversas áreas podem se beneficiar com a utilização do MCP:

• Desenvolvimento de Software: melhora a assistência à codificação em IDEs e agentes de código (VS Code, Cursor, Claude Code) com contexto do projeto, depuração aprimorada e integração com ferramentas (ex.: GitHub).
• Gestão de Conhecimento Empresarial: conecta IAs a repositórios internos (Google Drive, Slack, bancos de dados) para chatbots de suporte mais informados e pesquisa empresarial unificada.
• Assistentes de IA: cria assistentes mais capazes que interagem com diversas ferramentas e serviços (calendários, CRMs, planejamento de viagens), automatizando tarefas.
• Servidores Especializados: há um número crescente de servidores MCP para ferramentas específicas (Neo4j, Docker, Stripe, etc.), mostrando a extensibilidade do protocolo.

Que tal receber 30 dias de conteúdo Python direto na sua Caixa de Entrada?_

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

O Crescente Ecossistema MCP

O MCP possui um ecossistema vibrante e em expansão, com comunidades ativas (Discord, GitHub, Reddit) e muitos projetos de código aberto.

• SDKs Oficiais: a página de SDKs lista SDKs em TypeScript, Python, C#, Go e Rust (Tier 1), Java e Ruby (Tier 2) e Swift, PHP e Kotlin (Tier 3).
• Clientes: Claude, ChatGPT, VS Code e Cursor, entre muitos outros, já suportam MCP.
• Servidores e Ferramentas: a comunidade desenvolve servidores MCP para diversas aplicações e ferramentas úteis (o MCP Inspector oficial para testar servidores, mcp-cli, diretórios como mcp.so).

Análise Comparativa: MCP vs. Tecnologias Existentes

• 1) MCP vs. APIs Tradicionais (REST): uma API REST (como as que você cria com FastAPI) exige que cada aplicação de IA aprenda os endpoints e escreva uma integração própria. O MCP atua como um adaptador universal: o servidor descreve suas ferramentas com JSON Schema e o cliente as descobre em tempo de execução (tools/list). Muitos servidores MCP são, por dentro, uma camada fina sobre uma API REST que já existe.
• 2) MCP vs. Function Calling: function calling é o recurso da API de um LLM para pedir a execução de uma função descrita na requisição, e a definição fica presa ao código do seu app. O MCP padroniza onde as ferramentas vivem e como são descobertas e chamadas, para que o mesmo servidor funcione com vários hosts e modelos. Veja a seção a seguir para os detalhes.
• 3) Inspiração no LSP: assim como o LSP padronizou o suporte a linguagens em IDEs, o MCP visa padronizar a interação da IA com sistemas externos.

Embora vantajoso, o MCP coexiste com outros métodos (OpenAPI, GraphQL, LangChain), cada um com seus casos de uso.

MCP vs function calling: qual a diferença

Essa é a dúvida mais comum, porque os dois parecem fazer a mesma coisa. Eles atuam em camadas diferentes:

• Function calling (ou tool use) acontece entre o seu código e o modelo: você manda a lista de funções na chamada à API, o modelo responde “quero chamar buscar_clima com estes argumentos” e o seu código executa a função.
• MCP acontece entre o host e os servidores de ferramentas: o host pergunta ao servidor quais ferramentas existem (tools/list), entrega essa lista ao modelo (via function calling) e, quando o modelo escolhe uma, pede ao servidor para executá-la (tools/call).

Ou seja, o MCP não substitui o function calling: ele tira as ferramentas de dentro do seu app e as coloca em um servidor reaproveitável. Se você está montando um agente próprio, o loop “modelo pede ferramenta, código executa, resultado volta” é exatamente o que mostramos em como criar um agente de IA em Python; o MCP entra quando essas ferramentas precisam servir a mais de um cliente.

Tabela de decisão para escolher a abordagem:

Regra prática: comece com function calling direto quando só o seu app vai usar a ferramenta; transforme em servidor MCP quando você (ou seu time) quiser usar a mesma ferramenta no Claude, no editor e no agente ao mesmo tempo.

Perspectivas de Especialistas e Tendências Futuras

Especialistas veem o MCP como potencial para criar um ecossistema de IA padronizado e interoperável, reduzindo a dependência de fornecedores.

Ele pode impulsionar agentes de IA mais avançados, capazes de coletar contexto e executar tarefas complexas.

Poderia também deslocar o foco da pesquisa de IA para o uso eficaz de conhecimento externo, em vez de apenas datasets massivos.

Em 2025 as previsões eram de adoção mais ampla, possível padronização formal, melhorias na integração remota/nuvem, suporte a modalidades de dados mais ricas e arquiteturas de agentes mais sofisticadas. Boa parte disso já aconteceu: o protocolo passou para uma fundação neutra (Agentic AI Foundation, na Linux Foundation), ganhou o transporte Streamable HTTP com autorização baseada em OAuth 2.1 e extensões opcionais como MCP Apps (interfaces interativas dentro da conversa) e Tasks (operações longas e assíncronas).

Contudo, desafios como segurança, complexidade e latência continuam. A especificação lembra que ferramentas representam execução de código arbitrário: o host deve pedir consentimento explícito do usuário antes de invocar qualquer ferramenta, e descrições de ferramentas vindas de servidores não confiáveis devem ser tratadas como não confiáveis. Na prática: só instale servidores MCP de fontes que você confia e revise quais ferramentas cada um expõe.

Como criar um servidor MCP em Python

O caminho oficial é o SDK Python (mcp), que exige Python 3.10 ou superior. O tutorial oficial usa o gerenciador uv, mas um ambiente virtual comum com pip também funciona (veja o módulo venv na documentação do Python):

1
2
3
4
5
6
7
8
9

# Opção 1: com uv (como no tutorial oficial)
uv init calculadora
cd calculadora
uv add "mcp[cli]"

# Opção 2: com venv + pip
python3 -m venv .venv
source .venv/bin/activate   # no Windows: .venv\Scripts\activate
pip install "mcp[cli]"

Agora crie o arquivo servidor.py:

1
2
3
4
5
6
7
8
9
10
11
12
13

from mcp.server import MCPServer

mcp = MCPServer("calculadora")


@mcp.tool()
def somar(a: int, b: int) -> int:
    """Soma dois números inteiros."""
    return a + b


if __name__ == "__main__":
    mcp.run()  # stdio é o transporte padrão

O que acontece aqui:

• MCPServer("calculadora") cria o servidor com um nome, que aparece para o host.
• @mcp.tool() registra a função Python como ferramenta. O SDK usa os type hints (a: int, b: int) para gerar o JSON Schema dos argumentos e a docstring como descrição, que é o texto que o LLM lê para decidir quando usar a ferramenta.
• mcp.run() inicia o servidor no transporte stdio. Para um servidor remoto, use mcp.run(transport="streamable-http").

Rode com python servidor.py (ou uv run servidor.py). O terminal fica “parado”, sem imprimir nada: é o esperado, porque o servidor está aguardando mensagens JSON-RPC na entrada padrão. Aperte Ctrl+C para sair. Quem inicia esse processo no dia a dia é o host, como você verá na seção sobre o Claude.

Dois cuidados importantes:

• Nada de print() em servidor stdio. A saída padrão é o canal do protocolo; qualquer texto solto ali corrompe as mensagens. Use o módulo logging, que escreve em stderr.
• Se você viu FastMCP em outro tutorial, ele é do SDK 1.x. No SDK 2.x a classe foi renomeada para MCPServer (detalhes em “Erros comuns”).

Se funções, classes e tratamento de erros ainda não estão firmes para você, vale praticar a base com projetos guiados no nosso curso de Python completo antes de partir para servidores mais complexos.

Exemplo Prático: MCP Server em Python

Vamos a um servidor mais completo, com os três primitivos (tool, resource e prompt), e a um cliente em Python que sobe o servidor via stdio, lista as ferramentas e chama uma delas. Tudo roda offline, sem chave de API. Código testado com o SDK mcp 2.2.0 e Python 3.10.

servidor.py:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from mcp.server import MCPServer

mcp = MCPServer("pythonacademy")


@mcp.tool()
def contar_palavras(texto: str) -> int:
    """Conta quantas palavras existem em um texto."""
    return len(texto.split())


@mcp.resource("config://versao")
def versao() -> str:
    """Versão da API interna."""
    return "1.4.2"


@mcp.prompt()
def revisar_codigo(codigo: str) -> str:
    """Pede uma revisão de código Python."""
    return f"Revise este código Python e aponte bugs:\n\n{codigo}"


if __name__ == "__main__":
    mcp.run(transport="stdio")

• A tool contar_palavras é uma ação que o modelo pode chamar.
• O resource config://versao é um dado identificado por uma URI, que o host pode ler e colocar no contexto.
• O prompt revisar_codigo é um modelo de mensagem que o usuário escolhe (muitos hosts mostram prompts como comandos).

cliente.py (na mesma pasta):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import asyncio
import sys

from mcp import Client, StdioServerParameters


async def main():
    # Sobe o servidor como subprocesso e conversa com ele via stdio
    params = StdioServerParameters(command=sys.executable, args=["servidor.py"])
    async with Client(params) as client:
        ferramentas = await client.list_tools()
        for tool in ferramentas.tools:
            print(tool.name, "-", tool.description)
            print(tool.input_schema)

        resultado = await client.call_tool(
            "contar_palavras", {"texto": "MCP conecta LLMs a ferramentas"}
        )
        print(resultado.content[0].text)


asyncio.run(main())

Saída de python cliente.py:

1
2
3

contar_palavras - Conta quantas palavras existem em um texto.
{'type': 'object', 'properties': {'texto': {'title': 'Texto', 'type': 'string'}}, 'required': ['texto'], 'title': 'contar_palavrasArguments'}
5

Repare que o cliente descobriu a ferramenta sozinho: nome, descrição e JSON Schema vieram do servidor, gerados a partir da assinatura da função. É exatamente essa lista que um host como o Claude entrega ao modelo. Para outros testes, o SDK também instala o comando mcp dev servidor.py, que abre o servidor no MCP Inspector.

Construir e conectar servidores MCP pressupõe conforto com Python, tipos e tratamento de erro. Se essa base ainda não está firme, a Jornada Python ensina do zero, com projetos guiados:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Como usar um servidor MCP no Claude Desktop ou Claude Code

Os passos abaixo seguem a documentação oficial do tutorial de servidor MCP e do MCP no Claude Code.

No Claude Desktop

1. Abra o arquivo de configuração claude_desktop_config.json (crie se não existir). Pelo app: menu Claude > Settings… > aba Developer > Edit Config. Os caminhos são:
   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows: %APPDATA%\Claude\claude_desktop_config.json
   • Linux: ~/.config/Claude/claude_desktop_config.json
2. Adicione o servidor na chave mcpServers (exemplo com uv, como no tutorial oficial):

1
2
3
4
5
6
7
8
9
10
11
12
13

{
  "mcpServers": {
    "calculadora": {
      "command": "uv",
      "args": [
        "--directory",
        "/CAMINHO/ABSOLUTO/PARA/calculadora",
        "run",
        "servidor.py"
      ]
    }
  }
}

3. Use caminhos absolutos. Se o Claude não achar o uv, coloque o caminho completo do executável em command (descubra com which uv no macOS/Linux ou where uv no Windows).
4. Salve o arquivo e reinicie o Claude Desktop. A ferramenta somar passa a aparecer para o Claude, que pede sua permissão antes de executá-la.

No Claude Code

Servidores locais (stdio) são adicionados com claude mcp add. Tudo depois do -- é o comando que inicia o servidor:

1
2
3
4
5
6
7
8

# servidor local via stdio
claude mcp add --transport stdio calculadora -- uv --directory /CAMINHO/ABSOLUTO/PARA/calculadora run servidor.py

# servidor remoto via Streamable HTTP
claude mcp add --transport http meu-servidor https://exemplo.com/mcp

# conferir os servidores configurados e o status da conexão
claude mcp list

Dentro de uma sessão do Claude Code, o comando /mcp mostra o status dos servidores. Por padrão o servidor fica no escopo local (só você, neste projeto); use --scope project para gravar no arquivo .mcp.json e compartilhar com o time, ou --scope user para usar em todos os seus projetos.

Erros comuns

Todos os erros abaixo foram reproduzidos com o SDK mcp 2.2.0 e Python 3.10.

1. Usar código de tutorial antigo com FastMCP no SDK 2.x

1

from mcp.server.fastmcp import FastMCP

1

ModuleNotFoundError: No module named 'mcp.server.fastmcp'. This is mcp 2.x, where FastMCP was renamed to MCPServer (from mcp.server.mcpserver import MCPServer) and other APIs changed; see the migration guide at https://py.sdk.modelcontextprotocol.io/v2/migration/#fastmcp-renamed-to-mcpserver or pin 'mcp<2' to keep running v1 code.

A maioria dos tutoriais de 2025 usa FastMCP, que foi renomeado. Troque por from mcp.server import MCPServer e mcp = MCPServer("nome"). Se precisar rodar um projeto antigo sem mexer no código, fixe a versão com pip install "mcp<2".

2. SDK instalado em um Python, servidor rodando em outro

1

from mcp.server import MCPServer

1

ModuleNotFoundError: No module named 'mcp'

Acontece quando você instalou o mcp no ambiente virtual, mas executou com o Python do sistema (venv não ativado) ou quando o host inicia o servidor com outro interpretador. Ative o venv antes de rodar e, na configuração do host, use o uv --directory ... run ou o caminho absoluto do Python certo.

3. Usar print() em um servidor stdio

1
2
3
4
5
6
7

from mcp.server import MCPServer

mcp = MCPServer("ruim")

if __name__ == "__main__":
    print("servidor iniciado")  # vai para o stdout, o canal do protocolo
    mcp.run(transport="stdio")

O cliente espera JSON-RPC no stdout do servidor e recebe texto solto. No SDK Python, o cliente registra um erro de validação (pydantic_core.ValidationError) que inclui esta linha:

1

Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='servidor iniciado', input_type=str]

Em outros hosts o sintoma pode ser o servidor aparecer como desconectado ou com falha. A correção é usar logging (que escreve em stderr) ou print(..., file=sys.stderr).

4. Chamar a ferramenta com argumento do tipo errado

1
2
3

resultado = await client.call_tool("contar_palavras", {"texto": 3})
print(resultado.is_error)
print(resultado.content[0].text)

1
2
3
4

True
Error executing tool contar_palavras: 1 validation error for contar_palavrasArguments
texto
  Input should be a valid string [type=string_type, input_value=3, input_type=int]

Não é uma exceção no cliente: o servidor valida os argumentos contra o schema gerado pelos type hints e devolve um resultado com is_error igual a True (seguido de um link para a documentação do Pydantic). Sempre confira is_error antes de usar o conteúdo, e mande os tipos que o input_schema pede.

5. Ferramenta sem docstring e sem type hints

1
2
3

@mcp.tool()
def buscar(q):
    return q

Listando essa ferramenta (imprimindo repr(tool.description) e tool.input_schema), a descrição vem vazia e o argumento vira texto genérico:

1

'' {'type': 'object', 'properties': {'q': {'title': 'q', 'type': 'string'}}, 'required': ['q'], 'title': 'buscarArguments'}

Não dá erro, mas o LLM não sabe quando usar a ferramenta nem o que passar em q. Escreva uma docstring clara (“Busca produtos pelo nome no catálogo”) e anote os tipos de cada parâmetro.

Exercícios resolvidos

Os exercícios de código rodam offline e sem chave de API. Os de 3 a 5 usam só a biblioteca padrão; o 6 precisa do SDK (pip install "mcp[cli]").

Exercício 1. (Estilo prova) Qual destes não é um primitivo oferecido por um servidor MCP?

a) Tools
b) Resources
c) Prompts
d) Sampling

Exercício 2. (Estilo prova) Você escreveu um servidor MCP em Python que o Claude Desktop vai iniciar na sua própria máquina. Qual transporte é o indicado?

a) stdio
b) Streamable HTTP
c) HTTP+SSE
d) FTP

Exercício 3. Monte, como dicionário Python, a mensagem JSON-RPC 2.0 que um cliente enviaria para chamar a ferramenta contar_palavras com o texto "MCP conecta LLMs a ferramentas". Converta para JSON e leia de volta, imprimindo o método e o texto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import json

mensagem = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
        "name": "contar_palavras",
        "arguments": {"texto": "MCP conecta LLMs a ferramentas"},
    },
}

texto = json.dumps(mensagem)
recebida = json.loads(texto)
print(recebida["method"], recebida["params"]["arguments"]["texto"])

Exercício 4. Simule o lado do servidor: crie um dicionário com duas ferramentas (contar_palavras e somar) e uma função despachar(chamada) que execute a ferramenta pedida ou devolva um erro se ela não existir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def contar_palavras(texto: str) -> int:
    return len(texto.split())


def somar(a: float, b: float) -> float:
    return a + b


FERRAMENTAS = {"contar_palavras": contar_palavras, "somar": somar}


def despachar(chamada: dict):
    nome = chamada["name"]
    if nome not in FERRAMENTAS:
        return {"is_error": True, "texto": f"Ferramenta desconhecida: {nome}"}
    resultado = FERRAMENTAS[nome](**chamada["arguments"])
    return {"is_error": False, "texto": str(resultado)}


print(despachar({"name": "somar", "arguments": {"a": 2, "b": 3}}))
print(despachar({"name": "deletar_tudo", "arguments": {}}))

1
2

{'is_error': False, 'texto': '5'}
{'is_error': True, 'texto': 'Ferramenta desconhecida: deletar_tudo'}

Exercício 5. Escreva validar(argumentos, schema) em Python puro que confira se os campos obrigatórios (required) estão presentes e se os tipos batem com o type de cada propriedade do schema. Devolva a lista de erros.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

SCHEMA = {
    "type": "object",
    "properties": {"texto": {"type": "string"}, "limite": {"type": "integer"}},
    "required": ["texto"],
}

TIPOS = {"string": str, "integer": int, "number": (int, float), "boolean": bool}


def validar(argumentos: dict, schema: dict) -> list:
    erros = []
    for campo in schema.get("required", []):
        if campo not in argumentos:
            erros.append(f"campo obrigatório ausente: {campo}")
    for campo, valor in argumentos.items():
        tipo = schema["properties"].get(campo, {}).get("type")
        if tipo and not isinstance(valor, TIPOS[tipo]):
            erros.append(f"{campo} deveria ser {tipo}")
    return erros


print(validar({"texto": "oi", "limite": 5}, SCHEMA))
print(validar({"limite": "5"}, SCHEMA))

1
2

[]
['campo obrigatório ausente: texto', 'limite deveria ser integer']

Exercício 6. Usando o SDK, crie um servidor com a ferramenta somar(a: float, b: float) e teste sem subprocesso, conectando o Client direto ao objeto do servidor. Liste as ferramentas e chame somar com 2 e 3.5.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import asyncio

from mcp import Client
from mcp.server import MCPServer

mcp = MCPServer("calculadora")


@mcp.tool()
def somar(a: float, b: float) -> float:
    """Soma dois números."""
    return a + b


async def main():
    async with Client(mcp) as client:
        ferramentas = await client.list_tools()
        print([t.name for t in ferramentas.tools])
        resultado = await client.call_tool("somar", {"a": 2, "b": 3.5})
        print(resultado.content[0].text)


asyncio.run(main())

1
2

['somar']
5.5

Conclusão: O Significado e o Futuro do MCP

Vimos nesse artigo que o MCP oferece padronização, melhor contexto e relevância para IA, suporte a agentes avançados, flexibilidade, redução de custos e um ecossistema aberto.

Também vimos que, na prática, criar um servidor MCP em Python leva poucas linhas com o MCPServer do SDK oficial, e que o mesmo servidor funciona no Claude Desktop, no Claude Code e em qualquer outro host compatível.

Representa um passo crucial para uma IA mais interconectada e interoperável, podendo se tornar um padrão fundamental como HTTP ou USB-C.

Seu desenvolvimento contínuo, agora sob uma fundação neutra, e o apoio da comunidade sugerem um futuro promissor para moldar a evolução da IA.

Por Vinícius Ramos em 15/03/2025

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•