Como Adicionar Pesquisa na Web ao GitHub Copilot CLI: Guia de Integração MCP Sem Scraps

Principais Conclusões:

• Um arquivo de configuração conecta o acesso à web ao vivo ao Copilot CLI. Adicione um único bloco scrapeless em ~/.copilot/mcp-config.json e seu agente do terminal ganha um scraper de SERP do Google, um scraper de Tendências, auxiliares de página em HTML/Markdown/Captura de Tela e uma superfície completa de automação de navegador em nuvem — sem código SDK, sem serviço extra para executar.
• O agente pesquisa, renderiza e controla um navegador a partir de prompts simples. Pergunte-lhe em linguagem natural para pesquisar no Google, renderizar uma página com muito JavaScript ou clicar em um fluxo de várias etapas, e ele compõe as chamadas de ferramenta certas passo a passo, em vez de ficar limitado a arquivos locais e conhecimento até a data de corte de treinamento.
• Proxies residenciais e anti-detecção são gerenciados na nuvem. Cada solicitação passa pelo navegador anti-detecção Scrapeless em nuvem com proxies residenciais em mais de 195 países, de modo que o agente obtém uma resposta renderizada e utilizável em sites comerciais sem necessidade de configuração de proxy ou impressão digital em sua máquina.
• Ele funciona ao lado das ferramentas de codificação do Copilot na mesma sessão. As ferramentas Scrapeless ficam ao lado das edições de arquivos, comandos de terminal e geração de código do Copilot CLI, de modo que uma única interação do agente pode fazer scraping da web ao vivo e escrever o resultado diretamente no código que você está construindo.
• 21 ferramentas para SERP, scraping sem estado e automação de navegador. O servidor MCP Scrapeless expõe google_search, google_trends, scrape_html/scrape_markdown/scrape_screenshot, além de 16 ferramentas de automação browser_* — um namespace do qual o planejador do agente extrai a cada interação.
• Transporte via HTTP streaming cobre configurações hospedadas. Stdio via npx é o padrão em uma estação de trabalho; para containers de desenvolvimento remotos ou runners de CI onde criar um processo filho é complicado, aponte a mesma configuração para o endpoint HTTP que suporta streaming.
• Gratuito para começar. Novas contas Scrapeless incluem a execução do Scraping Browser gratuita — inscreva-se em Scrapeless.

Introdução: seu agente de terminal, agora com acesso à web ao vivo

O GitHub Copilot CLI foi lançado oficialmente em 25-FEV-2026 como um agente de codificação nativo do terminal, com padrão para Claude Sonnet 4.5. Ele lê seu repositório, edita arquivos, executa comandos e raciocina sobre o projeto à sua frente — tudo sem sair do shell. O que ele não consegue fazer de imediato é acessar a web ao vivo. Seu conhecimento termina na data de corte do treinamento e nos arquivos no disco.

Essa lacuna aparece no momento em que uma tarefa precisa de dados atuais e públicos. O agente não pode extrair uma SERP ao vivo, ler a página de preços de um concorrente, verificar o changelog mais recente ou renderizar um aplicativo exclusivo em JavaScript — então as respostas vão se tornando obsoletas, qualquer coisa sensível ao tempo se transforma em cópia manual de um navegador, e o agente fica "cego" para tudo o que foi publicado após sua data de corte.

Este post fecha essa lacuna conectando o servidor MCP Scrapeless ao GitHub Copilot CLI. Um bloco de configuração fornece ao agente busca no Google, renderização de JavaScript e um navegador completo em nuvem, tudo acessível através dos mesmos prompts em linguagem natural que ele já utiliza para o código. Para acessar a mesma superfície Scrapeless através de outros clientes MCP, veja o tutorial do Google Antigravity e o tutorial do servidor MCP.

O Que Você Pode Fazer Com Isso

