🌍 Conectando o Claude (MCPs)

Token tax e o custo em tokens que cada MCP conectado adiciona a TODA interacao, mesmo quando voce nao esta usando aquele MCP. O schema das tools e injetado no contexto automaticamente.

Conectar 5 MCPs ao mesmo tempo pode consumir 30-50% do seu contexto so com schemas. Sem entender token tax, voce perde qualidade de resposta sem saber por que.

Cada MCP expoe tools com descricoes e parametros. Essas definicoes sao enviadas como tokens de entrada em cada mensagem. Mais MCPs = mais tokens fixos = menos espaco para seu codigo.

Filesystem: ~500 tokens (Low). GitHub: ~2.000 tokens (Moderate). Browser: ~5.000+ tokens (HIGH). Supabase: ~1.500 tokens (Moderate). Google Sheets: ~800 tokens (Low-Moderate).

Com a tabela de overhead, voce planeja quais MCPs manter conectados e quais ativar sob demanda. E a base da estrategia de rotacao ativa (modulo 6.9).

MCPs com muitas tools (Browser tem 10+) custam mais. MCPs simples (Filesystem tem 3-4 tools) custam pouco. O overhead e FIXO por mensagem, nao por uso.

Pense no contexto como oxigenio dentro de um capacete de astronauta. Quanto mais MCPs voce conecta, mais tubos compartilham o mesmo tanque. Com menos oxigenio, o Claude pensa pior.

A metafora torna tangivel algo abstrato. Operadores que entendem isso naturalmente evitam conectar MCPs desnecessarios e priorizam espaco para codigo e instrucoes.

Janela de contexto = tanque de oxigenio (200k tokens). MCPs = equipamentos que consomem oxigenio. Codigo + conversa = o que precisa do oxigenio para funcionar bem.

Regra de ouro: mantenha no maximo 2-3 MCPs conectados simultaneamente. Mais que isso e voce comeca a sacrificar qualidade de resposta por conveniencia.

Ter um limite mental evita o acumulo gradual de MCPs que corroi a performance sem voce perceber. E a base da disciplina operacional com MCPs.

2-3 MCPs = sweet spot. 4-5 MCPs = degradacao perceptivel. 6+ MCPs = desperdicio significativo. Sempre desconecte o que nao esta usando ativamente.

Use /cost antes e depois de conectar MCPs para ver o impacto real no consumo de tokens. A diferenca entre sessoes com e sem MCPs revela o token tax na pratica.

Teoria sem medicao e achismo. O /cost transforma token tax de conceito abstrato em numero concreto que voce pode otimizar.

Compare: sessao sem MCPs vs com MCPs fazendo a mesma tarefa. A diferenca no /cost e o token tax real. Use isso para justificar quais MCPs valem a pena.

Com muitos MCPs, o Claude recebe menos espaco para "pensar" sobre seu codigo. Respostas ficam mais curtas, menos detalhadas e com mais erros. O contexto competido degrada a inteligencia efetiva.

Muitos operadores culpam o modelo quando a qualidade cai, mas o problema real e contexto saturado. Entender isso evita frustracoes e otimiza resultados.

Contexto < 50% usado = respostas otimas. 50-70% = respostas boas. 70-90% = degradacao visivel. 90%+ = erros frequentes e respostas truncadas. MCPs aceleram essa curva.

Se a tarefa segue um padrao previsivel e repetitivo (code review, criar componente, gerar testes), ela e candidata perfeita para Skill. Skills sao instrucoes em Markdown, zero overhead de tokens.

Usar MCP para algo que uma Skill resolve e desperdicar tokens. Skills custam zero em token tax, MCPs custam centenas a milhares por mensagem.

Skill = prompt reutilizavel (zero infra). Exemplos: /review, /create-component, /generate-tests. Se a tarefa nao precisa de dados externos ao vivo, e Skill.

Se a tarefa precisa de dados ao vivo de um servico externo (consultar banco, ler issues do GitHub, acessar planilha), ela exige MCP. Skills nao acessam APIs.

Tentar fazer com Skill o que exige dados ao vivo resulta em invencoes e alucinacoes. O Claude fabricara dados em vez de admitir que nao tem acesso.

MCP = ponte para servicos vivos. Exemplos: consultar DB production, ler issues abertas, acessar dados de planilha. Se precisa de dados fresh, e MCP.

