Protocolo MCP: como funciona e como criar um servidor com FastMCP

O problema de integração que me deixou louco por dois dias

É um pouco constrangedor admitir, mas no ano passado tentei conectar o Claude ao repositório da empresa no GitHub. Imaginei o quanto seria mais eficiente deixar a IA ajudar nas revisões de código. O resultado? Passei dois dias inteiros nisso, escrevi centenas de linhas de código de adaptação, depurei até as três da manhã e ainda terminei com uma pilha de bugs inexplicáveis. Para piorar, assim que concluí a integração com o GitHub, meu chefe pediu que eu conectasse o Slack para processar mensagens. Isso significava começar tudo de novo.

Naquele momento, eu só conseguia pensar: por que cada ferramenta de IA precisa de uma forma própria de conexão? Por que não existe um padrão único?

Então, em novembro de 2024, a Anthropic lançou o MCP (Model Context Protocol). No início, não dei muita atenção. Pensei: “Mais um protocolo novo, mais uma coisa para aprender. Que irritação.” Mas, quando vi que a OpenAI também anunciou oficialmente a adoção desse padrão em março de 2025, percebi que havia algo importante ali. Dois gigantes da IA apostando ao mesmo tempo no mesmo protocolo não é algo comum no setor.

Quero compartilhar o que aprendi ao estudar MCP nos últimos meses. Não será uma introdução genérica que apenas repete a documentação oficial: a ideia é entender de verdade o que é MCP e, principalmente, como usá-lo para resolver problemas concretos. É bem mais simples do que parece.

O que é MCP, afinal? A história de uma porta USB

Primeiro, uma analogia fácil de entender

Gosto especialmente de explicar o MCP usando uma porta USB como analogia. Você se lembra dos computadores do início dos anos 2000? O mouse usava uma porta PS/2, o teclado outra, a impressora precisava de uma porta paralela e o scanner, de SCSI. A parte traseira do computador ficava tomada por conectores diferentes. Ao trocar um dispositivo, era preciso encontrar a porta correspondente; quando não havia portas suficientes, ainda era necessário comprar uma placa de expansão.

Depois veio o USB. Uma única porta passou a aceitar todo tipo de dispositivo: mouse, teclado, pen drive, impressora e celular. Tudo resolvido com o mesmo conector. Foi um salto enorme em simplicidade.

É exatamente isso que o MCP pretende fazer: tornar-se a “porta USB” do universo das ferramentas de IA.

Em termos concretos, MCP é um protocolo de padrão aberto para interoperabilidade entre ferramentas de IA. Em palavras mais diretas: ele padroniza e simplifica a conexão entre ferramentas de IA e diferentes fontes de dados. Você deixa de escrever um adaptador para cada fonte. Se uma fonte de dados disponibiliza um MCP Server, qualquer ferramenta de IA compatível com MCP pode se conectar diretamente a ele.

"Nos seis meses após o lançamento do protocolo MCP, a comunidade Hugging Face já reunia mais de 1.000 servidores MCP, enquanto o projeto awesome-mcp-servers ultrapassava 30 mil Stars no GitHub. Os servidores abrangiam mais de 20 áreas, incluindo ferramentas de desenvolvimento, comunicação e colaboração e armazenamento de dados."

Que problema concreto ele resolve?

Vou ser mais direto: os problemas que o MCP resolve são bastante práticos.

Problema 1: trabalho repetido demais

Antes, cada ferramenta de IA precisava de uma integração própria com cada fonte de dados. Para conectar o GitHub, você escrevia um conjunto de código; para o Slack, outro; para o banco de dados, mais um. Eu cheguei a manter sete conectores diferentes, e qualquer atualização exigia alterações nos sete lugares. Só de lembrar já dá dor de cabeça.

Vultr - Servidor cloud NVMe de alto desempenho, 32 locais globais, deploy Docker com um clique

Ver preços →Anúncio