• Pesquisa de SERP ao vivo no terminal. Peça ao agente para executar google_search para uma consulta e devolvê-lo os principais resultados em JSON, fazendo com que a pesquisa ocorra no shell em vez de em uma aba separada do navegador.
• Capturas de concorrentes e preços. Insira uma URL de concorrente no prompt e faça com que o agente renderize a página de preços e extraia nomes dos planos, preços e recursos em um registro estruturado que você pode colocar ao lado do seu código.
• Consultas de documentação e changelog que alimentam o código. Faça o agente buscar a documentação atual de uma biblioteca ou notas de lançamento como markdown limpo e escreva com base no texto renderizado, em vez de uma memória obsoleta da API.
• Verificações de mercado e tendências. Use google_trends para puxar sinais de interesse por um tópico em uma região-alvo e, em seguida, alimente cópias de recursos, templates de conteúdo ou ideias de experimentos com evidências atuais.
• Extração de página JS em um registro tipado. Aponte o agente para uma página renderizada em JavaScript; o navegador em nuvem a hidrata e o agente analisa o resultado em um objeto tipado para o script que você está escrevendo.
• Fluxos múltiplos no navegador. Encadeie browser_goto, browser_click, browser_type e browser_scroll para que o agente navegue por paginações, expanda painéis ou siga um assistente antes de extrair.
• Captura de tela para revisão. Use scrape_screenshot ou browser_screenshot para pegar uma página renderizada como uma imagem que o agente pode anexar à conversa ou salvar no espaço de trabalho.
• Pipelines de pesquisa e leitura. Combine google_search com scrape_markdown para que o agente encontre os principais resultados, leia cada um e resuma-os em uma única interação no terminal.
  Na Scrapeless, acessamos apenas dados disponíveis publicamente enquanto cumprimos rigorosamente as leis, regulamentos e políticas de privacidade dos sites aplicáveis. O conteúdo neste post é apenas para fins de demonstração.

Por que o servidor MCP da Scrapeless

O servidor MCP da Scrapeless é uma ponte personalizável e anti-detecção entre um agente de IA e a web ao vivo. Especificamente para o GitHub Copilot CLI, ele traz:

• Um navegador em nuvem anti-detecção com renderização de JavaScript. As páginas são hidratadas em um Navegador de Scraping Scrapeless completo antes da extração, então SPAs, feeds de rolagem infinita e painéis carregados sob demanda tornam-se alvos de primeira classe para browser_goto + browser_get_html.
• Proxies residenciais em mais de 195 países. Consultas geográficas retornam as listagens que um usuário local veria, com a saída do proxy totalmente gerenciada do lado da Scrapeless.
• Um comando stdio via npx, sem código SDK. O servidor é lançado como um processo filho de npx -y scrapeless-mcp-server; não há nada para construir, hospedar ou importar para seu projeto.
• 21 ferramentas abrangendo SERP, scraping sem estado e automação de navegador completo. google_search e google_trends cobrem dados de SERP, scrape_html/scrape_markdown/scrape_screenshot cobrem recuperações de página de uma só vez, e 16 ferramentas browser_* cobrem navegação com estado, cliques, digitação, rolagem e capturas de tela.
• Transporte HTTP transmitível para agentes hospedados. Quando o Copilot CLI é executado em um contêiner remoto ou runner de CI, a mesma superfície é acessível através do endpoint HTTP transmitível em vez de stdio.

O plano gratuito é suficiente para conectar isso e executar prompts reais; compare as quotas na página de preços quando você ultrapassar. Obtenha sua chave de API no plano gratuito em app.scrapeless.com.

Pré-requisitos

• Node.js 18 ou superior na estação de trabalho — o Copilot CLI é instalado a partir do npm, e o servidor MCP de stdio é iniciado com npx.
• GitHub Copilot CLI instalado e uma assinatura ativa do GitHub Copilot. O CLI autentica-se em sua conta do GitHub, e o loop do agente se utiliza da cota do Copilot; sem uma assinatura ativa, a etapa do modelo não será executada.
• Uma conta Scrapeless e chave de API — inscreva-se no plano gratuito em Scrapeless e copie a chave de Configurações → Gerenciamento de Chave de API.
• Familiaridade básica com o terminal — toda a configuração consiste em alguns comandos mais um pequeno arquivo JSON.

Instalação

