Pular para o conteúdo
Curso Claude Code

Módulo 3: MCP Servers e Integrações Externas

Conecte Claude Code com ferramentas externas usando Model Context Protocol (MCP). Integre Sentry, GitHub, bancos de dados e multiplique as capacidades do Claude Code.

Gustavo Miranda
40 min de leitura
LinkedIn𝕏X
MCP ServersModel Context ProtocolClaude CodeIntegraçõesSentryGitHub

Por que isso é importante

MCP (Model Context Protocol) é o que separa Claude Code básico do profissional. Conecta Claude com ferramentas externas: Sentry para debugging, GitHub para automação, bancos de dados para análise. Transforma Claude Code em central de comando do seu desenvolvimento.

Model Context Protocol permite que Claude Code se conecte com APIs, serviços e ferramentas externas, criando pipeline integrado de desenvolvimento. É como dar superpoderes ao Claude.

Neste módulo você instalará MCP servers essenciais, criará automações com GitHub, integrará debugging com Sentry, conectará bancos de dados e muito mais. Transformação completa do seu workflow.

Aula 1: Entendendo Model Context Protocol (MCP)

🧠 Conceitos Fundamentais

MCP Server:

Serviço que expõe ferramentas para Claude Code usar.

Context Bridge:

Conexão que permite Claude acessar dados externos.

Arquitetura do MCP

Fluxo de Comunicação

mcp-architecture
┌─────────────────┐    ┌──────────────┐    ┌────────────────┐
│   Claude Code   │◄──►│ MCP Protocol │◄──►│   External     │
│                 │    │              │    │   Services     │
│ - Prompts       │    │ - JSON-RPC   │    │ - Sentry       │
│ - Context       │    │ - WebSocket  │    │ - GitHub       │
│ - Workflows     │    │ - HTTP       │    │ - Databases    │
└─────────────────┘    └──────────────┘    └────────────────┘

Flow:
1. Claude Code identifica necessidade de ferramenta externa
2. MCP Protocol estabelece conexão segura
3. Dados são trocados via JSON-RPC/WebSocket
4. Claude processa resposta e integra ao contexto

Vantagens do MCP

  • • Acesso a dados em tempo real
  • • Automação de tarefas complexas
  • • Context awareness expandido

Casos de Uso

  • • Debugging inteligente
  • • Automação de deploys
  • • Análise de performance

Limitações

  • • Requer configuração inicial
  • • Dependente de APIs externas
  • • Possível overhead de latência

MCP vs Outras Formas de Integração

❌ Integrações Tradicionais

API Calls Manuais:

Claude não entende contexto da API, requer prompts detalhados

Webhooks Simples:

Comunicação unidirecional, sem feedback inteligente

✅ MCP Servers

Context Aware:

Claude entende dados e pode tomar decisões inteligentes

Bi-direcional:

Fluxo completo de dados com feedback e ações automatizadas

Aula 2: Instalação e Configuração de MCP Servers

🔧 Setup Prático

Configuração passo-a-passo dos principais MCP servers. Começamos com GitHub para automação básica e evoluímos para integrações mais complexas.

Passo 1: Configuração do Ambiente MCP

Estrutura de Configuração

mcp-setup
# Localização dos arquivos de configuração MCP
~/.config/claude-desktop/
├── claude_desktop_config.json  # Configuração principal
├── mcp-servers.json           # Lista de servers instalados
└── servers/                   # Servidores customizados
    ├── github-mcp/
    ├── sentry-mcp/
    └── database-mcp/

# Verificar configuração atual
claude mcp list

# Verificar status dos servers
claude mcp status

Arquivo de Configuração Base

claude_desktop_config.json
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    },
    "sentry": {
      "command": "npx", 
      "args": ["-y", "@sentry/mcp-server"],
      "env": {
        "SENTRY_AUTH_TOKEN": "your-sentry-token",
        "SENTRY_ORG": "your-org-slug"
      }
    }
  }
}

Passo 2: GitHub MCP Server (Essencial)

🐙 Por que GitHub MCP?

Automações:
  • • Criação automática de PRs
  • • Code review inteligente
  • • Gerenciamento de issues
Análises:
  • • Histórico de commits
  • • Análise de branching
  • • Métricas de código

Instalação GitHub MCP

1. Gerar Personal Access Token
github-token-setup
# Acesse: https://github.com/settings/tokens
# Create new token (classic)
# Permissões necessárias:
- repo (Full control of private repositories)
- read:org (Read org membership)  
- read:user (Read user profile data)
- write:discussion (Write team discussions)
2. Instalar via Command Universal
github-mcp-install
# Comando universal para instalar GitHub MCP
claude mcp install github

