Agente de inteligencia de reseñas multifuente con CrewAI y Bright Data

Las reseñas de clientes dispersas en múltiples plataformas crean desafíos de análisis para las empresas. El monitoreo manual de reseñas consume mucho tiempo y a menudo pasa por alto información esencial. Esta guía te muestra cómo construir un agente de IA que recopila, analiza y categoriza automáticamente reseñas de diferentes fuentes.

Aprenderás:

Cómo construir un sistema de inteligencia de reseñas usando CrewAI y el Bright Data MCP de Bright Data
Cómo realizar análisis de sentimiento basado en aspectos sobre el feedback de clientes
Cómo categorizar reseñas por tema y generar información procesable

¡Consulta el proyecto final en GitHub!

¿Qué es CrewAI?

CrewAI es un framework de código abierto para construir equipos colaborativos de agentes de IA. Defines roles, objetivos y herramientas para los agentes que ejecutan flujos de trabajo complejos. Cada agente maneja tareas específicas mientras trabaja en conjunto hacia un objetivo común.

CrewAI se compone de:

Agente: Un trabajador impulsado por LLM con responsabilidades y herramientas definidas
Tarea: Un trabajo específico con requisitos de salida claros
Herramienta: Funciones que los agentes usan para trabajo especializado, como la extracción de datos
Crew: Una colección de agentes trabajando juntos

¿Qué es MCP?

MCP (Model Context Protocol) es un estándar JSON-RPC 2.0 que conecta agentes de IA a herramientas externas y fuentes de datos a través de una interfaz unificada.

El servidor Bright Data MCP de Bright Data proporciona acceso directo a capacidades de scraping web con protección anti-bot a través de 400M+ proxies residenciales rotativos, renderizado de JavaScript para contenido dinámico, salida JSON limpia de los datos extraídos y más de 50 herramientas listas para usar en diferentes plataformas.

Qué estamos construyendo: Agente de inteligencia de reseñas multifuente

Crearemos un sistema CrewAI que extrae automáticamente reseñas de empresas específicas desde múltiples plataformas como G2, Capterra, Trustpilot y TrustRadius, obteniendo la puntuación de cada una y las mejores reseñas, realiza análisis de sentimiento basado en aspectos, categoriza el feedback en temas (Soporte, Precios, Facilidad de uso), puntúa el sentimiento por categoría y genera información de negocio procesable.

Requisitos previos

Configura tu entorno de desarrollo con:

Python 3.11 o superior
Node.js y npm para el servidor Bright Data MCP
Cuenta de Bright Data – Regístrate y crea un token de API (hay créditos de prueba gratuita disponibles).
Clave API de Nebius – Crea una clave en Nebius AI Studio (haz clic en + Get API Key). Puedes usarla de forma gratuita. No se requiere perfil de facturación.
Entorno virtual de Python – Mantiene las dependencias aisladas; consulta la documentación de venv.

Configuración del entorno

Crea el directorio de tu proyecto e instala las dependencias:

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

Crea un nuevo archivo llamado review_intelligence.py y añade las siguientes importaciones:

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()

Configuración del Bright Data MCP de Bright Data

Crea un archivo .env con tus credenciales:

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"

Necesitas:

Token de API: Genera un nuevo token de API desde tu panel de control de Bright Data
Zona Web Unlocker: Crea una nueva zona Web Unlocker para sitios de bienes raíces
Zona Browser API: Crea una nueva zona Browser API para sitios de propiedades con mucho JavaScript
Clave API de Nebius: Ya creada en los requisitos previos

Configura el LLM y el servidor Bright Data MCP en 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"),
    },
)

Definición de agentes y tareas

Define agentes especializados para diferentes aspectos del análisis de reseñas. El agente scraper de reseñas extrae reseñas de clientes de múltiples plataformas y devuelve datos JSON limpios y estructurados con texto de reseña, puntuaciones, fechas y fuente de plataforma. Este agente tiene conocimiento experto en scraping web, con un profundo entendimiento de las estructuras de plataformas de reseñas y la capacidad de eludir 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,
    )