A configuração é composta por cinco sub-etapas; cada uma é verificável de forma independente.

1. Instalar o GitHub Copilot CLI

Instale o CLI globalmente a partir do npm e, em seguida, inicie-o:

npm install -g @github/copilot
copilot

O primeiro lançamento leva você a uma sessão interativa do Copilot onde as etapas restantes são executadas.

2. Autenticar o Copilot

Dentro da sessão, faça login com o comando de barra /login e siga o fluxo de autorização de dispositivo do GitHub:

/login

Isso requer uma assinatura ativa do GitHub Copilot — o CLI usa sua identidade do GitHub para autenticação e cota do modelo. O Copilot CLI padrão para Claude Sonnet 4.5; altere backends a qualquer momento com o comando de barra /model.

3. Adicionar o servidor MCP da Scrapeless (stdio)

O Copilot CLI lê servidores MCP de ~/.copilot/mcp-config.json. Crie o arquivo (ou adicione o bloco scrapeless a um objeto mcpServers existente) com a configuração de stdio:

{
  "mcpServers": {
    "scrapeless": {
      "type": "local",
      "command": "npx",
      "args": ["-y", "scrapeless-mcp-server"],
      "env": { "SCRAPELESS_KEY": "SUA_CHAVE_SCRAPELESS" },
      "tools": ["*"]
    }
  }
}

Um detalhe que confunde as pessoas: o servidor MCP da Scrapeless lê sua chave de SCRAPELESS_KEY, e não SCRAPELESS_API_KEY. O CLI e SDK da Scrapeless usam SCRAPELESS_API_KEY, mas o servidor MCP é a exceção documentada — use SCRAPELESS_KEY aqui ou o servidor iniciará sem credenciais. O código-fonte do servidor está em github.com/scrapeless-ai/scrapeless-mcp-server.

Substitua sua chave real por SUA_CHAVE_SCRAPELESS. A linha "tools": ["*"] expõe toda a superfície da ferramenta. Você também pode gerenciar servidores de dentro de uma sessão com os comandos de barra /mcp — /mcp add, /mcp show, /mcp edit, /mcp delete, /mcp enable e /mcp disable — que gravam no mesmo arquivo de configuração.

4. Ou use o modo HTTP transmitível

Se o host não puder iniciar npx de forma confiável — um contêiner de desenvolvimento hospedado, um espaço de trabalho remoto ou uma sandbox de CI — aponte o Copilot para o endpoint HTTP da Scrapeless em vez do processo local:

{
  "mcpServers": {
    "scrapeless": {
      "type": "http",
      "url": "https://api.scrapeless.com/mcp",
      "headers": { "x-api-token": "SUA_CHAVE_SCRAPELESS" },
      "tools": ["*"]
    }
  }
}

O mesmo valor de chave funciona em ambos os modos; observe que o fluxo HTTP o passa como o cabeçalho x-api-token em vez da variável de ambiente SCRAPELESS_KEY. O Stdio é o padrão certo em uma estação de trabalho de desenvolvedor; o HTTP streamable é o padrão certo em qualquer lugar onde um processo filho de longa duração seja complicado de manter ativo.

5. Verifique a conexão

Inicie o CLI e liste os servidores MCP conectados:

copilot
/mcp

O servidor scrapeless deve aparecer com suas 21 ferramentas carregadas — as ferramentas de dados do Google (google_search, google_trends), os assistentes de página de uma só vez (scrape_html, scrape_markdown, scrape_screenshot), e os primitivos do navegador na nuvem (browser_create, browser_goto, browser_get_html, browser_get_text, browser_click, browser_type, browser_press_key, browser_scroll, browser_scroll_to, browser_screenshot, browser_snapshot, browser_wait, browser_wait_for, browser_go_back, browser_go_forward, browser_close). Se o servidor estiver listado e as ferramentas forem enumeradas, a conexão está boa e a chave da API é válida.

Como você realmente usa isso: solicite ao seu agente Copilot CLI