Tarefas de formatacao, padronizacao de codigo, geracao de boilerplate, criacao de templates - tudo isso e dominio de Skills. Sao instrucoes que moldam output, nao que buscam dados.

Muitos operadores criam MCPs complexos para tarefas que uma Skill de 20 linhas resolve. O resultado e overhead desnecessario e mais pontos de falha.

Skill para: code style, commit messages, PR templates, component boilerplate, documentation format. Se e sobre COMO formatar, e Skill.

Coletar dados de websites, acessar paginas, extrair informacoes de URLs - tudo isso exige um MCP de browser ou fetch. O Claude nao tem acesso nativo a internet.

Web scraping e um dos casos de uso mais poderosos de MCPs. Com o Browser MCP, o Claude le paginas reais e extrai dados estruturados.

Browser MCP para: ler paginas web, extrair precos, coletar leads de LinkedIn, verificar sites concorrentes. Alto custo de tokens mas alto valor de output.

Quando eficiencia de tokens e prioridade (sessoes longas, planos com limite), prefira Skills sempre que possivel. Skills consomem zero overhead fixo.

Em sessoes longas com compactacoes frequentes, cada token economizado se multiplica. Uma Skill que substitui um MCP pode economizar milhares de tokens por sessao.

Skills = 0 token tax. MCPs = 500-5000+ tokens fixos. Em 50 mensagens, um MCP de 2000 tokens custa 100k tokens extras. Prefira Skill quando possivel.

Tabela: Code review -> Skill. Consultar DB -> MCP. Gerar componente -> Skill. Ler issues GitHub -> MCP. Formatar commit -> Skill. Navegar website -> MCP.

Uma referencia rapida elimina hesitacao. Cole na parede ou no CLAUDE.md e consulte sempre que surgir duvida sobre Skill vs MCP.

Regra geral: se a resposta para "precisa de dados externos ao vivo?" for SIM = MCP, NAO = Skill. Simples, eficaz, e cobre 90% dos casos.

O Filesystem MCP expande o acesso do Claude para alem do diretorio atual. Com ele, o Claude le e escreve arquivos em qualquer caminho do seu sistema que voce autorizar.

Sem este MCP, o Claude so acessa o diretorio onde foi iniciado. Com ele, voce pode copiar configs entre projetos, acessar templates globais e gerenciar multiplos repos.

Expoe tools: read_file, write_file, list_directory, search_files. Funciona via caminhos absolutos com permissoes que voce define na instalacao.

O Filesystem e o MCP com melhor relacao custo-beneficio: ~500 tokens de overhead para acesso completo ao sistema de arquivos. E o unico MCP que muitos operadores mantem sempre conectado.

Saber que o Filesystem e "sempre ligado" simplifica decisoes. Enquanto outros MCPs sao rotativos, este e fixo no seu setup.

~500 tokens overhead (menos que uma mensagem curta). Habilita workflows cross-repo. ROI altissimo para qualquer tipo de projeto.

Instale com: claude mcp add filesystem -- npx -y @anthropic/mcp-filesystem /caminho/permitido. Substitua /caminho/permitido pelo diretorio que deseja expor.

O comando e simples mas a configuracao de caminhos e critica para seguranca. Expor / (raiz) e perigoso. Prefira caminhos especificos como ~/projetos.

claude mcp add filesystem -- npx -y @anthropic/mcp-filesystem ~/projetos. Pode adicionar multiplos caminhos separados por espaco. Caminhos sao whitelist, nao blacklist.

Casos: copiar componentes entre projetos, acessar configs globais (~/.config), ler templates de outro repo, comparar implementacoes entre projetos diferentes.

Operadores avancados trabalham em multiplos projetos simultaneamente. O Filesystem MCP e o que permite esse workflow multi-repo fluido.

Cross-repo: copie patterns de um projeto para outro. Global configs: leia .bashrc, .gitconfig, etc. Templates: acesse boilerplate de qualquer lugar.

O Filesystem MCP tem o menor token tax entre os MCPs populares: ~500 tokens por mensagem. Isso e menos que um paragrafo de texto e praticamente insignificante.

Saber que e Low impact justifica mante-lo sempre conectado. Nao faz sentido desconectar algo que custa tao pouco e entrega tanto valor.

~500 tokens = 0.25% do contexto de 200k. Pode manter ligado o tempo todo. Unico MCP onde "always on" e recomendado para todos.

