Como Construir Análises de Busca Inteligentes com Scrapeless e Google Gemini

# Criar ambiente virtual
python -m venv scrapeless-gemini-env

# Ativar o ambiente
scrapeless-gemini-env\Scripts\activate

# Criar ambiente virtual
python3 -m venv scrapeless-gemini-env

# Ativar o ambiente
source scrapeless-gemini-env/bin/activate

# Criar ambiente virtual
python3 -m venv scrapeless-gemini-env

# Ativar o ambiente
source scrapeless-gemini-env/bin/activate

pip install requests google-generativeai python-dotenv pandas

SCRAPELESS_API_TOKEN=seu_token_aqui
GEMINI_API_KEY=sua_chave_gemini_aqui

import json
import requests
import os
from dotenv import load_dotenv

load_dotenv()

class ScrapelessClient:
    def __init__(self):
        self.token = os.getenv('SCRAPELESS_API_TOKEN')
        self.host = "api.scrapeless.com"
        self.url = f"https://{self.host}/api/v1/scraper/request"
        self.headers = {"x-api-token": self.token}
    
    def search_google(self, query, **kwargs):
        """Realizar uma busca no Google usando o Scrapeless"""
        payload = {
            "actor": "scraper.google.search",
            "input": {
                "q": query,
                "gl": kwargs.get("gl", "us"),
                "hl": kwargs.get("hl", "en"),
                "google_domain": kwargs.get("google_domain", "google.com"),
                "location": kwargs.get("location", ""),
                "tbs": kwargs.get("tbs", ""),
                "start": str(kwargs.get("start", 0)),
                "num": str(kwargs.get("num", 10))
            }
        }
        
        response = requests.post(
            self.url, 
            headers=self.headers, 
            data=json.dumps(payload)
        )
        
        if response.status_code != 200:
            print(f"Erro: {response.status_code} - {response.text}")
            return None
            
        return response.json()

import google.generativeai as genai

class SearchAnalyzer:
    def __init__(self):
        genai.configure(api_key=os.getenv('GEMINI_API_KEY'))
        self.model = genai.GenerativeModel('gemini-1.5-flash')
        self.scraper = ScrapelessClient()
    
    def analyze_topic(self, topic):
        """Buscar e analisar um tópico"""
        # Passo 1: Obter resultados de busca
        print(f"Buscando por: {topic}")
        search_results = self.scraper.search_google(topic, num=20)
        
        if not search_results:
            return None
        
        # Passo 2: Extrair informações chave
        extracted_data = self._extract_results(search_results)
        
        # Passo 3: Analisar com o Gemini
        prompt = f"""
        Analise esses resultados de busca sobre "{topic}":
        
        {json.dumps(extracted_data, indent=2)}
        
        Forneça:
        1. Temas e tendências principais
        2. Fontes principais de informação
        3. Insights notáveis
        4. Ações recomendadas
        
        Formate sua resposta como um relatório claro e acionável.
        """
        
        response = self.model.generate_content(prompt)
        
        return {
            "topic": topic,
            "search_data": extracted_data,
            "analysis": response.text
        }
