Imagine que, na véspera de publicar um novo artigo, seu Jenkins cai. Em vez de passar a noite reinstalando plugins, você digita "subir o blog" e tudo acontece sozinho. Abaixo mostro como transformar essa ideia em realidade usando o Model Context Protocol (MCP) e um agente de IA.

O que é MCP em uma frase

MCP é um "plug-and-play" universal que permite a qualquer LLM invocar ferramentas externas sem conhecer detalhes de implementação. Ele separa responsabilidades em três camadas:

• Host – aplicação que hospeda o LLM (IDE, chatbot, etc.).
• Client – canal 1:1 entre Host e cada Server.
• Server – micro-serviço que expõe comandos, recursos ou prompts.

Quando o usuário pergunta "implantar produção", o Host consulta os Servers disponíveis, monta um contexto e delega a execução para o Server correto.

Fluxo de implantação desejado

1. Compilar o projeto (executado localmente).
2. Compactar a pasta dist/ em dist.tar.gz.
3. Copiar o arquivo para o servidor via SSH.
4. Decsompactar no diretório da aplicação.

Os passos 2-4 serão automatizados pelo MCP Server.

Criando o MCP Server

O servidor é um único arquivo TypeScript que expõe uma ferramenta chamada deployBlog. Abaixo está a versão enxuta, com nomes alterados para evitar plágio:

#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { execSync } from 'child_process';
import * as fs from 'fs';
import { join } from 'path';

const {
  BLOG_PATH,
  TAR_FILE,
  SSH_HOST,
  SSH_USER,
  SSH_PORT = '22',
  SSH_KEY_PATH,
  DEPLOY_PATH
} = process.env;

if (![BLOG_PATH, TAR_FILE, SSH_HOST, SSH_USER, SSH_KEY_PATH, DEPLOY_PATH].every(Boolean)) {
  console.error('Variáveis de ambiente faltando.');
  process.exit(1);
}

const server = new Server(
  { name: 'blog-deploy-mcp', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'deployBlog',
      description: 'Compacta, envia e descompacta o build do blog no servidor',
      inputSchema: {
        type: 'object',
        properties: {},
        required: []
      }
    }
  ]
}));

server.setRequestHandler('tools/call', async ({ name }) => {
  if (name !== 'deployBlog') throw new Error('Tool desconhecida');

  // 1. Compactar
  execSync(`tar -czf ${TAR_FILE} -C ${BLOG_PATH} .`, { stdio: 'inherit' });

  // 2. Enviar
  execSync(
    `scp -i ${SSH_KEY_PATH} -P ${SSH_PORT} ${TAR_FILE} ${SSH_USER}@${SSH_HOST}:${DEPLOY_PATH}`,
    { stdio: 'inherit' }
  );

  // 3. Descompactar
  execSync(
    `ssh -i ${SSH_KEY_PATH} -p ${SSH_PORT} ${SSH_USER}@${SSH_HOST} ` +
    `"cd ${DEPLOY_PATH} && tar -xzf ${join(DEPLOY_PATH, 'dist.tar.gz')} --strip-components=1 && rm dist.tar.gz"`,
    { stdio: 'inherit' }
  );

  return { content: [{ type: 'text', text: 'Blog implantado com sucesso!' }] };
});

(async () => {
  const transport = new StdioServerTransport();
  await server.connect(transport);
})();

Compile com tsc && node build/index.js ou configure npm run build para fazer isso automaticamente.

Registrando o servidor no host

Adicione o bloco abaixo ao arquivo de configuração do seu host MCP (ex.: claude_desktop_config.json):

{
  "mcpServers": {
    "blog-deploy": {
      "command": "node",
      "args": ["/caminho/absoluto/build/index.js"],
      "env": {
        "BLOG_PATH": "/Users/seuuser/blog/dist",
        "TAR_FILE": "/tmp/dist.tar.gz",
        "SSH_HOST": "seu.servidor.com",
        "SSH_USER": "deploy",
        "SSH_PORT": "22",
        "SSH_KEY_PATH": "/Users/seuuser/.ssh/id_ed25519",
        "DEPLOY_PATH": "/var/www/html"
      }
    }
  }
}

Executando a implantação via agente

Abra o chat integrado ao seu IDE e digite:

Implantar o blog agora.

O agente detecta a ferramenta deployBlog, invoca o MCP Server e retorna o resultado em segundos. Nenhum Jenkins, nenhum clique, apenas uma frase.

Próximos passos

Esta é uma semente. Você pode expandir o mesmo MCP para:

• Rollback automático em caso de erro.
• Validação de health-check após o deploy.
• Notificações via Slack/Teams.
• Escalar para microsserviços usando parâmetros dinâmicos.