Após conectar o servidor MCP, você obtém dados da web ao conversar com o Copilot CLI no terminal — não escrevendo manualmente chamadas de ferramentas. O agente lê a lista de ferramentas que o servidor MCP Scrapeless expõe e escolhe google_search, scrape_markdown ou as ferramentas browser_* conforme necessário, compondo-as uma a uma a partir do prompt em linguagem natural. Não há JSON de ferramenta para criar do seu lado e nenhuma chamada manual de MCP a emitir. (O Copilot CLI executa prompts interativamente em uma sessão ou não interativamente com copilot -p "<prompt>" para execuções únicas e scripts.)

Prompts que você pode colar

Exemplo prático

Você digita:

copilot -p "Encontre os principais resultados orgânicos para 'web scraping python' e resuma os 3 principais com links."

O plano do agente (em linguagem simples):

1. Chamar google_search com q: "web scraping python", hl: "en", gl: "us".
2. Receber um array de linhas de resultado e ler os campos position, title, link e snippet.
3. Classificar por position e manter as três primeiras linhas.
4. Resumir cada resultado a partir do seu snippet e emparelhar o resumo com o title e link da linha.
5. Retornar os três resumos com seus links para o terminal.

O que você recebe de volta (forma ilustrativa — o agente trabalha com linhas como estas):

[
  {
    "position": 1,
    "title": "Tutorial de Web Scraping em Python",
    "link": "https://www.example.com/python-web-scraping",
    "snippet": "Um guia passo a passo para raspar páginas da web com Python, requests e um parser.",
    "source": "example.com"
  },
  {
    "position": 2,
    "title": "Documentação do Beautiful Soup",
    "link": "https://www.example.org/beautifulsoup/docs",
    "snippet": "Referência para análise de documentos HTML e XML em Python.",
    "source": "example.org"
  },
  {
    "position": 3,
    "title": "Raspando Sites Dinâmicos em Python",
    "link": "https://blog.example.net/dynamic-scraping",
    "snippet": "Como renderizar páginas JavaScript antes de extrair dados.",
    "source": "example.net"
  }
]
// Os nomes dos campos correspondem à forma das linhas de google_search; os valores são exemplos ilustrativos.

As ferramentas de dados sem estado (google_search, google_trends, scrape_html, scrape_markdown) retornam sua carga como um corpo prefixado com Response:\n\n; o agente remove esse prefixo antes de analisar o JSON, então você nunca o vê na resposta.

Moldando prompts

A superfície da ferramenta Scrapeless MCP

Uma vez que o servidor esteja conectado, o GitHub Copilot CLI vê 21 ferramentas abrangendo dados SERP, scraping sem estado e controle total do navegador em nuvem anti-detectação.

Obtenha sua chave de API no plano gratuito: Scrapeless

O que você recebe de volta

Uma chamada google_search retorna um array JSON de linhas de resultados orgânicos. Cada linha carrega as mesmas chaves, permitindo que o agente mapeie diretamente para título, link e trecho:

// Os nomes dos campos refletem a saída da ferramenta google_search; os valores são amostras ilustrativas.
[
  {
    "position": 1,
    "title": "Tutorial de Web Scraping com Python",
    "link": "https://example.com/python-web-scraping",
    "snippet": "Um guia passo a passo para raspar a web com Python e analisar HTML.",
    "source": "example.com"
  },
  {
    "position": 2,
    "title": "Melhores Práticas de Web Scraping",
    "link": "https://example.org/best-practices",
    "snippet": "Como raspar de forma responsável: limites de taxa, robots.txt e saída estruturada.",
    "source": "example.org"
  }
]

Algumas observações honestas uma vez que você começa a executar prompts:

• Ferramentas sem estado como google_search e scrape_markdown retornam um corpo prefixado com Response:\n\n seguido pela carga JSON; o agente remove automaticamente esse prefixo, para que você trabalhe com os dados, não com o wrapper.
• As ferramentas browser_* retornam texto simples sem o prefixo Response:\n\n.
• Os argumentos da ferramenta estão em camelCase: passe sessionId, proxyCountry e campos semelhantes exatamente como nomeados.
• proxyCountry é um pedido, não uma garantia — pode se referir à região configurada em sua conta.
• Os valores na saída da ferramenta são dependentes do conteúdo: contagens de resultados, ordenação e texto do trecho variam com a consulta ao vivo.