```python
def _extrair_resultados(self, dados_busca):
        """Extrair dados relevantes dos resultados da busca"""
        resultados = []
        
        if "resultados_organicos" em dados_busca:
            for item em dados_busca["resultados_organicos"][:10]:
                resultados.append({
                    "titulo": item.get("titulo", ""),
                    "resumo": item.get("resumo", ""),
                    "link": item.get("link", ""),
                    "fonte": item.get("link_exibido", "")
                })
        
        return resultados

class MonitorConcorrente:
    def __init__(self):
        self.analisador = AnalisadorDeBusca()
    
    def analisar_concorrentes(self, nome_empresa, concorrentes):
        """Analisar uma empresa em relação aos seus concorrentes"""
        todos_dados = {}
        
        # Pesquisar por cada empresa
        for conc in [nome_empresa] + concorrentes:
            print(f"\nAnalisando: {conc}")
            
            # Pesquisar por notícias e atualizações recentes
            consulta_noticias = f"{conc} últimas notícias atualizações 2025"
            dados = self.analisador.analisar_tema(consulta_noticias)
            
            if dados:
                todos_dados[conc] = dados
        
        # Gerar análise comparativa
        prompt_comparativo = f"""
        Compare {nome_empresa} com os concorrentes com base nesses dados:
        
        {json.dumps(todos_dados, indent=2)}
        
        Forneça:
        1. Posicionamento competitivo
        2. Forças únicas de cada empresa
        3. Oportunidades de mercado
        4. Recomendações estratégicas para {nome_empresa}
        """
        
        resposta = self.analisador.modelo.gerar_conteudo(prompt_comparativo)
        
        return {
            "empresa": nome_empresa,
            "concorrentes": concorrentes,
            "analise": resposta.text,
            "dados_crus": todos_dados
        }

class MonitorTendencia:
    def __init__(self):
        self.analisador = AnalisadorDeBusca()
        self.scraper = ClienteScrapeless()
    
    def monitorar_tendencia(self, palavra_chave, intervalo_tempo="d"):
        """Monitorar tendências para uma palavra-chave"""
        # Mapear intervalos de tempo para o parâmetro tbs do Google
        mapa_tempo = {
            "h": "qdr:h",  # Última hora
            "d": "qdr:d",  # Último dia
            "w": "qdr:w",  # Última semana
            "m": "qdr:m"   # Último mês
        }
        
        # Pesquisar com filtro de tempo
        resultados = self.scraper.pesquisar_google(
            palavra_chave, 
            tbs=mapa_tempo.get(intervalo_tempo, "qdr:d"),
            num=30
        )
        
        if not resultados:
            return None
        
        # Analisar tendências
        prompt = f"""
        Analise as tendências para "{palavra_chave}" com base nos resultados de busca recentes:
        
        {json.dumps(resultados.get("resultados_organicos", [])[:15], indent=2)}
        
        Identifique:
        1. Padrões emergentes
        2. Principais desenvolvimentos
        3. Sentimento (positivo/negativo/neutro)
        4. Previsões futuras
        5. Insights acionáveis
        """
        
        resposta = self.analisador.modelo.gerar_conteudo(prompt)
        
        return {
            "palavra_chave": palavra_chave,
            "intervalo_tempo": intervalo_tempo,
            "analise": resposta.text,
            "contagem_resultados": len(resultados.get("resultados_organicos", []))
        }

def main():
    # Inicializar componentes
    monitor_concorrente = MonitorConcorrente()
    monitor_tendencias = MonitorTendencia()
    
    # Exemplo 1: Análise de Concorrentes
    # IMPORTANTE: Substitua essas empresas de exemplo pelo nome da sua empresa e concorrentes
    print("=== ANÁLISE DE CONCORRENTES ===")
    analise = monitor_concorrente.analisar_concorrentes(
        nome_empresa="OpenAI",  # Substitua pelo nome da sua empresa
        concorrentes=["Anthropic", "Google AI", "Meta AI"]  # Substitua pelos seus concorrentes
    )
    
    print("\nResultados da Análise Competitiva:")
    print(analise["analise"])
    
    # Salvar resultados
    with open("analise_concorrente.json", "w") as f:
        json.dump(analise, f, indent=2)
    
    # Exemplo 2: Monitoramento de Tendências
    # IMPORTANTE: Substitua a palavra-chave por termos específicos da sua indústria
    print("\n\n=== MONITORAMENTO DE TENDÊNCIAS ===")
    tendencias = monitor_tendencias.monitorar_tendencia(
        palavra_chave="regulação da inteligência artificial",  # Substitua pelas suas palavras-chave
        intervalo_tempo="w"  # Última semana
    )
    
    print("\nResultados da Análise de Tendências:")
    print(tendencias["analise"])
    
    # Exemplo 3: Análise Multitópico
    # IMPORTANTE: Substitua esses tópicos por tópicos específicos da sua indústria
    print("\n\n=== ANÁLISE MULTITÓPICA ===")
    topicos = [
        "aplicações comerciais de IA generativa",  # Substitua pelos seus tópicos
        "ameaças à cibersegurança de IA",

    # Etapa 2: Extrair informações-chave
    dados_extraídos = self._extrair_resultados(resultados_de_busca)
    
    # Etapa 3: Analisar com o Gemini
    prompt = f"""
    Analise estes resultados de busca sobre "{tópico}":
    
    {json.dumps(dados_extraídos, indent=2)}
    
    Forneça:
    1. Temas e tendências principais
    2. Principais fontes de informação
    3. Insights notáveis
    4. Ações recomendadas
    
    Formate sua resposta como um relatório claro e acionável.
    """
    
    resposta = self.modelo.gerar_conteúdo(prompt)
    
    return {
        "tópico": tópico,
        "dados_de_busca": dados_extraídos,
        "análise": resposta.texto
    }

def _extrair_resultados(self, dados_de_busca):
    """Extrair dados relevantes dos resultados de busca"""
    resultados = []
    
    if "resultados_orgânicos" in dados_de_busca:
        for item in dados_de_busca["resultados_orgânicos"][:10]:
            resultados.append({
                "título": item.get("título", ""),
                "snippet": item.get("snippet", ""),
                "link": item.get("link", ""),
                "fonte": item.get("link_exibido", "")
            })
    
    return resultados

def analisar_concorrentes(self, nome_da_empresa, concorrentes):
    """Analisar uma empresa em relação a seus concorrentes"""
    todos_os_dados = {}
    
    # Buscar por cada empresa
    for conc in [nome_da_empresa] + concorrentes:
        print(f"\nAnalisando: {conc}")
        
        # Buscar por notícias e atualizações recentes
        consulta_de_noticias = f"{conc} últimas notícias atualizações 2025"
        dados = self.analisador.analisar_tópico(consulta_de_noticias)
        
        if dados:
            todos_os_dados[conc] = dados
        
        # Adicionar um atraso entre as requisições
        time.sleep(2)
    
    # Gerar análise comparativa
    prompt_comparativo = f"""
    Compare {nome_da_empresa} com concorrentes com base nestes dados:
    
    {json.dumps(todos_os_dados, indent=2)}
    
    Forneça:
    1. Posicionamento competitivo
    2. Pontos fortes únicos de cada empresa
    3. Oportunidades de mercado
    4. Recomendações estratégicas para {nome_da_empresa}
    """
    
    resposta = self.analisador.modelo.gerar_conteúdo(prompt_comparativo)
    
    return {
        "empresa": nome_da_empresa,
        "concorrentes": concorrentes,
        "análise": resposta.texto,
        "dados_raw": todos_os_dados
    }

def monitorar_tendência(self, palavra_chave, intervalo_de_tempo="d"):
    """Monitorar tendências para uma palavra-chave"""
    # Mapeia intervalos de tempo para o parâmetro tbs do Google
    mapa_de_tempo = {
        "h": "qdr:h",  # Última hora
        "d": "qdr:d",  # Último dia
        "w": "qdr:w",  # Última semana
        "m": "qdr:m"   # Último mês
    }
    
    # Buscar com filtro de tempo
    resultados = self.scraper.buscar_google(
        palavra_chave, 
        tbs=mapa_de_tempo.get(intervalo_de_tempo, "qdr:d"),
        num=30
    )
    
    if not resultados:
        return None
    
    # Analisar tendências
    prompt = f"""
    Analise as tendências para "{palavra_chave}" com base nos resultados de busca recentes:
    
    {json.dumps(resultados.get("resultados_orgânicos", [])[:15], indent=2)}
    
    Identifique:
    1. Padrões emergentes
    2. Principais desenvolvimentos
    3. Sentimento (positivo/negativo/neutro)
    4. Previsões futuras
    5. Insights acionáveis
    """
    
    resposta = self.analisador.modelo.gerar_conteúdo(prompt)
    
    return {
        "palavra_chave": palavra_chave,
        "intervalo_de_tempo": intervalo_de_tempo,
        "análise": resposta.texto,
        "contagem_de_resultados": len(resultados.get("resultados_orgânicos", []))
    }

    # Achatar a estrutura de dados
    linhas = []
    for item in dados:
        if isinstance(item, dict) and "dados_de_busca" in item:
            for resultado in item["dados_de_busca"]:
                linhas.append({
                    "tópico": item.get("tópico", ""),
                    "título": resultado.get("título", ""),
                    "snippet": resultado.get("snippet", ""),
                    "link": resultado.get("link", ""),
                    "fonte": resultado.get("fonte", "")
                })
    
    df = pd.DataFrame(linhas)

df.to_csv(nome_arquivo, index=False)
        print(f"Dados exportados para {nome_arquivo}")
        
        return nome_arquivo
    
    @staticmethod
    def create_html_report(dados_analise, nome_arquivo="relatorio.html"):
        """Cria um relatório HTML a partir dos dados de análise"""
        html = f"""
        <!DOCTYPE html>
        <html>
        <head>
            <title>Relatório de Análise de Busca</title>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 40px; }}
                .section {{ margin-bottom: 30px; padding: 20px; 
                           background-color: #f5f5f5; border-radius: 8px; }}
                h1 {{ color: #333; }}
                h2 {{ color: #666; }}
                pre {{ white-space: pre-wrap; word-wrap: break-word; }}
            </style>
        </head>
        <body>
            <h1>Relatório de Análise de Busca</h1>
            <p>Gerado: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
            
            <div class="section">
                <h2>Resultados da Análise</h2>
                <pre>{dados_analise.get('analise', 'Nenhuma análise disponível')}</pre>
            </div>
            
            <div class="section">
                <h2>Resumo dos Dados</h2>
                <p>Tópico: {dados_analise.get('topico', 'N/A')}</p>
                <p>Resultados analisados: {len(dados_analise.get('dados_busca', []))}</p>
            </div>
        </body>
        </html>
        """
        
        with open(nome_arquivo, 'w') as f:
            f.write(html)
        
        print(f"Relatório HTML criado: {nome_arquivo}")

def main():
    # Inicializar componentes
    monitor_concorrentes = CompetitorMonitor()
    monitor_tendencias = TrendMonitor()
    exportador = DataExporter()
    
    # Exemplo 1: Análise de Concorrentes
    print("=== ANÁLISE DE CONCORRENTES ===")
    analise = monitor_concorrentes.analyze_competitors(
        company_name="OpenAI",
        competitors=["Anthropic", "Google AI", "Meta AI"]
    )
    
    print("\nResultados da Análise Competitiva:")
    print(analise["analise"])
    
    # Salvar resultados
    with open("analise_concorrente.json", "w") as f:
        json.dump(analise, f, indent=2)
    
    # Exemplo 2: Monitoramento de Tendências
    print("\n\n=== MONITORAMENTO DE TENDÊNCIAS ===")
    tendencias = monitor_tendencias.monitor_trend(
        keyword="regulação da inteligência artificial",
        time_range="w"  # Última semana
    )
    
    print("\nResultados da Análise de Tendências:")
    print(tendencias["analise"])
    
    # Exemplo 3: Análise de Múltiplos Tópicos
    print("\n\n=== ANÁLISE DE MÚLTIPLOS TÓPICOS ===")
    topicos = [
        "aplicações de negócios de IA generativa",
        "ameaças de cibersegurança de IA",
        "machine learning na saúde"
    ]
    
    analisador = SearchAnalyzer()
    todos_resultados = []
    
    for topico in topicos:
        print(f"\nAnalisando: {topico}")
        resultado = analisador.analyze_topic(topico)
        
        if resultado:
            todos_resultados.append(resultado)
            # Salvar análise individual
            nome_arquivo = f"{topico.replace(' ', '_')}_analise.txt"
            with open(nome_arquivo, "w") as f:
                f.write(resultado["analise"])
            print(f"Análise salva em {nome_arquivo}")
        
        # Atraso entre solicitações
        time.sleep(2)
    
    # Exportar todos os resultados para CSV
    if todos_resultados:
        arquivo_csv = exportador.export_to_csv(todos_resultados)
        print(f"\nTodos os resultados exportados para: {arquivo_csv}")
        
        # Criar relatório HTML para o primeiro resultado
        if todos_resultados[0]:
            exportador.create_html_report(todos_resultados[0])

if __name__ == "__main__":
    main()