Melhores praticas: nunca exponha / (raiz). Use caminhos especificos. Nao exponha ~/.ssh ou ~/.aws. Prefira ~/projetos ou ~/dev. Revise permissoes periodicamente.

Seguranca com Filesystem MCP e critica. Um caminho mal configurado pode expor chaves SSH, credenciais AWS e outros segredos ao contexto do Claude.

Whitelist > blacklist. Minimo privilegio: exponha so o necessario. Nunca exponha diretorios com credenciais. Revise com claude mcp list periodicamente.

O GitHub MCP conecta o Claude a API do GitHub. O Claude pode listar issues, criar PRs, ler reviews, verificar checks de CI/CD e gerenciar repositorios programaticamente.

GitHub e o hub central de desenvolvimento. Com este MCP, o Claude entende o contexto completo do seu projeto: issues abertas, PRs pendentes, feedback de reviewers.

Tools: list_issues, create_pull_request, get_pull_request_reviews, search_repositories, get_file_contents. Acesso direto via GitHub API com autenticacao por token.

Com GitHub MCP, o Claude sabe quais issues estao abertas, quem pediu o que, qual o feedback dos reviewers. Isso transforma o Claude de "editor de codigo" em "membro da equipe".

Sem GitHub MCP, voce precisa copiar/colar issues e comentarios manualmente. Com ele, o Claude busca e processa tudo sozinho, economizando seu tempo.

Workflow: "leia a issue #42 e implemente" - o Claude busca a issue, entende os requisitos e implementa. Zero copy-paste, 100% contexto automatico.

Instale com: claude mcp add github -- npx -y @anthropic/mcp-github. Configure GITHUB_TOKEN como variavel de ambiente com um Personal Access Token (PAT) do GitHub.

A instalacao e simples mas a configuracao do token requer atencao: defina escopos minimos (repo, read:org) e nunca use tokens com permissoes de admin.

1. Crie um PAT em github.com/settings/tokens. 2. export GITHUB_TOKEN=ghp_xxx. 3. claude mcp add github -- npx -y @anthropic/mcp-github. 4. Verifique com /status.

Casos: "leia a issue #42 e implemente", "crie um PR com essas mudancas", "liste issues com label bug", "verifique se o CI passou no ultimo commit".

Cada caso de uso representa horas economizadas. O Claude pode triagiar issues, criar PRs formatados e ate responder reviews - tudo via MCP.

Issue-driven: leia issue -> implemente -> crie PR -> linkei issue. Review-driven: leia comments -> ajuste codigo -> responda review. CI-driven: verifique falhas -> corrija.

O GitHub MCP tem impacto moderado: ~2.000 tokens por mensagem. Justificavel quando voce esta trabalhando ativamente com issues e PRs, mas desnecessario em tarefas puramente de codigo.

Saber que e Moderate ajuda na decisao de quando conectar/desconectar. Use quando precisar interagir com GitHub, desconecte quando estiver so codando.

~2.000 tokens = 1% do contexto. Conecte quando: trabalhando com issues/PRs. Desconecte quando: codando features sem referencia a issues. Rotacao inteligente.

Em vez de "liste todas as issues", peca "liste issues com label bug criadas essa semana". Queries especificas retornam menos dados e consomem menos tokens de resposta.

Queries amplas retornam centenas de issues que enchem o contexto. Queries focadas retornam so o necessario, mantendo o contexto limpo para codigo.

Filtre por: label, assignee, state, created date. Peca campos especificos. Evite listar repos inteiros. Quanto mais preciso o pedido, menor o custo em tokens.

O Browser MCP da ao Claude a capacidade de abrir paginas web, clicar em elementos, preencher formularios, tirar screenshots e extrair conteudo de qualquer site.

Com Browser MCP, o Claude se torna um agente web completo. Ele pode verificar se seu deploy funcionou, scrape dados de concorrentes, ou testar UI automaticamente.

Tools: navigate, click, fill, screenshot, get_text, evaluate_js. Usa Puppeteer/Playwright por tras. O Claude ve e interage com a web como um usuario real.

Browser e o unico MCP que da "olhos" ao Claude. Nenhum outro MCP permite verificar UI visualmente, scrape dados ao vivo ou testar flows de usuario. E insubstituivel para certas tarefas.