Problema 2: a IA é inteligente, mas não alcança os dados

As ferramentas de IA ficavam isoladas em seus próprios ambientes, sem acesso aos dados que você realmente precisava usar. Quer que a IA leia a documentação do projeto? Consulte o banco de dados? Analise os dados dos pedidos? Em todos os casos, era necessário escrever mais código de integração.

Problema 3: ecossistemas fragmentados desperdiçam tempo

O conector que você escreveu para o Claude não servia para o GPT; aquele criado para o GPT não funcionava em outras ferramentas de IA. Todo mundo reinventava a roda: a mesma funcionalidade acabava exigindo código escrito N vezes.

O MCP surgiu para resolver esses problemas de uma só vez.

A arquitetura central do MCP é surpreendentemente simples

Uma estrutura de três camadas. Só isso

Quando vi o diagrama de arquitetura do MCP pela primeira vez, o que mais me chamou a atenção foi a simplicidade. O sistema inteiro tem apenas três camadas, com funções bem definidas:

┌──────────────────────────────────────┐
│    MCP Host (aplicativo host)         │
│    - Como Claude Desktop e ChatGPT    │
│    - Gerencia conexões e interface    │
└──────────────┬───────────────────────┘
               │
               ↓ Comunicação JSON-RPC 2.0
┌──────────────────────────────────────┐
│    MCP Client (cliente)               │
│    - Comunica-se com o servidor       │
│    - Envia solicitações e trata       │
│      respostas                        │
└──────────────┬───────────────────────┘
               │
               ↓ Comunicação JSON-RPC 2.0
┌──────────────────────────────────────┐
│    MCP Server (servidor)              │
│    - Resources (recursos)             │
│    - Tools (ferramentas)              │
│    - Prompts                          │
└──────────────────────────────────────┘

O design é realmente inteligente. O Host administra o conjunto, o Client cuida da comunicação e o Server fornece recursos específicos. As responsabilidades são claras, e o acoplamento é baixo.

O Server oferece três recursos principais

Um MCP Server oferece principalmente três tipos de recurso às ferramentas de IA:

1. Resources (recursos)

São as fontes de dados: conteúdo de arquivos, registros de banco de dados, respostas de APIs e assim por diante. As ferramentas de IA conseguem ler diferentes dados estruturados por meio deles.

Por exemplo, um MCP Server do GitHub pode expor informações do repositório, a lista de PRs e detalhes de Issues como Resources. Quando a IA faz a chamada, os dados chegam.

2. Tools (ferramentas)

São os recursos que realmente executam ações. A IA pode chamar essas ferramentas para criar arquivos, enviar mensagens, atualizar bancos de dados e muito mais.

Por exemplo, um MCP Server do Slack pode oferecer ferramentas como “enviar mensagem” e “criar canal”. A IA não fica limitada à leitura de dados: ela consegue agir de verdade.

3. Prompts

Este recurso é um pouco diferente: trata-se de modelos predefinidos de prompts. Você pode vê-los como “atalhos” para tarefas frequentes, que ajudam a IA a entender e executar melhor um trabalho específico.

Um MCP Server voltado à revisão de código, por exemplo, pode oferecer modelos de Prompt para “verificação da qualidade do código” e “análise de vulnerabilidades de segurança”. Quando a IA os utiliza, já sabe como conduzir a tarefa.

Railway - Plataforma de deploy moderna, sem ops complexas, no ar em minutos

Começar agora →Anúncio

Uma comparação com a abordagem anterior

Antes, a integração funcionava assim:

Claude ──┐
         ├──→ GitHub API (exige código de adaptação)
GPT   ──┐│
        │└──→ Slack API (exige código de adaptação)
        └───→ Postgres (exige código de adaptação)

Cada ferramenta de IA precisava se integrar separadamente a cada fonte de dados, com uma complexidade N×M. Dez ferramentas de IA conectadas a dez fontes de dados significavam cem conjuntos de código.

