Agente de Inteligência de Avaliações Multi-Fonte com CrewAI e Bright Data

Avaliações de clientes espalhadas por várias plataformas criam desafios de análise para as empresas. O monitoramento manual de avaliações é demorado e frequentemente deixa passar insights essenciais. Este guia mostra como construir um agente de IA que coleta, analisa e categoriza avaliações de diferentes fontes automaticamente.

Você aprenderá:

Como construir um sistema de inteligência de avaliações usando CrewAI e o Bright Data MCP da Bright Data
Como realizar análise de sentimento baseada em aspectos no feedback de clientes
Como categorizar avaliações por tópico e gerar insights acionáveis

Confira o projeto final no GitHub!

O que é CrewAI?

CrewAI é um framework de código aberto para construir equipes colaborativas de agentes de IA. Você define funções, objetivos e ferramentas dos agentes para executar fluxos de trabalho complexos. Cada agente lida com tarefas específicas enquanto trabalha em conjunto em direção a um objetivo comum.

O CrewAI é composto por:

Agente: Um trabalhador alimentado por LLM com responsabilidades e ferramentas definidas
Tarefa: Um trabalho específico com requisitos de saída bem definidos
Ferramenta: Funções que os agentes usam para trabalhos especializados, como extração de dados
Crew: Uma coleção de agentes trabalhando juntos

O que é MCP?

MCP (Model Context Protocol) é um padrão JSON-RPC 2.0 que conecta agentes de IA a ferramentas externas e fontes de dados por meio de uma interface unificada.

O servidor Bright Data MCP da Bright Data fornece acesso direto a capacidades de scraping de dados com proteção anti-bot por meio de 400M+ proxies residenciais rotativos, renderização de JavaScript para conteúdo dinâmico, saída JSON limpa de dados extraídos e mais de 50 ferramentas prontas para diferentes plataformas.

O que Estamos Construindo: Agente de Inteligência de Avaliações Multi-Fonte

Criaremos um sistema CrewAI que extrai automaticamente avaliações de empresas específicas em múltiplas plataformas como G2, Capterra, Trustpilot e TrustRadius, obtendo a classificação de cada uma e as principais avaliações, realiza análise de sentimento baseada em aspectos, categoriza o feedback por tópicos (Suporte, Preço, Facilidade de Uso), pontua o sentimento de cada categoria e gera insights de negócios acionáveis.

Pré-requisitos

Configure seu ambiente de desenvolvimento com:

Python 3.11 ou superior
Node.js e npm para o servidor Bright Data MCP
Conta Bright Data – Cadastre-se e crie um token de API (créditos de teste gratuito estão disponíveis).
Chave de API Nebius – Crie uma chave no Nebius AI Studio (clique em + Get API Key). Você pode usá-la gratuitamente. Nenhum perfil de faturamento é necessário.
Ambiente virtual Python – Mantém as dependências isoladas; consulte a documentação do venv.

Configuração do Ambiente

Crie o diretório do projeto e instale as dependências:

python -m venv venv
# macOS/Linux: source venv/bin/activate
# Windows: venv\\Scripts\\activate
pip install "crewai-tools[mcp]" crewai mcp python-dotenv pandas textblob

Crie um novo arquivo chamado review_intelligence.py e adicione as seguintes importações:

from crewai import Agent, Task, Crew, Process
from crewai_tools import MCPServerAdapter
from mcp import StdioServerParameters
from crewai.llm import LLM
import os
import json
import pandas as pd
from datetime import datetime
from dotenv import load_dotenv
from textblob import TextBlob

load_dotenv()

Configuração do Bright Data MCP da Bright Data

Crie um arquivo .env com suas credenciais:

BRIGHT_DATA_API_TOKEN="your_api_token_here"
WEB_UNLOCKER_ZONE="your_web_unlocker_zone"
BROWSER_ZONE="your_browser_zone"
NEBIUS_API_KEY="your_nebius_api_key"

Você precisará de:

Token de API: Gere um novo token de API no painel da Bright Data
Zona Web Unlocker: Crie uma nova zona Web Unlocker para sites de imóveis
Zona Browser API: Crie uma nova zona Browser API para sites com muito JavaScript
Chave de API Nebius: Já criada nos Pré-requisitos

Configure o LLM e o servidor Bright Data MCP em review_intelligence.py:

llm = LLM(
    model="nebius/Qwen/Qwen3-30B-A3B",
    api_key=os.getenv("NEBIUS_API_KEY")
)

server_params = StdioServerParameters(
    command="npx",
    args=["@brightdata/mcp"],
    env={
        "API_TOKEN": os.getenv("BRIGHT_DATA_API_TOKEN"),
        "WEB_UNLOCKER_ZONE": os.getenv("WEB_UNLOCKER_ZONE"),
        "BROWSER_ZONE": os.getenv("BROWSER_ZONE"),
    },
)

Definição de Agentes e Tarefas

Defina agentes especializados para diferentes aspectos da análise de avaliações. O agente scraper de avaliações extrai avaliações de clientes de múltiplas plataformas e retorna dados JSON limpos e estruturados com texto da avaliação, classificações, datas e fonte da plataforma. Este agente tem conhecimento especializado em scraping de dados, com profundo entendimento das estruturas das plataformas de avaliação e capacidade de contornar medidas anti-bot.

def build_review_scraper_agent(mcp_tools):
    return Agent(
        role="Review Data Collector",
        goal=(
            "Extract customer reviews from multiple platforms and return clean, "
            "structured JSON data with review text, ratings, dates, and platform source."
        ),
        backstory=(
            "Expert in web scraping with deep knowledge of review platform structures. "
            "Skilled at bypassing anti-bot measures and extracting complete review datasets "
            "from Amazon, Yelp, Google Reviews, and other platforms."
        ),
        tools=mcp_tools,
        llm=llm,
        max_iter=3,
        verbose=True,
    )

O agente analisador de sentimento analisa o sentimento das avaliações em três aspectos principais: Qualidade do Suporte, Satisfação com o Preço e Facilidade de Uso. Ele fornece pontuações numéricas e raciocínio detalhado para cada categoria. Este agente é especializado em processamento de linguagem natural e análise de sentimento de clientes, com expertise em identificar indicadores emocionais e padrões de feedback específicos por aspecto.

def build_sentiment_analyzer_agent():
    return Agent(
        role="Sentiment Analysis Specialist",
        goal=(
            "Analyze review sentiment across three key aspects: Support Quality, "
            "Pricing Satisfaction, and Ease of Use. Provide numerical scores and "
            "detailed reasoning for each category."
        ),
        backstory=(
            "Data scientist specializing in natural language processing and customer "
            "sentiment analysis. Expert at identifying emotional indicators, context clues, "
            "and aspect-specific feedback patterns in customer reviews."
        ),
        llm=llm,
        max_iter=2,
        verbose=True,
    )

O agente gerador de insights transforma os resultados da análise de sentimento em insights de negócios acionáveis. Ele identifica tendências, destaca problemas críticos e fornece recomendações específicas de melhoria. Este agente traz expertise em análise estratégica com habilidades em otimização da experiência do cliente e tradução de dados de feedback em ações concretas de negócios.

def build_insights_generator_agent():
    return Agent(
        role="Business Intelligence Analyst",
        goal=(
            "Transform sentiment analysis results into actionable business insights. "
            "Identify trends, highlight critical issues, and provide specific "
            "recommendations for improvement."
        ),
        backstory=(
            "Strategic analyst with expertise in customer experience optimization. "
            "Skilled at translating customer feedback data into concrete business "
            "actions and priority frameworks."
        ),
        llm=llm,
        max_iter=2,
        verbose=True,
    )

Montagem e Execução do Crew

Crie tarefas para cada etapa do pipeline de análise. A tarefa de scraping coleta avaliações das páginas de produto especificadas e gera JSON estruturado com informações da plataforma, texto da avaliação, classificações, datas e status de verificação.