Operadores que dominam Browser MCP conseguem automatizar workflows que antes exigiam intervencao manual: QA visual, lead scraping, competitive analysis.

Elite porque: unico com capacidade visual. Caro porque: screenshots consomem muitos tokens. Estrategia: use pontualmente, nunca "always on".

Instale com: claude mcp add browser -- npx -y @anthropic/mcp-puppeteer. Requer Chrome/Chromium instalado no sistema. Funciona em headless mode por padrao.

A instalacao pode falhar se Chrome nao estiver disponivel. Saber os pre-requisitos evita troubleshooting desnecessario.

Pre-req: Chrome/Chromium. Comando: claude mcp add browser -- npx -y @anthropic/mcp-puppeteer. Teste: peca ao Claude para navegar a um site e tirar screenshot.

Casos: verificar visualmente se um deploy esta correto, extrair dados de paginas web, coletar leads do LinkedIn, testar flows de checkout, monitorar precos de concorrentes.

Browser MCP transforma o Claude em um assistente de QA visual e um web scraper inteligente. Tarefas que levavam horas manualmente agora levam minutos.

QA: "navegue para localhost:3000 e verifique se o header esta correto". Scraping: "extraia precos de produto.com". Leads: "colete nomes e emails de diretorio.com".

Browser e o MCP mais caro: ~5.000+ tokens de overhead fixo por mensagem, e screenshots adicionam milhares de tokens extras. Uma unica screenshot pode custar 10.000+ tokens.

Sem esse conhecimento, operadores deixam Browser conectado durante sessoes de coding puro, desperdicando 5.000+ tokens por mensagem sem beneficio algum.

~5.000 tokens overhead fixo + tokens por screenshot/pagina. Em 20 mensagens = 100k+ tokens desperdicados se nao estiver usando. SEMPRE desconecte quando nao precisar.

Regra de ouro do Browser MCP: conecte APENAS quando precisar de acesso visual. Backend puro? Desconecte. Refatorando API? Desconecte. So precisa de UI check? Conecte, use, desconecte.

A disciplina de conectar/desconectar Browser e o que separa operadores eficientes de operadores desperdicadores. E a regra #1 de rotacao ativa.

Workflow: claude mcp add browser (quando precisar) -> use -> claude mcp remove browser (quando terminar). Nunca deixe ligado "por conveniencia".

O Database MCP conecta o Claude a bancos PostgreSQL. O Claude pode executar queries SQL, explorar schemas, analisar dados e ate sugerir migrations baseadas no estado atual do banco.

Com acesso direto ao banco, o Claude pode debugar issues de dados, validar migrations antes de aplicar, e escrever queries otimizadas baseadas no schema real.

Tools: execute_query, list_tables, describe_table, get_schema. O Claude ve a estrutura real do banco e escreve SQL baseado nela, nao em suposicoes.

Para PostgreSQL generico: claude mcp add postgres -- npx -y @anthropic/mcp-postgres "postgresql://user:pass@host:5432/dbname". A connection string e passada como argumento.

PostgreSQL e o banco mais popular para apps modernos. Saber conectar diretamente permite debug rapido e exploracao de dados sem tools externas.

Connection string: postgresql://user:pass@host:5432/db. Para local: localhost. Para cloud: use o hostname do provider. NUNCA commite a connection string.

Para Supabase: claude mcp add supabase -- npx -y @supabase/mcp-server-supabase --supabase-url https://xxx.supabase.co --supabase-key sua-service-role-key.

Supabase adiciona funcionalidades alem do SQL puro: auth, storage, realtime. O MCP especifico do Supabase expoe essas APIs diretamente ao Claude.

Use service_role key (nao anon key) para acesso completo. Encontre URL e key em supabase.com/dashboard. O MCP do Supabase inclui tools para auth, storage e database.

Casos: "mostre as ultimas 10 orders com status failed", "sugira um indice para essa query lenta", "crie uma migration para adicionar coluna email_verified", "analise distribuicao de usuarios por plano".

Debug de dados ao vivo no terminal e extremamente produtivo. Em vez de abrir pgAdmin ou Supabase Dashboard, peca direto ao Claude.

Debug: queries com WHERE e LIMIT. Migrations: baseadas no schema real. Analise: GROUP BY, COUNT, AVG. Performance: EXPLAIN ANALYZE via Claude.

