Servidores MCP: estender a IA com ferramentas reais

Grandes modelos de linguagem são inteligentes. Podem raciocinar, escrever, analisar e criar. Mas também são isolados. Por padrão, um LLM não pode olhar o clima de hoje, verificar seu banco de dados, pesquisar na web ou ler um arquivo do seu computador. Ele só sabe o que estava nos dados de treinamento dele e o que você cola no prompt.

MCP — o Model Context Protocol — muda isso. É um padrão para conectar modelos de IA a ferramentas externas. Pense nele como USB para IA: uma tomada universal que deixa qualquer modelo usar qualquer ferramenta, desde que ambos falem o protocolo.

Como o MCP funciona

O fluxo é simples:

A ideia-chave: o LLM decide quando usar uma ferramenta. Você não escreve código que diga “se o usuário perguntar sobre GitHub, chame a API do GitHub.” O modelo entende a intenção do usuário, reconhece que precisa de dados externos, chama o servidor MCP apropriado, pega o resultado e incorpora na resposta.

Isso é o que torna o MCP poderoso — e o que o torna diferente de integrações tradicionais de API em que um desenvolvedor tem que antecipar cada fluxo possível.

Quais servidores MCP existem

Existem 117 servidores MCP disponíveis no Zubnet. Aqui estão as categorias e alguns destaques:

Ferramentas de desenvolvimento

• GitHub — pesquisar repos, criar/ler/fechar issues, listar PRs, ler conteúdo de arquivos, criar branches
• GitLab — similar ao GitHub, para projetos hospedados no GitLab
• Linear — criar e gerenciar issues, ler status de projetos
• Sentry — pesquisar erros, ler stack traces, resolver issues

Bancos de dados

• PostgreSQL — executar queries de leitura contra seu BD Postgres
• MySQL — o mesmo para MySQL/MariaDB
• SQLite — consultar arquivos SQLite locais
• Redis — ler chaves, escanear padrões

Pesquisa e investigação

• Brave Search — busca web sem tracking
• Exa — busca semântica pela web
• ArXiv — pesquisar papers acadêmicos
• Wikipedia — consultar conhecimento enciclopédico

Sistemas de arquivos e armazenamento

• Filesystem — ler, escrever, listar e pesquisar arquivos num diretório especificado
• Google Drive — pesquisar e ler documentos do Drive
• S3 — listar e ler objetos de buckets AWS S3

Comunicação

• Slack — ler canais, enviar mensagens, pesquisar histórico
• Discord — ler e enviar mensagens em servidores
• Email — ler e rascunhar e-mails via IMAP/SMTP

Dados e APIs

• Fetch — fazer requisições HTTP para qualquer URL
• Puppeteer — navegar páginas web, tirar screenshots, extrair conteúdo
• Google Maps — geocodificação, direções, pesquisa de lugares

Navegue a lista completa na nossa MCP Store.

Configuração para Claude Desktop

O Claude Desktop suporta MCP nativamente. Para conectar um servidor, você adiciona a configuração dele ao arquivo de config do Claude. Na MCP Store do Zubnet, cada servidor tem um botão de copiar com um clique para essa config exata.

O arquivo de config vive em:

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

É assim que uma config com dois servidores MCP se parece:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_key_here"
      }
    }
  }
}

Salve o arquivo, reinicie o Claude Desktop, e as ferramentas aparecem automaticamente. O Claude vai usá-las quando forem relevantes para sua conversa.

Configuração para Cursor

O Cursor (o editor de código com IA) também suporta MCP. A config vai no arquivo .cursor/mcp.json do seu projeto:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/path/to/your/project"
      ]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:pass@localhost/mydb"
      }
    }
  }
}

Isso dá à IA do Cursor a capacidade de ler seus arquivos de projeto e consultar seu banco de dados — tornando-a dramaticamente melhor em entender seu codebase e responder perguntas sobre seus dados.

Configuração no Zubnet

Para agentes rodando na plataforma Zubnet, a configuração de servidores MCP é ainda mais simples:

1. Vá à MCP Store

2. Encontre o servidor que você quer (ex., GitHub)

3. Clique em “Ativar”

4. Insira a configuração necessária (chaves de API, URLs, etc.)

5. Conecte ao seu agente

O servidor roda na nossa infraestrutura. Sem instalação local, sem npx, sem Node.js necessário. Só funciona.

Esquemas de config: o que cada servidor precisa

Todo servidor MCP precisa de alguma configuração. Os padrões mais comuns:

Como a IA decide usar ferramentas

Essa é a parte que parece mágica. Você não escreve regras. O LLM descobre.

Quando você pergunta “quais issues abertos temos no GitHub?”, o modelo reconhece que:

1. Isso exige dados que ele não tem (seus issues específicos do GitHub)
2. Uma ferramenta do GitHub está disponível
3. A função list_issues com state=open é a chamada certa

Ele constrói a chamada de ferramenta, envia ao servidor MCP, pega a resposta JSON e depois resume em linguagem natural.

Para tarefas multi-passo, o modelo encadeia chamadas de ferramentas. “Encontre o issue aberto mais comentado e publique um resumo no #dev-chat do Slack” pode envolver:

1. github.list_issues(state=open, sort=comments)
2. github.get_issue(number=142) (para detalhes completos)
3. slack.post_message(channel=#dev-chat, text=...)

Três chamadas de ferramentas, orquestradas automaticamente. Sem código escrito.

Considerações de segurança

Construindo seu próprio servidor MCP

A especificação do MCP é aberta. Se a ferramenta de que você precisa ainda não existe, você pode construí-la. Um servidor MCP é um programa que:

1. Declara suas ferramentas disponíveis (nome, descrição, esquema de parâmetros)
2. Trata requisições de chamadas de ferramenta
3. Retorna resultados estruturados

O SDK oficial está disponível em TypeScript e Python. Um servidor mínimo em TypeScript são umas 50 linhas de código. A especificação e os SDKs estão em modelcontextprotocol.io.

Se você construir um servidor que outros poderiam achar útil, considere publicá-lo no ecossistema MCP. A comunidade cresce toda semana.

Quando usar MCP vs. chamadas de API regulares

MCP nem sempre é a resposta certa. Use quando:

• Você quer que a IA decida quando chamar serviços externos (fluxos dinâmicos, guiados pelo usuário)
• Você está construindo agentes que precisam acesso a ferramentas
• Você quer uma interface padrão entre muitas ferramentas (um protocolo, 117 servidores)

Use chamadas de API regulares quando:

• O fluxo é determinístico (sempre chamar essa API, depois aquela)
• Você precisa de controle preciso sobre cada requisição
• Performance é crítica e você não pode bancar o loop de decisão do LLM

---

Navegue os 117 servidores MCP na nossa MCP Store. Configurações com um clique para Claude Desktop e Cursor. Ou ative diretamente para seus agentes do Zubnet.