Jeff Bruchado
Voltar para o Blog

MCP (Model Context Protocol): O Padrão da Anthropic Que Está Unificando Agentes de IA

Olá HaWkers, em 2026 estamos testemunhando algo raro na indústria de tecnologia: empresas concorrentes adotando o mesmo padrão aberto. O Model Context Protocol (MCP), criado pela Anthropic, está sendo chamado de "USB-C da IA" e já foi adotado pela OpenAI, Microsoft e Google.

Por que esse protocolo é tão importante? E como ele muda a forma de construir aplicações com agentes de IA?

O Problema da Fragmentação

Cada empresa tinha sua própria solução.

Antes do MCP

Como era conectar IA a ferramentas:

OpenAI Function Calling:

// Formato específico da OpenAI
const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "Get weather for a location",
    parameters: {
      type: "object",
      properties: {
        location: { type: "string" }
      }
    }
  }
}];

Anthropic Tool Use:

// Formato específico da Anthropic
const tools = [{
  name: "get_weather",
  description: "Get weather for a location",
  input_schema: {
    type: "object",
    properties: {
      location: { type: "string" }
    }
  }
}];

Google Gemini Functions:

// Outro formato diferente
const tools = [{
  functionDeclarations: [{
    name: "get_weather",
    description: "Get weather for a location",
    parameters: {
      type: "OBJECT",
      properties: {
        location: { type: "STRING" }
      }
    }
  }]
}];

Três formatos diferentes para fazer a mesma coisa. Desenvolvedores precisavam manter código separado para cada provider.

O Que é o MCP

Protocolo aberto e universal.

Arquitetura do MCP

Como funciona:

┌─────────────────────────────────────────────────────────┐
│                    MCP Host (Client)                     │
│              (Claude, GPT, Gemini, etc.)                │
└────────────────────────┬────────────────────────────────┘
                         │
                    MCP Protocol
                    (JSON-RPC 2.0)
                         │
         ┌───────────────┼───────────────┐
         ▼               ▼               ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│  MCP Server  │ │  MCP Server  │ │  MCP Server  │
│   (GitHub)   │ │   (Slack)    │ │  (Database)  │
└──────────────┘ └──────────────┘ └──────────────┘

Conceitos Fundamentais

Três tipos de recursos:

1. Tools (Ferramentas):

// Ações que o agente pode executar
{
  "name": "create_issue",
  "description": "Create a GitHub issue",
  "inputSchema": {
    "type": "object",
    "properties": {
      "title": { "type": "string" },
      "body": { "type": "string" },
      "repo": { "type": "string" }
    },
    "required": ["title", "repo"]
  }
}

2. Resources (Recursos):

// Dados que o agente pode acessar
{
  "uri": "github://repos/user/project/issues",
  "name": "Project Issues",
  "mimeType": "application/json",
  "description": "List of open issues in the project"
}

3. Prompts (Templates):

// Templates de interação pré-definidos
{
  "name": "code_review",
  "description": "Review code changes",
  "arguments": [
    {
      "name": "pr_url",
      "description": "Pull request URL",
      "required": true
    }
  ]
}

Implementando um MCP Server

Criando sua própria integração.

Servidor Básico

Estrutura de um MCP Server:

// mcp-server.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

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

// Definir ferramentas disponíveis
server.setRequestHandler('tools/list', async () => {
  return {
    tools: [
      {
        name: 'search_database',
        description: 'Search records in the database',
        inputSchema: {
          type: 'object',
          properties: {
            query: {
              type: 'string',
              description: 'Search query'
            },
            limit: {
              type: 'number',
              description: 'Max results',
              default: 10
            }
          },
          required: ['query']
        }
      }
    ]
  };
});

// Implementar execução da ferramenta
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'search_database') {
    const results = await searchDB(args.query, args.limit);
    return {
      content: [
        {
          type: 'text',
          text: JSON.stringify(results, null, 2)
        }
      ]
    };
  }

  throw new Error(`Unknown tool: ${name}`);
});

// Iniciar servidor
const transport = new StdioServerTransport();
await server.connect(transport);

Servidor com Resources

Expondo dados para o agente:

// Listar recursos disponíveis
server.setRequestHandler('resources/list', async () => {
  return {
    resources: [
      {
        uri: 'myapp://users/active',
        name: 'Active Users',
        description: 'List of currently active users',
        mimeType: 'application/json'
      },
      {
        uri: 'myapp://metrics/daily',
        name: 'Daily Metrics',
        description: 'Today\'s application metrics',
        mimeType: 'application/json'
      }
    ]
  };
});

// Ler conteúdo de um recurso
server.setRequestHandler('resources/read', async (request) => {
  const { uri } = request.params;

  if (uri === 'myapp://users/active') {
    const users = await getActiveUsers();
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(users)
        }
      ]
    };
  }

  if (uri === 'myapp://metrics/daily') {
    const metrics = await getDailyMetrics();
    return {
      contents: [
        {
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(metrics)
        }
      ]
    };
  }

  throw new Error(`Resource not found: ${uri}`);
});

Servidores MCP Populares

Integrações prontas para usar.

Servidores Oficiais