Database MCP tem impacto moderado: ~1.500 tokens de overhead. Resultados de queries grandes podem adicionar muitos tokens extras, entao use LIMIT e seja especifico.

O overhead fixo e moderado, mas queries sem LIMIT podem explodir o contexto. Um SELECT * sem LIMIT em tabela grande pode consumir toda a janela de contexto.

Overhead fixo: ~1.500 tokens. Cuidado com: queries sem LIMIT, tabelas grandes, JOINs multiplos. Sempre use LIMIT e selecione colunas especificas.

NUNCA conecte ao banco de producao com usuario admin. Crie um usuario read-only para exploracao. Use staging/dev para mutations. Producao = somente leitura, SEMPRE.

Um DELETE sem WHERE executado pelo Claude em producao pode destruir dados de clientes. Seguranca com banco via MCP e inegociavel.

Producao: usuario read-only. Staging: usuario com write. Dev: pode ser admin. Nunca exponha credenciais em arquivos commitados. Use variaveis de ambiente.

O Google Sheets MCP permite ao Claude ler e escrever em planilhas Google. Ele pode consultar ranges, atualizar celulas, criar novas abas e processar dados tabulares.

Muitas equipes usam Google Sheets como fonte de verdade para dados nao-tecnicas: listas de leads, planos de projeto, inventario. Conectar ao Claude automatiza a interacao.

Tools: read_spreadsheet, write_spreadsheet, get_sheets, create_sheet. Acessa via Google Sheets API com credenciais de service account.

Instale com: claude mcp add google-sheets -- npx -y @anthropic/mcp-google-sheets. Requer configuracao de credenciais Google (service account ou OAuth).

A instalacao do MCP e simples, mas a configuracao de credenciais Google e a parte mais trabalhosa. Prepare-se para criar um projeto no Google Cloud Console.

1. Crie projeto no Google Cloud Console. 2. Habilite Sheets API. 3. Crie service account. 4. Baixe credentials.json. 5. Configure path na env var.

Voce precisa de um service account com acesso as planilhas. Compartilhe a planilha com o email do service account. export GOOGLE_APPLICATION_CREDENTIALS=/path/to/credentials.json.

Sem credenciais corretas, o MCP conecta mas nao acessa nada. O erro mais comum e esquecer de compartilhar a planilha com o service account.

Service account email: xxx@projeto.iam.gserviceaccount.com. Compartilhe planilha com esse email. Permissao: Editor para read/write, Viewer para read-only.

Casos: "leia a aba Leads e filtre empresas de SP", "atualize o status das tarefas concluidas", "crie um resumo semanal a partir dos dados da planilha", "popule a planilha com dados do banco".

Planilhas sao a interface universal de dados. Conectar Claude ao Sheets permite bridge entre dados tecnicos (banco, API) e dados de negocio (planilhas, reports).

Read: extraia e analise dados existentes. Write: popule com resultados de processamento. Bridge: mova dados entre banco e planilha via Claude.

Google Sheets MCP tem overhead baixo-moderado: ~800 tokens. O custo real vem dos dados retornados - planilhas grandes podem injetar milhares de tokens no contexto.

O overhead fixo e aceitavel, mas lembre-se de usar ranges especificos em vez de ler planilhas inteiras. "A1:D50" e muito melhor que "toda a aba".

~800 tokens overhead fixo. Dados retornados variam. Use ranges: Sheet1!A1:D50 em vez de Sheet1. Limite colunas e linhas ao minimo necessario.

Sempre especifique ranges ao consultar planilhas. Em vez de "leia toda a planilha", peca "leia Leads!A1:E100". Isso controla quantos tokens os dados consomem.

Uma planilha com 10.000 linhas pode consumir toda a janela de contexto. Ranges especificos mantem o uso previsivel e controlavel.

Sintaxe: NomeAba!ColunaLinha:ColunaLinha. Exemplo: Leads!A1:E100. Peca primeiro as colunas/headers para entender a estrutura, depois consulte dados especificos.

O comando claude mcp list mostra todos os MCPs configurados, seu status (conectado/desconectado) e as tools que cada um expoe. E o /status especifico para MCPs.

Antes de adicionar um novo MCP, verifique o que ja esta ativo. Antes de debugar, confirme que o MCP esta conectado. E o primeiro passo de qualquer operacao com MCPs.

Rode regularmente para manter consciencia do que esta consumindo tokens. MCPs desconectados aparecem como "disconnected" e nao consomem tokens.