Com MCP, fica assim:

Claude ──┐
GPT   ──┼──→ MCP Client ──┬──→ GitHub MCP Server
Gemini──┘                  ├──→ Slack MCP Server
                          └──→ Postgres MCP Server

A ferramenta de IA só precisa implementar um MCP Client para se conectar a todos os MCP Servers. A fonte de dados só precisa implementar um MCP Server para ser usada por todas as ferramentas de IA. A complexidade cai para N+M. Com dez ferramentas e dez fontes de dados, são necessários apenas vinte conjuntos de código.

Quanto mais fontes de dados existem, maior fica essa diferença.

Na prática: crie um MCP Server de consulta do clima

Chega de teoria. É hora de colocar a mão na massa e criar um exemplo simples, mas completo: um serviço de consulta do clima. Não se preocupe, não é difícil. Quando fiz o teste, levei cinco minutos para colocá-lo em funcionamento.

Pré-requisitos

Você vai precisar de:

• Python 3.10 ou superior (provavelmente você já o instalou)
• Framework FastMCP (o framework Python recomendado oficialmente e muito fácil de usar)

A instalação é simples:

pip install fastmcp

O código completo

Preparei um exemplo completo. O código é curto, mas inclui tudo o que precisamos:

from fastmcp import FastMCP
import httpx
from datetime import datetime

mcp = FastMCP("Weather Service")

@mcp.tool()
async def get_weather(city: str) -> dict:
    """
    Obtém informações meteorológicas da cidade informada

    Args:
        city: Nome da cidade (por exemplo, Pequim ou Xangai)

    Returns:
        Dicionário com informações meteorológicas
    """
    # Este exemplo usa a API gratuita do OpenWeatherMap
    # Para usá-la, solicite uma API Key (é rápido e gratuito)
    API_KEY = "your_api_key_here"
    url = f"http://api.openweathermap.org/data/2.5/weather"

    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(
                url,
                params={
                    "q": city,
                    "appid": API_KEY,
                    "units": "metric",  # Usa Celsius em vez de Fahrenheit
                    "lang": "zh_cn"     # Descrição em chinês
                }
            )
            response.raise_for_status()
            data = response.json()

            # Organiza os dados retornados e mantém os mais importantes
            return {
                "city": data["name"],
                "temperature": data["main"]["temp"],
                "feels_like": data["main"]["feels_like"],
                "description": data["weather"][0]["description"],
                "humidity": data["main"]["humidity"],
                "wind_speed": data["wind"]["speed"],
                "timestamp": datetime.now().isoformat()
            }

        except httpx.HTTPError as e:
            # Evita interromper todo o serviço em caso de falha de rede ou da API
            return {
                "error": f"查不到天气信息: {str(e)}"
            }

@mcp.resource("weather://current")
async def current_weather_status() -> str:
    """
    Fornece o status atual do serviço meteorológico
    """
    return f"天气服务运行中，更新时间：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"

# Inicia o servidor
if __name__ == "__main__":
    mcp.run()

Configure o Claude Desktop — e evite estas armadilhas

O código está pronto. Agora, como fazer o Claude usá-lo? Você precisa configurar o arquivo de configuração do Claude Desktop.

Localização do arquivo:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Use este conteúdo:

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": [
        "-m",
        "fastmcp",
        "run",
        "/Users/yourname/projects/weather_server.py"
      ],
      "env": {
        "PYTHONPATH": "/Users/yourname/projects"
      }
    }
  }
}

Atenção a alguns pontos em que eu mesmo já tropecei:

1. O caminho precisa ser absoluto. Não tente economizar usando um caminho relativo, porque o arquivo não será encontrado.
2. O formato JSON precisa estar rigorosamente correto. Uma vírgula a mais ou uma aspa a menos causa erro, e a mensagem nem sempre é clara. Vale validar o arquivo em uma ferramenta de verificação de JSON antes de continuar.
3. Reinicie o Claude Desktop depois de configurar. Sem reiniciar, a alteração não entra em vigor. Na primeira vez, esqueci essa etapa e esperei meia hora à toa.

