MCP Servers: o que são, como funcionam e 5 servidores famosos para começar

Table of contents

Introdução

Se você já usou um agente de IA como Claude, Cursor ou o Kiro e sentiu aquela frustração de ter que copiar e colar dados entre ferramentas — um schema de banco aqui, um issue do GitHub ali, um documento do Drive acolá — o Model Context Protocol (MCP) foi criado exatamente para resolver isso.

MCP é, provavelmente, a mudança mais importante no ecossistema de IA agêntica dos últimos dois anos. Ele padronizou a forma como agentes conversam com o mundo exterior — bancos de dados, APIs, sistemas de arquivos, serviços em nuvem — de um jeito que lembra o que o USB fez pelos periféricos: antes cada dispositivo exigia um cabo e um driver específico; depois, um protocolo só resolveu tudo.

Neste post vamos cobrir o que é MCP, por que ele importa, os 5 servidores mais usados em 2026, uma lista ampla de outros relevantes, como criar o seu próprio servidor simples, e os cuidados de segurança que você precisa conhecer.

O que é MCP, em uma frase

Model Context Protocol é um padrão aberto que define como agentes de IA se conectam a fontes de dados e ferramentas externas de forma segura, bidirecional e reutilizável.

Foi lançado pela Anthropic em novembro de 2024 e, em dezembro de 2025, foi doado para a Agentic AI Foundation (um fundo sob a Linux Foundation, co-fundado por Anthropic, Block e OpenAI). Hoje é suportado nativamente por Claude Desktop, Cursor, Windsurf, Claude Code, Kiro e muitos outros — e já tem mais de 1.200 servidores catalogados.

O problema que o MCP resolve

Antes do MCP, conectar um agente de IA a um sistema externo significava escrever código customizado — function calling específico para cada API, com documentação, tratamento de erros, lógica de autenticação, tudo feito à mão e preso àquele fornecedor. Se você quisesse trocar de Claude para GPT-4, tinha que reescrever tudo.

Multiplique esse esforço por cada ferramenta (banco de dados, Slack, Jira, Drive, GitHub, etc.) e por cada agente. O que tínhamos era um problema N×M: N ferramentas × M modelos = manutenção inviável.

Como MCP funciona por baixo dos panos

MCP tem 3 atores principais:

• MCP Host: a aplicação que roda o agente de IA (Claude Desktop, Cursor, Kiro)
• MCP Client: a camada dentro do host que fala com os servidores
• MCP Server: o serviço externo que expõe ferramentas, recursos e prompts ao agente

A comunicação usa JSON-RPC 2.0 como formato de mensagens — o mesmo protocolo que o Language Server Protocol (LSP) usa, por exemplo. Existem dois mecanismos de transporte:

• stdio (standard input/output): para servidores locais, rodando como processo na sua máquina. Rápido e síncrono.
• SSE ou HTTP: para servidores remotos acessados pela internet. Ideal para serviços em nuvem.

O que um servidor MCP expõe

Um servidor MCP pode expor três tipos de coisas para o agente:

1. Tools (ferramentas): funções que o agente pode chamar. Ex: create_issue, query_database, send_slack_message.
2. Resources (recursos): dados que o agente pode ler como contexto. Ex: conteúdo de um arquivo, registro de um banco, página de documentação.
3. Prompts: templates prontos que o usuário pode invocar. Ex: “resuma o PR #123 seguindo este formato”.

MCP vs function calling tradicional

Se você já usou function calling da OpenAI ou Anthropic, deve estar se perguntando: MCP substitui isso?

Não exatamente. MCP usa function calling por baixo dos panos — ele é uma camada de padronização. A diferença é que function calling tradicional te obriga a definir cada função dentro da sua aplicação, enquanto MCP permite que qualquer servidor externo contribua com funções ao agente, sem mudança no código do host.

Os 5 servidores MCP mais famosos

Escolhi os 5 servidores com maior adoção real em 2026, baseado em dados de volume de busca, stars no GitHub e menções em guias técnicos. Pra cada um mostro o que faz, caso de uso real e configuração.

1. GitHub MCP — o rei da produtividade

O servidor MCP mais usado do mundo. Dá ao seu agente acesso completo a repositórios, issues, PRs, actions e GitHub Discussions. É a ponte entre o seu editor de IA e o ciclo de desenvolvimento real.

O que você pode fazer:

• “Abra um PR com essas mudanças e descreva no padrão da equipe”
• “Liste issues com label bug abertos há mais de 30 dias”
• “Resuma o que mudou no PR #234”
• “Crie uma issue detalhando este erro que acabei de encontrar”