# Ou manualmente
claude mcp add-json github '{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-github"],
  "env": {
    "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
  }
}'

# Verificar instalação
claude mcp status github
3. Testar Funcionamento
github-mcp-test
# No Claude Code, teste os comandos:
/github-list-repos
/github-create-issue --title="Test MCP" --repo="your-repo"
/github-search-code --query="function handleSubmit"

# Exemplo de automação:
"Analise o último commit do repositório [nome] e crie um PR 
com melhorias de performance identificadas"

Passo 3: Sentry MCP Server (Debugging Inteligente)

🐛 Debugging Automático

Sentry MCP conecta Claude diretamente aos seus erros de produção. Claude pode analisar stack traces, identificar padrões e até usar o agente Seer para resolução automática.

Setup Sentry MCP

1. Obter Auth Token do Sentry
sentry-token-setup
# Acesse: https://sentry.io/settings/account/api/auth-tokens/
# Create New Token
# Scopes necessários:
- event:read
- org:read  
- project:read
- team:read

# Para usar Seer (AI do Sentry):
- event:write
- project:write
2. Instalar Sentry MCP
sentry-mcp-install
# Instalação automática
claude mcp install sentry

# Ou configuração manual
claude mcp add-json sentry '{
  "command": "npx",
  "args": ["-y", "@sentry/mcp-server"],
  "env": {
    "SENTRY_AUTH_TOKEN": "your-sentry-auth-token",
    "SENTRY_ORG": "your-organization-slug"
  }
}'

# Verificar conexão
claude mcp status sentry
3. Comandos Sentry Disponíveis
sentry-commands
# Comandos principais do Sentry MCP:
/sentry-list-issues        # Lista issues recentes
/sentry-get-issue          # Detalhe de issue específica  
/sentry-search-events      # Busca eventos por filtros
/sentry-fix-with-seer      # Usa IA do Sentry para fix automático

# Exemplos de uso:
/sentry-list-issues --project="my-app" --status="unresolved"
/sentry-fix-with-seer --issue-id="12345" --auto-assign=true

Aula 3: MCP Servers Avançados e Customizados

🚀 Nível Profissional

Integração com bancos de dados, Docker, sistemas de monitoramento e criação de MCP servers customizados para suas necessidades específicas.

Database MCP Server

🗃️ Capacidades de Database MCP

Análise de Schema:
  • • Otimização de queries
  • • Identificação de índices faltantes
  • • Análise de relacionamentos
Geração Automática:
  • • Migrations inteligentes
  • • Seeders baseados em schema
  • • Queries otimizadas

PostgreSQL MCP Setup

postgres-mcp-setup
# Instalar PostgreSQL MCP
npm install -g @modelcontextprotocol/server-postgres

# Configuração no claude_desktop_config.json
{
  "mcpServers": {
    "postgres": {
      "command": "mcp-server-postgres",
      "args": [],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/dbname"
      }
    }
  }
}

# Comandos disponíveis após instalação:
/postgres-query          # Executar query
/postgres-explain        # EXPLAIN ANALYZE de queries
/postgres-schema         # Analisar schema
/postgres-optimize       # Sugestões de otimização

Exemplos Práticos de Uso

postgres-usage-examples
# Análise de performance de query
"Analise a performance desta query e sugira otimizações:
SELECT u.*, p.title, COUNT(c.id) as comment_count
FROM users u 
LEFT JOIN posts p ON u.id = p.user_id 
LEFT JOIN comments c ON p.id = c.post_id 
GROUP BY u.id, p.id"

# Geração de migration
"Crie uma migration para adicionar índice composto nas colunas 
user_id e created_at da tabela posts para otimizar queries de timeline"

# Análise de schema
"Analise o schema atual e identifique relacionamentos faltantes, 
índices que poderiam melhorar performance e possíveis problemas de normalização"

Docker MCP Server

Instalação Docker MCP

docker-mcp-setup
# Instalar Docker MCP
npm install -g @modelcontextprotocol/server-docker

# Configuração
{
  "mcpServers": {
    "docker": {
      "command": "mcp-server-docker",
      "args": [],
      "env": {
        "DOCKER_HOST": "unix:///var/run/docker.sock"
      }
    }
  }
}

# Comandos Docker MCP disponíveis:
/docker-ps              # Listar containers
/docker-logs            # Logs de container
/docker-exec            # Executar comando em container
/docker-stats           # Estatísticas de recursos
/docker-compose         # Gerenciar docker-compose

Automações Docker Inteligentes

docker-automation-examples
# Debugging de container problemático
"O container da aplicação está com alta CPU. Analise os logs dos 
últimos 30 minutos, identifique o problema e sugira soluções."

# Health check automático
"Verifique a saúde de todos os containers em produção e me alerte 
sobre qualquer anomalia. Se encontrar problemas, execute diagnósticos."