El agente analizador de sentimiento analiza el sentimiento de las reseñas en tres aspectos clave: Calidad del soporte, Satisfacción con los precios y Facilidad de uso. Proporciona puntuaciones numéricas y razonamiento detallado para cada categoría. Este agente se especializa en procesamiento del lenguaje natural y análisis de sentimiento de clientes, con experiencia en identificar indicadores emocionales y patrones 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,
    )

El agente generador de insights transforma los resultados del análisis de sentimiento en información de negocio procesable. Identifica tendencias, destaca problemas críticos y proporciona recomendaciones específicas de mejora. Este agente aporta experiencia en análisis estratégico con habilidades en optimización de la experiencia del cliente y traducción de datos de feedback en acciones de negocio concretas.

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,
    )

Ensamblaje y ejecución del crew

Crea tareas para cada etapa del pipeline de análisis. La tarea de scraping recopila reseñas de las páginas de producto especificadas y produce JSON estructurado con información de plataforma, texto de reseña, puntuaciones, fechas y estado de verificación.

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,
    )

La tarea de análisis de sentimiento procesa las reseñas para analizar los aspectos de Soporte, Precios y Facilidad de uso. Devuelve puntuaciones numéricas, clasificaciones de sentimiento, temas clave y conteos de reseñas para cada categoría.

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,
    )

La tarea de insights genera inteligencia de negocio procesable a partir de los resultados del análisis de sentimiento. Proporciona resúmenes ejecutivos, acciones prioritarias, áreas de riesgo, identificación de fortalezas y recomendaciones 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álisis de sentimiento basado en aspectos

Añade funciones de análisis de sentimiento que identifiquen aspectos específicos mencionados en las reseñas y calculen puntuaciones de sentimiento para cada área de interés.

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

Categorización de reseñas en temas (Soporte, Precios, Facilidad de uso)

La función de categorización organiza las reseñas en temas de Soporte, Precios y Facilidad de uso basándose en la coincidencia de palabras clave. Las palabras clave de soporte incluyen términos relacionados con el servicio al cliente y la asistencia. Las palabras clave de precios cubren menciones de costos, valor y asequibilidad.

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 devolviendo las reseñas categorizadas

Puntuación del sentimiento para cada tema

Implementa la lógica de puntuación que convierte el análisis de sentimiento en calificaciones numéricas y categorías 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

Generación del informe final de insights

Completa la ejecución del flujo de trabajo orquestando todos los agentes y tareas en secuencia. La función principal crea agentes especializados para scraping, análisis de sentimiento y generación de insights. Ensambla estos agentes en un crew con procesamiento secuencial de tareas.

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)}")

Ejecuta el análisis:

python review_intelligence.py

Verás el proceso de pensamiento del agente en la consola mientras cada agente planifica y ejecuta sus tareas. El sistema mostrará cómo está:

Extrayendo datos completos de reseñas de múltiples plataformas
Analizando brechas competitivas y posicionamiento en el mercado
Procesando patrones de sentimiento y puntuando la calidad de las reseñas
Identificando menciones de características e inteligencia de precios
Proporcionando recomendaciones estratégicas y alertas de riesgo

Conclusión

Al automatizar la inteligencia de reseñas con CrewAI y la potente infraestructura de datos web de Bright Data, puedes descubrir insights más profundos sobre los clientes, optimizar tu análisis competitivo y tomar decisiones de negocio más inteligentes. Con los productos de Bright Data y sus soluciones de scraping web anti-bot líderes en la industria, estás equipado para escalar la recopilación de reseñas y el análisis de sentimiento en cualquier sector. Para conocer las últimas estrategias y novedades, explora el blog de Bright Data o consulta nuestras guías detalladas de scraping web para comenzar a maximizar el valor de tu feedback de clientes hoy mismo.

Contactar ventas Prueba gratuita