Configuração:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_seu_token_aqui"
      }
    }
  }
}

Você precisa gerar um Personal Access Token em github.com/settings/tokens com as permissões mínimas necessárias (repo, issues, read:org).

2. Filesystem MCP — acesso seguro aos seus arquivos

Permite que o agente leia, escreva e pesquise arquivos no seu computador — com controle estrito de diretórios permitidos. É o que habilita aquele workflow mágico de “leia todo este projeto e explique a arquitetura”.

O que você pode fazer:

• “Leia todos os arquivos em src/ e me diga o que cada módulo faz”
• “Encontre todos os TODOs do projeto”
• “Crie um novo arquivo utils/validation.ts com estas funções”
• “Substitua a versão do React em todos os package.json”

Configuração:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/voce/projetos"
      ]
    }
  }
}

O último argumento é o diretório permitido. Você pode passar múltiplos. O agente não acessa nada fora desses diretórios.

3. PostgreSQL MCP — converse com seu banco

Permite que o agente execute queries em bancos Postgres. A experiência de “perguntar ao banco em português” é revolucionária — você descreve o que quer em linguagem natural e o agente gera e executa o SQL.

O que você pode fazer:

• “Quantos usuários se cadastraram na última semana?”
• “Mostre os top 10 produtos por receita no último trimestre”
• “Encontre registros com email duplicado na tabela users”
• “Gere um relatório de pedidos cancelados agrupados por motivo”

Configuração:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@localhost:5432/mydb"
      ]
    }
  }
}

4. Slack MCP — sua base de conhecimento em chat

Transforma o histórico do Slack da sua empresa em conhecimento consultável. Ideal quando a empresa inteira tomou decisões importantes em threads que ninguém mais encontra.

O que você pode fazer:

• “Me atualize sobre o que aconteceu no canal #engenharia essa semana”
• “Encontre a discussão sobre a migração do banco em junho”
• “Poste um resumo da reunião no canal #produto”
• “Me diga o que foi decidido sobre o incidente de ontem”

Configuração:

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-seu-token",
        "SLACK_TEAM_ID": "T01234567"
      }
    }
  }
}

Para gerar o token, você cria um Slack App em api.slack.com/apps e adiciona ao workspace. As permissões variam: leitura exige channels:history, groups:history; envio exige chat:write.

5. Brave Search MCP — o agente conectado à web

Dá ao agente capacidade de busca web em tempo real usando a Brave Search API (alternativa privacy-friendly ao Google). Essencial quando você precisa de informação mais recente que o conhecimento treinado do modelo.

O que você pode fazer:

• “Qual a versão mais recente do Next.js e o que mudou?”
• “Pesquise boas práticas de autenticação em 2026”
• “Encontre tutoriais sobre [biblioteca nova que foi lançada semana passada]”
• “Compare opções de hospedagem para Astro”

Configuração:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "sua-chave-aqui"
      }
    }
  }
}

API key grátis em brave.com/search/api (até 2.000 queries/mês no plano free).

Mais servidores que vale conhecer

Além dos 5 acima, aqui vai um panorama de outros servidores relevantes, agrupados por categoria:

Existe também o MCP Registry e marketplaces como Pulse MCP e MCP Marketplace onde você pode buscar por categoria e ver scores de segurança.

Criando seu primeiro servidor MCP

Pra tirar o véu do mistério, vamos fazer um servidor MCP minúsculo em Python que expõe uma única ferramenta: converter texto para maiúsculas. É bobo, mas mostra os passos essenciais que se repetem em servidores reais.

Setup

# Criar projeto
mkdir meu-primeiro-mcp && cd meu-primeiro-mcp
python -m venv venv && source venv/bin/activate

# Instalar SDK oficial
pip install mcp

Código do servidor

Crie server.py:

from mcp.server.fastmcp import FastMCP

# Instancia o servidor
mcp = FastMCP("meu-primeiro-mcp")

# Define uma tool - cada função decorada vira uma ferramenta
# que o agente pode chamar
@mcp.tool()
def maiusculas(texto: str) -> str:
    """Converte o texto recebido para letras maiúsculas."""
    return texto.upper()

@mcp.tool()
def contar_palavras(texto: str) -> dict:
    """Conta palavras, caracteres e linhas de um texto."""
    return {
        "palavras": len(texto.split()),
        "caracteres": len(texto),
        "linhas": len(texto.splitlines()) or 1,
    }