# Otimização de recursos
"Analise o uso de recursos dos containers e sugira otimizações 
no docker-compose.yml para reduzir consumo de memória."

Criando MCP Server Customizado

🛠️ Quando Criar MCP Customizado

• API interna da empresa que precisa integrar

• Ferramenta específica que não tem MCP oficial

• Workflow único que requer automação especializada

• Integração com sistemas legados

Template MCP Server

custom-mcp-server.js
// mcp-server-custom.js
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from '@modelcontextprotocol/sdk/types.js';

class CustomMCPServer {
  constructor() {
    this.server = new Server(
      {
        name: 'custom-mcp-server',
        version: '1.0.0',
      },
      {
        capabilities: {
          tools: {},
        },
      }
    );

    this.setupToolHandlers();
  }

  setupToolHandlers() {
    // Listar ferramentas disponíveis
    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [
        {
          name: 'analyze-api-performance',
          description: 'Analyzes API endpoint performance',
          inputSchema: {
            type: 'object',
            properties: {
              endpoint: { type: 'string', description: 'API endpoint URL' },
              timeframe: { type: 'string', description: 'Analysis timeframe' }
            },
            required: ['endpoint']
          }
        }
      ]
    }));

    // Implementar lógica da ferramenta
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      switch (request.params.name) {
        case 'analyze-api-performance':
          return await this.analyzeAPIPerformance(request.params.arguments);
        default:
          throw new Error(`Unknown tool: ${request.params.name}`);
      }
    });
  }

  async analyzeAPIPerformance({ endpoint, timeframe = '1h' }) {
    // Implementar lógica de análise
    const metrics = await this.fetchAPIMetrics(endpoint, timeframe);
    
    return {
      content: [
        {
          type: 'text',
          text: `API Performance Analysis for ${endpoint}:
- Average Response Time: ${metrics.avgResponseTime}ms
- Error Rate: ${metrics.errorRate}%
- Throughput: ${metrics.requestsPerSecond} req/s
- Bottlenecks: ${metrics.bottlenecks.join(', ')}`
        }
      ]
    };
  }

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

const server = new CustomMCPServer();
server.run().catch(console.error);

Configuração e Deploy

custom-mcp-deploy
# package.json do MCP server customizado
{
  "name": "custom-mcp-server",
  "version": "1.0.0",
  "type": "module",
  "main": "mcp-server-custom.js",
  "scripts": {
    "start": "node mcp-server-custom.js"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "latest"
  }
}

# Instalar globalmente
npm install -g ./custom-mcp-server

# Configurar no Claude Code
{
  "mcpServers": {
    "custom": {
      "command": "custom-mcp-server",
      "args": [],
      "env": {
        "API_KEY": "your-api-key",
        "BASE_URL": "https://api.yourdomain.com"
      }
    }
  }
}

# Testar funcionamento
claude mcp status custom
/analyze-api-performance --endpoint="/api/users" --timeframe="24h"

Aula 4: Workflows Integrados com MCP Servers

🔗 Automação Completa

Combine workflows customizados com MCP servers para criar automações complexas que conectam múltiplas ferramentas e serviços em fluxos integrados.

Workflow: Investigação Completa de Bug

investigate-production-bug.md
# investigate-production-bug.md
# Production Bug Investigation Workflow

Investigate critical production bug using integrated MCP tools:

## Phase 1: Error Discovery & Triage
{{#mcp sentry}}
1. **Sentry Analysis**
   - Get error details from issue: {{issue_id}}
   - Analyze error frequency and user impact
   - Extract stack trace and affected components
{{/mcp}}

{{#mcp github}}
2. **Code Context** 
   - Find related code files from stack trace
   - Check recent commits that might have introduced the issue
   - Identify potential contributors for context
{{/mcp}}

## Phase 2: Impact Assessment
{{#mcp docker}}
3. **Infrastructure Health**
   - Check container resources and logs
   - Verify deployment status
   - Analyze performance metrics during error timeframe
{{/mcp}}

{{#mcp database}}
4. **Data Integrity Check**
   - Query patterns around error occurrence  
   - Check for data inconsistencies
   - Identify slow queries during incident
{{/mcp}}

## Phase 3: Resolution Planning
Based on gathered data:
- **Root Cause**: [To be determined from analysis]
- **Priority Level**: {{priority_level}}
- **Estimated Fix Time**: [Based on complexity]
- **Rollback Strategy**: [If immediate fix needed]

## Phase 4: Automated Actions
{{#if auto_fix_enabled}}
{{#mcp sentry}}
- Create Sentry issue assignment
- Set up error monitoring alerts
{{/mcp}}

{{#mcp github}}  
- Create GitHub issue with full context
- Assign to appropriate team members
- Create branch for fix implementation
{{/mcp}}
{{/if}}

## Output Format
Provide comprehensive bug report with:
- **Executive Summary**: Impact and urgency
- **Technical Details**: Stack traces, logs, queries
- **Resolution Plan**: Step-by-step fix approach
- **Prevention**: Long-term improvements to avoid recurrence

**Focus Area**: {{focus_area}} (if specified)
**Environment**: {{environment}}

Exemplo de Execução

workflow-execution
# Executar workflow integrado
claude --workflow investigate-production-bug \
  --issue_id="SENTRY-12345" \
  --priority_level="critical" \
  --environment="production" \
  --focus_area="payment processing" \
  --auto_fix_enabled=true

# Resultado esperado:
# 1. Dados do Sentry analisados
# 2. Código relacionado identificado no GitHub
# 3. Logs do Docker coletados
# 4. Queries de database analisadas
# 5. Issue e branch criados automaticamente

Workflow: Pipeline de Deploy Inteligente

intelligent-deploy-pipeline.md
# intelligent-deploy-pipeline.md  
# Intelligent Deploy Pipeline with MCP Integration

Execute comprehensive deployment with automated checks and rollback:

## Pre-Deploy Validation
{{#mcp github}}
### Code Quality Gates
- Run automated tests on branch: {{branch_name}}
- Check PR approval status
- Verify no merge conflicts exist
- Validate commit messages follow convention
{{/mcp}}

{{#mcp sentry}}
### Error Baseline
- Capture current error rates for comparison
- Set up deployment monitoring alerts
- Create deployment marker in Sentry
{{/mcp}}

## Deployment Execution  
{{#mcp docker}}
### Container Management
- Build new image with tag: {{version}}
- Run security scans on image
- Execute zero-downtime rolling deployment
- Health check all containers post-deploy
{{/mcp}}

{{#mcp database}}
### Database Operations
{{#if has_migrations}}
- Backup current database state
- Run migrations with rollback capability  
- Verify data integrity post-migration
{{/if}}
{{/mcp}}

## Post-Deploy Monitoring
{{#mcp sentry}}
### Error Monitoring (15-minute window)
- Monitor error rate increase >20% → Auto-rollback
- Check for new error types introduced
- Validate critical user journeys
{{/mcp}}

{{#mcp github}}
### Documentation Updates
- Update CHANGELOG.md with deployment info
- Create release notes from commits
- Close related issues automatically
{{/mcp}}

## Rollback Strategy
If issues detected:
1. **Immediate**: Rollback containers to previous version
2. **Database**: Restore from pre-deploy backup if needed
3. **Monitoring**: Reset alerts and create incident report
4. **Communication**: Auto-notify team via GitHub issue

## Success Criteria
- ✅ Zero critical errors in 15-minute window
- ✅ Response times within 10% of baseline  
- ✅ All health checks passing
- ✅ Database integrity verified

**Environment**: {{environment}}
**Version**: {{version}}
**Rollback Enabled**: {{auto_rollback}}

Monitoramento e Debug de MCP Servers

Comandos de Debug

mcp-debug-commands
# Verificar status de todos MCP servers
claude mcp status

# Debug específico de um server
claude mcp debug github --verbose

# Logs de um MCP server
claude mcp logs sentry --tail=50

# Testar conectividade
claude mcp test-connection postgres

# Resetar configuração de um server
claude mcp reset docker --confirm

Problemas Comuns e Soluções

Server Not Responding:

Verificar se tokens/credenciais estão válidos e se servidor externo está acessível

Rate Limit Exceeded:

Implementar cache local ou throttling nas requisições MCP

Memory Leak:

Reiniciar MCP servers periodicamente ou implementar connection pooling

🎉 MCP Masters Achieved!

MCP Servers InstaladosAutomações IntegradasWorkflows AvançadosPipeline Completo

Claude Code agora é seu central de comando de desenvolvimento! Conectado com GitHub, Sentry, bancos de dados e ferramentas customizadas.

🎯 Checklist do Módulo 3

MCP Servers Essenciais

✓GitHub MCP instalado e configurado
✓Sentry MCP para debugging automático
✓Database MCP para análise de queries
✓Docker MCP para container management

Workflows Integrados

✓Workflow de investigação de bug
✓Pipeline de deploy inteligente
✓MCP server customizado criado
✓Sistema de monitoramento implementado

📚 Recursos Adicionais

MCP Registry:

Biblioteca oficial de MCP servers

SDK Documentation:

Para criar servers customizados

Community Examples:

Workflows e integrações da comunidade

Continue Dominando Claude Code

Revise os módulos do curso e coloque tudo em prática