claude mcp remove nome-do-mcp desconecta e remove um MCP da configuracao. O MCP para de consumir tokens imediatamente. Voce pode re-adicionar a qualquer momento.

Remover MCPs que nao esta usando e a acao mais direta para economizar tokens. E o "desligar a luz quando sair da sala" do mundo MCP.

Sintaxe: claude mcp remove browser. Efeito imediato: para de enviar schemas. Pode re-adicionar: claude mcp add browser -- [comando]. Sem perda de dados.

claude mcp add nome -- comando-do-server adiciona um novo MCP. O nome e seu identificador, e o comando apos -- e o que inicia o server MCP.

Saber a sintaxe exata de add evita erros de configuracao. O -- (double dash) separa o nome do MCP do comando do server - esquecer isso e o erro mais comum.

Formato: claude mcp add [nome] -- [comando]. Exemplo: claude mcp add filesystem -- npx -y @anthropic/mcp-filesystem ~/projetos. O nome pode ser qualquer string valida.

Essenciais (always on): Filesystem. Opcionais (sob demanda): GitHub, Browser, Database, Sheets. Classificar MCPs por necessidade guia decisoes de rotacao.

Sem classificacao, operadores tratam todos os MCPs como essenciais e acumulam overhead. Com classificacao, voce mantem o minimo e ativa sob demanda.

Essencial: beneficio constante, custo baixo (Filesystem). Opcional: beneficio pontual, custo variavel (Browser, GitHub). Nunca trate opcional como essencial.

Instale agora: Filesystem (essencial, sempre ligado) e GitHub (se trabalha com repos). Esses dois cobrem 80% dos casos de uso e tem custo aceitavel combinado (~2.500 tokens).

Ter os MCPs essenciais configurados antes de precisar evita interrupcoes no fluxo de trabalho. Configure uma vez, use sempre.

Filesystem: claude mcp add filesystem -- npx -y @anthropic/mcp-filesystem ~/projetos. GitHub: claude mcp add github -- npx -y @anthropic/mcp-github (requer GITHUB_TOKEN).

Instale quando precisar: Browser (so para UI/scraping), Database (so quando trabalhando com dados), Google Sheets (so quando interagindo com planilhas). Tenha os comandos salvos.

Ter os comandos de instalacao prontos num arquivo de referencia permite adicionar MCPs em segundos quando necessario. Prepare-se para velocidade.

Salve os comandos no CLAUDE.md ou num cheatsheet. Quando precisar: cole, execute, use, remova. Ciclo completo em menos de 30 segundos.

Quando construindo features: mantenha Filesystem (sempre) + GitHub (para issues). Desconecte Browser e Database. Foco maximo no codigo com minimo overhead.

Building e a fase onde voce mais precisa de contexto para codigo. Cada token economizado em MCPs desnecessarios vai direto para melhor qualidade de implementacao.

MCPs ativos: Filesystem + GitHub. Overhead: ~2.500 tokens. Contexto livre: ~197.500 tokens para codigo. Workflow: leia issue -> implemente -> crie PR.

Quando trabalhando em UI: mantenha Filesystem (sempre) + Browser (para verificar visualmente). Desconecte GitHub e Database. O Claude precisa ver o resultado.

UI sem verificacao visual e coding as cegas. O Browser MCP permite que o Claude veja o que voce ve, identifique problemas visuais e sugira ajustes.

MCPs ativos: Filesystem + Browser. Overhead: ~5.500 tokens (alto, mas necessario). Workflow: code -> screenshot -> adjust -> screenshot -> approve.

Quando trabalhando com backend/dados: mantenha Filesystem (sempre) + Database (para queries e schema). Desconecte Browser e GitHub. Foco em logica e dados.

Backend com acesso ao banco real permite que o Claude escreva queries validadas, crie migrations baseadas no schema atual e debugue problemas de dados diretamente.

MCPs ativos: Filesystem + Database. Overhead: ~2.000 tokens. Workflow: explore schema -> escreva query -> valide resultado -> implemente no codigo.

Para lead scraping: Browser (navegar e extrair) + Google Sheets (salvar resultados). Desconecte GitHub e Database. Workflow otimizado para coleta de dados da web.

Lead scraping e um dos workflows mais valiosos com MCPs. Browser coleta, Sheets armazena. O Claude faz em minutos o que levaria horas manualmente.