# Executa o servidor via stdio (comunicação por entrada/saída padrão)
if __name__ == "__main__":
    mcp.run(transport="stdio")

Registrando no cliente

Pra usar esse servidor no Claude Desktop, edite claude_desktop_config.json:

{
  "mcpServers": {
    "meu-mcp": {
      "command": "python",
      "args": ["/caminho/absoluto/para/server.py"]
    }
  }
}

Reinicie o Claude Desktop e pronto — você pode pedir “converta ‘olá mundo’ para maiúsculas” e ele vai usar seu servidor. No painel de tools, ele aparece como “meu-mcp”.

Próximos passos

Pra um servidor “de verdade” você vai adicionar:

• Autenticação (geralmente via env vars com tokens/keys)
• Tratamento de erros retornando mensagens úteis ao agente
• Resources para expor dados consultáveis (não só tools)
• Testes usando o MCP Inspector — uma ferramenta visual oficial para debugar servidores

Existem SDKs oficiais para Python, TypeScript, Kotlin, C#, Java e Rust. A documentação completa está em modelcontextprotocol.io.

Segurança: o que você precisa saber

MCP é poderoso — e com poder vem responsabilidade. Em abril de 2025, pesquisadores de segurança publicaram análises mostrando vários vetores de ataque em setups MCP mal configurados. Vale conhecer:

Como escolher os MCPs certos pra você

Com centenas de servidores disponíveis, é fácil exagerar. Meu conselho:

1. Comece pequeno: 2-3 servidores que cobrem seus pontos de fricção diários
2. Priorize oficiais: servidores mantidos pela Anthropic ou pelos provedores oficiais (GitHub, Postgres, etc.) são mais seguros
3. Adicione por necessidade: sentiu falta de algo? Aí sim pesquise um servidor
4. Documente no steering: se você usa Kiro, registre quais MCPs estão ativos e quando usar cada um
5. Monitore o uso: muitos clientes mostram quantas chamadas cada MCP faz — observe padrões

Pra maioria dos devs, esse combo cobre 80% dos casos:

• Filesystem (sempre)
• GitHub ou Git (sempre)
• Um banco (Postgres/SQLite conforme a stack)
• Brave Search (informação atualizada)
• 1-2 específicos (Notion, Slack, Sentry… o que fizer sentido)

Conclusão

MCP é para agentes de IA o que HTTP foi para a web: um padrão simples que, por ser aberto e bem desenhado, virou infraestrutura. A pergunta não é mais “devo usar MCP?”, e sim “quais MCPs fazem sentido pro meu workflow?”.

Se você ainda não usou nenhum, comece hoje com o Filesystem e o GitHub. Em uma tarde você já sente a diferença. Se já usa, vale explorar servidores menos óbvios — um Sentry MCP pode economizar horas de investigação em incidentes.

A boa notícia é que o ecossistema ainda está amadurecendo: padrões de segurança estão evoluindo, OAuth 2.0 está sendo formalizado no protocolo em 2026, e mais servidores corporativos estão saindo toda semana. Estar por dentro agora é um diferencial enorme pros próximos anos.

O que vem a seguir no blog

Este post abre uma série sobre a stack agêntica moderna. Os próximos tópicos que vou cobrir:

• Criando um servidor MCP robusto do zero — tutorial completo com autenticação, resources, prompts e deploy
• Comparativo: os melhores clientes MCP — Claude Desktop vs Cursor vs Kiro vs Windsurf na prática
• Segurança em setups MCP corporativos — como estruturar permissions, audit logs e sandboxing
• Criando agentes customizados com SDK Anthropic + MCP — indo além dos clientes prontos

Se você não quer perder, assine a newsletter abaixo — os posts saem toda semana.

Recursos para aprofundar

• Documentação oficial: modelcontextprotocol.io
• Repositório de servidores oficiais: github.com/modelcontextprotocol/servers
• SDKs oficiais: Python, TypeScript, Kotlin, C#, Java, Rust em github.com/modelcontextprotocol
• MCP Inspector (debug visual): github.com/modelcontextprotocol/inspector
• Anúncio original da Anthropic: anthropic.com/news/model-context-protocol
• Post anterior: Guia completo do Kiro — o IDE agêntico da AWS que usa MCP nativamente

Curtiu o post? Compartilhe com alguém que ainda acha que IA “só serve para chatbot”. E se ainda não está na newsletter, assine — toda semana um post novo sobre IA agêntica, desenvolvimento e ferramentas.