def build_scraping_task(agent, product_urls):
    return Task(
        description=f"Scrape reviews from these product pages: {product_urls}",
        expected_output="""{
            "reviews": [
                {
                    "platform": "amazon",
                    "review_text": "Great product, fast shipping...",
                    "rating": 5,
                    "date": "2024-01-15",
                    "reviewer_name": "John D.",
                    "verified_purchase": true
                }
            ],
            "total_reviews": 150,
            "platforms_scraped": ["amazon", "yelp"]
        }""",
        agent=agent,
    )

A tarefa de análise de sentimento processa as avaliações para analisar os aspectos de Suporte, Preço e Facilidade de Uso. Ela retorna pontuações numéricas, classificações de sentimento, temas principais e contagens de avaliações para cada categoria.

def build_sentiment_analysis_task(agent):
    return Task(
        description="Analyze sentiment for Support, Pricing, and Ease of Use aspects",
        expected_output="""{
            "aspect_analysis": {
                "support_quality": {
                    "score": 4.2,
                    "sentiment": "positive",
                    "key_themes": ["responsive", "helpful", "knowledgeable"],
                    "review_count": 45
                },
                "pricing_satisfaction": {
                    "score": 3.1,
                    "sentiment": "mixed",
                    "key_themes": ["expensive", "value", "competitive"],
                    "review_count": 67
                },
                "ease_of_use": {
                    "score": 4.7,
                    "sentiment": "very positive",
                    "key_themes": ["intuitive", "simple", "user-friendly"],
                    "review_count": 89
                }
            }
        }""",
        agent=agent,
    )

A tarefa de insights gera inteligência de negócios acionável a partir dos resultados da análise de sentimento. Ela fornece resumos executivos, ações prioritárias, áreas de risco, identificação de pontos fortes e recomendações estratégicas.

def build_insights_task(agent):
    return Task(
        description="Generate actionable business insights from sentiment analysis",
        expected_output="""{
            "executive_summary": "Overall customer satisfaction is strong...",
            "priority_actions": [
                "Address pricing concerns through value communication",
                "Maintain excellent ease of use standards"
            ],
            "risk_areas": ["Price sensitivity among new customers"],
            "strengths": ["Intuitive user experience", "Quality support team"],
            "recommended_focus": "Pricing strategy optimization"
        }""",
        agent=agent,
    )

Análise de Sentimento Baseada em Aspectos

Adicione funções de análise de sentimento que identificam aspectos específicos mencionados nas avaliações e calculam pontuações de sentimento para cada área de interesse.

def analyze_aspect_sentiment(reviews, aspect_keywords):
    """Analyze sentiment for specific aspects mentioned in reviews."""
    aspect_reviews = []
    
    for review in reviews:
        text = review.get('review_text', '').lower()
        if any(keyword in text for keyword in aspect_keywords):
            blob = TextBlob(review['review_text'])
            sentiment_score = blob.sentiment.polarity
            
            aspect_reviews.append({
                'text': review['review_text'],
                'sentiment_score': sentiment_score,
                'rating': review.get('rating', 0),
                'platform': review.get('platform', '')
            })
    
    return aspect_reviews

Categorizando Avaliações em Tópicos (Suporte, Preço, Facilidade de Uso)

A função de categorização organiza as avaliações nos tópicos Suporte, Preço e Facilidade de Uso com base na correspondência de palavras-chave. As palavras-chave de suporte incluem termos relacionados ao atendimento ao cliente e assistência. As palavras-chave de preço cobrem menções a custo, valor e acessibilidade.

def categorize_by_aspects(reviews):
    """Categorize reviews into Support, Pricing, and Ease of Use topics."""
    
    support_keywords = ['support', 'help', 'service', 'customer', 'response', 'assistance']
    pricing_keywords = ['price', 'cost', 'expensive', 'cheap', 'value', 'money', 'affordable']
    usability_keywords = ['easy', 'difficult', 'intuitive', 'complicated', 'user-friendly', 'interface']
    
    categorized = {
        'support': analyze_aspect_sentiment(reviews, support_keywords),
        'pricing': analyze_aspect_sentiment(reviews, pricing_keywords),
        'ease_of_use': analyze_aspect_sentiment(reviews, usability_keywords)
    }
    
    return categorized