MCPs ativos: Browser + Sheets (+ Filesystem). Overhead: ~6.300 tokens (alto). Workflow: navegar diretorio -> extrair dados -> salvar na planilha. Batch processing.

Para code review: Filesystem (ler codigo) + GitHub (ler PRs e comments). O Claude le o diff, entende o contexto do PR e gera review comments estruturados.

Code review com contexto completo (codigo local + PR remoto) resulta em reviews mais precisos e uteis. O Claude ve o que mudou E o que ja existia.

MCPs ativos: Filesystem + GitHub. Overhead: ~2.500 tokens. Workflow: leia PR -> leia arquivos afetados -> gere review -> poste comments. Skill de review complementa.

Nao pense "quais MCPs eu tenho". Pense "qual fase do trabalho estou e quais MCPs essa fase precisa". A fase dita a configuracao, nao o contrario.

A mentalidade de operador transforma MCP management de chato em automatico. Voce nao "gerencia MCPs", voce "entra em modo UI" ou "entra em modo backend".

Modos: Building (FS+GH), UI (FS+Browser), Backend (FS+DB), Scraping (Browser+Sheets), Review (FS+GH). Troque de modo, nao de MCPs individuais.

MCP aparece como "disconnected" no /status. Causa mais comum: o comando do server esta errado ou o pacote nao esta instalado. Verifique com npx -y [pacote] --help.

Conexao falhada e o problema #1 com MCPs. Saber diagnosticar rapidamente evita perder tempo achando que o MCP nao funciona quando e so configuracao.

1. claude mcp list (confirme status). 2. claude mcp remove nome. 3. Re-adicione com comando correto. 4. Verifique dependencias (Node.js, npx). 5. Rode /status.

O MCP conecta mas retorna "permission denied" ao tentar usar tools. Causa: token/credencial sem as permissoes necessarias ou caminho nao autorizado (Filesystem).

Permission denied e frustrante porque parece que tudo esta configurado. O problema geralmente esta no escopo do token ou nas permissoes do arquivo de credenciais.

GitHub: verifique escopos do PAT. Filesystem: verifique caminhos permitidos. Database: verifique permissoes do usuario SQL. Sheets: verifique compartilhamento com service account.

/cost mostra consumo muito acima do esperado. Causas: muitos MCPs conectados, queries que retornam dados grandes, screenshots frequentes do Browser MCP.

Token usage alto degrada qualidade e custa dinheiro. Identificar a causa rapidamente permite corrigir antes que afete toda a sessao.

Fix: 1. claude mcp list (veja quantos MCPs). 2. Remova os nao essenciais. 3. Use queries com LIMIT. 4. Evite screenshots desnecessarios. 5. /compact se necessario.

Respostas demoram muito mais que o normal. Causas: MCP server lento (Browser com paginas pesadas), contexto muito cheio, ou servidor MCP com timeout.

Lentidao pode ser do MCP, do contexto ou da rede. Diagnosticar a causa correta evita "fixes" que nao resolvem nada.

Diagnostico: 1. /cost (contexto cheio?). 2. Teste sem MCPs (mais rapido?). 3. Teste MCP individual (qual e lento?). 4. /compact se contexto > 70%. 5. Reinicie o MCP lento.

Erro ao adicionar MCP: "server not found" ou "command not found". Causa: pacote npm nao existe, nome errado, ou npx nao esta no PATH.

Nomes de pacotes MCP mudam conforme o ecossistema evolui. Saber verificar o pacote correto e essencial para evitar frustracoes.

Fix: 1. Verifique nome do pacote no npm (npm info @anthropic/mcp-xxx). 2. Confirme Node.js instalado (node --version). 3. Confirme npx disponivel. 4. Tente npx -y [pacote] --help isolado.

Checklist universal: 1. /status (MCP conectado?). 2. claude mcp list (config correta?). 3. Remove + re-add (reseta conexao). 4. /doctor (diagnostico geral). 5. Reinicie a sessao.

Ter um checklist padronizado de troubleshooting elimina tentativa e erro. Siga os passos em ordem e resolva 95% dos problemas com MCPs.

Regra #1: Sempre comece pelo /status. Regra #2: Remove + re-add resolve 80% dos problemas. Regra #3: Se nada funcionar, reinicie a sessao do Claude Code completamente.