Disponíveis da Anthropic:

GitHub:

npx @anthropic/mcp-server-github
  • Criar/editar issues e PRs
  • Buscar código no repositório
  • Acessar histórico de commits

Slack:

npx @anthropic/mcp-server-slack
  • Enviar mensagens
  • Listar canais
  • Buscar histórico

PostgreSQL:

npx @anthropic/mcp-server-postgres
  • Executar queries
  • Listar tabelas
  • Acessar schema

Filesystem:

npx @anthropic/mcp-server-filesystem
  • Ler/escrever arquivos
  • Listar diretórios
  • Buscar conteúdo

Configuração no Claude Desktop

Como conectar servidores:

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost/db"
      }
    },
    "custom": {
      "command": "node",
      "args": ["/path/to/my-mcp-server.js"]
    }
  }
}

Adoção pela Indústria

Quem está usando MCP.

OpenAI e Microsoft

Anúncio oficial em janeiro 2026:

  • OpenAI adotou MCP para GPT-4 e GPT-5
  • Microsoft integrou ao Copilot
  • Azure AI Services suporta MCP nativamente

Benefícios imediatos:

  • Desenvolvedores escrevem uma integração, funciona em todos os modelos
  • Ecossistema compartilhado de servidores MCP
  • Redução de 70% no código de integração

Google

Implementação gradual:

  • Gemini Pro suporta MCP desde dezembro 2025
  • Google Cloud oferece MCP servers gerenciados
  • Vertex AI tem suporte nativo

Comunidade Open Source

Crescimento explosivo:

Estatísticas GitHub (Janeiro 2026):

  • 500+ servidores MCP públicos
  • 12k+ stars no repositório principal
  • 200+ contribuidores ativos

Servidores populares da comunidade:

  • Notion MCP Server
  • Jira MCP Server
  • AWS MCP Server
  • Linear MCP Server
  • Figma MCP Server

Casos de Uso Avançados

Aplicações práticas do MCP.

Agente de DevOps

Workflow automatizado:

// O agente pode usar múltiplos servidores MCP
// para criar um workflow completo

// 1. Recebe alerta do PagerDuty (MCP Server)
// 2. Busca logs no DataDog (MCP Server)
// 3. Identifica o problema
// 4. Cria issue no GitHub (MCP Server)
// 5. Notifica no Slack (MCP Server)
// 6. Sugere fix e abre PR (MCP Server)

// Prompt do usuário:
// "Investigue o alerta de alta latência e crie
// um issue com sua análise"

// O agente automaticamente:
// - Consulta métricas
// - Analisa logs
// - Correlaciona eventos
// - Documenta findings
// - Notifica equipe

Agente de Análise de Dados

Acesso a múltiplas fontes:

// Servidores MCP conectados:
// - PostgreSQL (dados transacionais)
// - BigQuery (dados analíticos)
// - Notion (documentação)
// - Slack (contexto de negócio)

// Prompt: "Analise as vendas do último trimestre
// e compare com as metas definidas no Notion"

// O agente:
// 1. Busca metas no Notion
// 2. Query vendas no PostgreSQL
// 3. Agregações no BigQuery
// 4. Gera relatório
// 5. Posta resumo no Slack

Segurança e Boas Práticas

Como implementar com segurança.

Controle de Acesso

Limitando permissões:

// Definir escopo de permissões
const server = new Server({
  name: 'secure-mcp-server',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {
      // Apenas ferramentas de leitura
      allowedOperations: ['read', 'search']
    },
    resources: {
      // Recursos específicos
      allowedPatterns: ['myapp://public/*']
    },
  },
});

// Validar inputs
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  // Sanitizar inputs
  const sanitizedArgs = sanitize(args);

  // Verificar rate limits
  await checkRateLimit(request.context.clientId);

  // Audit log
  await logAccess({
    tool: name,
    args: sanitizedArgs,
    client: request.context.clientId,
    timestamp: new Date()
  });

  return executeTool(name, sanitizedArgs);
});

O Model Context Protocol representa uma mudança fundamental na forma como construímos aplicações com IA. Pela primeira vez, temos um padrão aberto adotado por todos os principais players. Isso reduz a fragmentação, acelera o desenvolvimento e cria um ecossistema robusto de integrações.

Se você quer entender mais sobre agentes de IA na prática, recomendo ver outro artigo: n8n e Workflows de Agentes IA onde você descobrirá como criar automações inteligentes sem código.

Bora pra cima! 🦅

🎯 Junte-se aos Desenvolvedores que Estão Evoluindo

Milhares de desenvolvedores já usam nosso material para acelerar seus estudos e conquistar melhores posições no mercado.

Por que investir em conhecimento estruturado?

Aprender de forma organizada e com exemplos práticos faz toda diferença na sua jornada como desenvolvedor.

Comece agora:

  • 1x de R$27,00 no cartão
  • ou R$27,00 à vista no Pix

🚀 Acessar Guia Completo

"Material excelente para quem quer se aprofundar!" - João, Desenvolvedor

Comentários (0)

Esse artigo ainda não possui comentários 😢. Seja o primeiro! 🚀🦅

Adicionar comentário