agente retornando as avaliações categorizadas

Pontuando o Sentimento para Cada Tópico

Implemente a lógica de pontuação que converte a análise de sentimento em classificações numéricas e categorias significativas.

def calculate_aspect_scores(categorized_reviews):
    """Calculate numerical scores for each aspect category."""
    
    scores = {}
    
    for aspect, reviews in categorized_reviews.items():
        if not reviews:
            scores[aspect] = {'score': 0, 'count': 0, 'sentiment': 'neutral'}
            continue
            
        # Calculate average sentiment score
        sentiment_scores = [r['sentiment_score'] for r in reviews]
        avg_sentiment = sum(sentiment_scores) / len(sentiment_scores)
        
        # Convert to 1-5 scale
        normalized_score = ((avg_sentiment + 1) / 2) * 5
        
        # Determine sentiment category
        if avg_sentiment > 0.3:
            sentiment_category = 'positive'
        elif avg_sentiment < -0.3:
            sentiment_category = 'negative'
        else:
            sentiment_category = 'neutral'
            
        scores[aspect] = {
            'score': round(normalized_score, 1),
            'count': len(reviews),
            'sentiment': sentiment_category,
            'raw_sentiment': round(avg_sentiment, 2)
        }
    
    return scores

Gerando o Relatório Final de Insights

Conclua a execução do fluxo de trabalho orquestrando todos os agentes e tarefas em sequência. A função principal cria agentes especializados para scraping, análise de sentimento e geração de insights. Ela reúne esses agentes em um crew com processamento sequencial de tarefas.

def analyze_reviews(product_urls):
    """Main function to orchestrate the review intelligence workflow."""
    
    with MCPServerAdapter(server_params) as mcp_tools:
        # Create agents
        scraper_agent = build_review_scraper_agent(mcp_tools)
        sentiment_agent = build_sentiment_analyzer_agent()
        insights_agent = build_insights_generator_agent()
        
        # Create tasks
        scraping_task = build_scraping_task(scraper_agent, product_urls)
        sentiment_task = build_sentiment_analysis_task(sentiment_agent)
        insights_task = build_insights_task(insights_agent)
        
        # Assemble crew
        crew = Crew(
            agents=[scraper_agent, sentiment_agent, insights_agent],
            tasks=[scraping_task, sentiment_task, insights_task],
            process=Process.sequential,
            verbose=True
        )
        
        return crew.kickoff()

if __name__ == "__main__":
    product_urls = [
        "<https://www.amazon.com/product-example-1>",
        "<https://www.yelp.com/biz/business-example>"
    ]
    
    try:
        result = analyze_reviews(product_urls)
        print("Review Intelligence Analysis Complete!")
        print(json.dumps(result, indent=2))
    except Exception as e:
        print(f"Analysis failed: {str(e)}")

Execute a análise:

python review_intelligence.py

Você verá o processo de raciocínio do agente no console enquanto cada agente planeja e executa suas tarefas. O sistema mostrará como está:

Extraindo dados abrangentes de avaliações de múltiplas plataformas
Analisando lacunas competitivas e posicionamento de mercado
Processando padrões de sentimento e pontuação de qualidade das avaliações
Identificando menções a funcionalidades e inteligência de preços
Fornecendo recomendações estratégicas e alertas de risco

Conclusão

Ao automatizar a inteligência de avaliações com CrewAI e a poderosa infraestrutura de dados web da Bright Data, você pode obter insights mais profundos sobre clientes, otimizar sua análise competitiva e tomar decisões de negócios mais inteligentes. Com os produtos da Bright Data e as soluções de scraping de dados anti-bot líderes do setor, você está equipado para escalar a coleta de avaliações e a análise de sentimento em qualquer setor. Para as estratégias e atualizações mais recentes, explore o blog da Bright Data ou saiba mais em nossos guias detalhados de scraping de dados para começar a maximizar o valor do seu feedback de clientes hoje.

Contate-nos Teste grátis