Depois de reiniciar, um novo ícone de ferramenta aparecerá no Claude. Ao abri-lo, você verá que o serviço “weather” está conectado. Experimente perguntar: “Como está o tempo em Pequim?”. O Claude chamará automaticamente o MCP Server que você acabou de escrever.

Foi empolgante ver a primeira chamada funcionar de verdade, especialmente depois de tanto trabalho para chegar até ali.

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

Casos de uso reais: o que o MCP pode fazer?

Agora já temos a teoria e uma demonstração. Mas o que o MCP faz em projetos reais? Analisei alguns casos práticos bastante interessantes.

Integração com GitHub: revisão de código automatizada

Um projeto de código aberto conectou o GitHub por MCP para oferecer estes recursos:

• Analisar automaticamente novos PRs e atribuir uma avaliação de qualidade do código
• Detectar possíveis vulnerabilidades de segurança e problemas de desempenho
• Gerar automaticamente resumos de PRs e descrições das alterações
• Recomendar revisores adequados com base em dados históricos

Segundo o relato do projeto, o sistema tornou a revisão de código quatro vezes mais eficiente. Muitas verificações mecânicas passaram a ser automatizadas, permitindo que os revisores humanos se concentrassem na lógica de negócio e no design da arquitetura.

Integração com Slack: um assistente de trabalho inteligente

Outro caso é a integração com o Slack. Por meio de um MCP Server, um assistente de IA pode:

• Organizar automaticamente as atas das reuniões diárias
• Classificar mensagens de forma inteligente e ordenar prioridades
• Criar tarefas automaticamente com base no conteúdo das conversas
• Alertar as pessoas relevantes durante discussões importantes

Uma equipe afirmou ter aumentado em 60% a eficiência no processamento de informações, porque muitas tarefas repetitivas de organização passaram a ser automatizadas. O tempo economizado todos os dias pôde ser dedicado a trabalhos mais valiosos.

Empresas: conectando sistemas de negócio

No ambiente empresarial, os casos de uso são ainda mais práticos:

• Integração com Google Drive: a IA pode buscar e resumir documentos da empresa para encontrar rapidamente as informações necessárias
• Integração com banco de dados Postgres: consultas em linguagem natural, sem precisar escrever SQL
• Integração com sistemas de CRM: atualização automática de dados de clientes e geração de relatórios de vendas

Esses cenários têm algo em comum: conectam a IA aos sistemas de dados que a empresa já usa, permitindo que ela acesse e processe informações de negócio de verdade. A IA deixa de ser um brinquedo e passa a ser uma ferramenta de produtividade.

Para concluir

Se eu tivesse de resumir o valor do MCP em uma frase, diria: ele torna a conexão entre ferramentas de IA e fontes de dados tão simples quanto montar blocos de construção.

Antes, era necessário escrever um conjunto de código de adaptação para cada ferramenta de IA e cada fonte de dados, repetindo trabalho e elevando o custo de manutenção. Agora, basta a fonte de dados oferecer um MCP Server para que todas as ferramentas compatíveis com MCP possam usá-la. Esse é o poder da padronização.

Se você tem interesse em MCP, sugiro os próximos passos:

1. Pratique: copie o código de consulta do clima deste artigo, altere alguns parâmetros e implante-o no Claude Desktop
2. Explore os recursos disponíveis: veja o projeto awesome-mcp-servers no GitHub, que reúne mais de 3.000 servidores prontos
3. Desenvolva seu próprio Server: se você tiver uma necessidade específica, experimente criar um MCP Server
4. Participe da comunidade: compartilhe sua experiência prática e ajude outros desenvolvedores

Então, você está pronto para criar seu primeiro MCP Server?