Conclusão: pesquise, renderize e navegue pelo terminal

Toda a integração se resume a um bloco de configuração MCP mais prompts em linguagem natural. Com a entrada scrapeless-mcp-server no lugar e sua chave no ambiente, o GitHub Copilot CLI ganha busca ao vivo no Google, renderização em JavaScript e um navegador em nuvem anti-detectação completo — tudo isso sem sair do terminal ou configurar um único cliente HTTP manualmente. Você descreve a tarefa; o agente escolhe a ferramenta.

Se você está conectando outros agentes, o mesmo servidor Scrapeless MCP também pode ser integrado a eles: veja as integrações Google Antigravity e Pi Agent, e a visão geral do servidor Scrapeless MCP para a referência completa da ferramenta. Mantenha sua chave de API em SCRAPELESS_KEY, prefira transporte stdio para CLIs locais e HTTP-streamable para agentes hospedados, e deixe o agente escolher as ferramentas. Referência completa em docs.scrapeless.com.

FAQ

É legal fazer web scraping via o agente?

Raspar dados disponíveis publicamente é geralmente permitido, mas você é responsável por como os utiliza. Revise os Termos de Serviço de cada site e respeite o robots.txt, e lembre-se de que as regras sobre dados pessoais e acesso variam conforme a jurisdição. Quando estiver em dúvida, procure aconselhamento jurídico para seu caso de uso específico.

Você precisa de uma chave de API Scrapeless e qual variável de ambiente a contém?

Sim. O servidor Scrapeless MCP se autentica com a chave da sua conta, que você define em SCRAPELESS_KEY. Sem ela, o servidor inicia, mas suas ferramentas não conseguem acessar o backend do Scrapeless.

Você precisa de uma assinatura do GitHub Copilot?

Sim. O GitHub Copilot CLI executa suas ações contra o modelo do Copilot, que requer uma assinatura ativa do Copilot com cota disponível. O servidor MCP e suas ferramentas são separados; a assinatura cobre o modelo do agente, não as chamadas Scrapeless.

stdio vs HTTP streaming — quando você deve usar cada um?

Use stdio quando o servidor roda localmente junto ao CLI: o agente inicia o scrapeless-mcp-server como um processo filho e se comunica com ele por meio da entrada/saída padrão. Use o transporte HTTP streaming (https://api.scrapeless.com/mcp com o cabeçalho x-api-token) quando o agente estiver hospedado ou remoto e não puder criar um processo local. Para uma configuração local do Copilot CLI, stdio é a escolha mais simples.

O agente pode executar um fluxo de navegador completo, não apenas pesquisa?

Sim. As 16 ferramentas browser_* permitem que o agente abra uma sessão, navegue, clique, digite, role, aguarde elementos, tire uma foto, faça capturas de tela e feche — um fluxo completo de navegador na nuvem impulsionado inteiramente por comandos em linguagem natural.

O proxyCountry sempre se aplica?

Não necessariamente. O proxyCountry é uma preferência que pode ser subordinada à região configurada na sua conta. Se o geo-alvo for importante, confirme a região de saída em vez de assumir que o valor por chamada sempre prevalece.

Você pode usar isso sem um agente de IA?

Sim. O servidor Scrapeless MCP é um servidor MCP padrão, então qualquer cliente compatível com MCP pode chamá-lo — ou você pode controlá-lo diretamente via JSON-RPC (initialize, depois tools/list e tools/call). O agente é uma conveniência, não uma exigência.

Pronto para construir seu pipeline de dados impulsionado por IA?

Junte-se à nossa comunidade para reivindicar um plano gratuito e conectar-se com desenvolvedores que estão construindo agentes GitHub Copilot CLI + Scrapeless MCP: Discord · Telegram.

Inscreva-se em Scrapeless para obter o tempo de execução gratuito do Scraping Browser e adapte a integração acima aos SERPs, páginas e regiões que sua equipe precisa. Referência completa em docs.scrapeless.com.