Agente de inteligencia de revisión multifuente con CrewAI y Bright Data

Las opiniones de los clientes dispersas por varias plataformas plantean retos de análisis a las empresas. La supervisión manual de las opiniones lleva mucho tiempo y a menudo pasa por alto información esencial. Esta guía le muestra cómo crear un agente de IA que recopile, analice y categorice automáticamente las reseñas de diferentes fuentes.

Aprenderá:

Cómo construir un sistema de inteligencia de reseñas utilizando CrewAI y Web MCP de Bright Data.
Cómo realizar un análisis de sentimiento basado en aspectos sobre las opiniones de los clientes
Cómo categorizar las reseñas por temas y generar información procesable

¡Echa un vistazo al proyecto final en GitHub!

¿Qué es CrewAI?

CrewAI es un marco de trabajo de código abierto para crear equipos de agentes de IA colaborativos. Usted define los roles, objetivos y herramientas de los agentes para ejecutar flujos de trabajo complejos. Cada agente se encarga de tareas específicas mientras trabajan juntos 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 resultados claros
Herramienta: Funciones que los agentes utilizan para trabajos especializados, como la extracción de datos
Equipo: Conjunto de agentes que trabajan juntos

¿Qué es MCP?

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

El servidor Web MCP de Bright Data proporciona acceso directo a capacidades de raspado web con protección anti-bot a través de más de 150 millones de IPs residenciales rotatorias, renderizado JavaScript para contenido dinámico, salida JSON limpia de datos raspados y más de 50 herramientas preparadas para diferentes plataformas.

Lo que estamos construyendo: Agente de inteligencia de revisión multifuente

Vamos a crear un sistema CrewAI que automáticamente raspa los comentarios para empresas específicas de múltiples plataformas como G2, Capterra, Trustpilot y TrustRadius y recupera la calificación de cada uno, y los mejores comentarios, realiza análisis de sentimiento basado en aspectos, categorías de retroalimentación en temas (Apoyo, Precios, Facilidad de uso), califica el sentimiento de cada categoría y genera ideas de negocio procesables.

Requisitos previos

Configure su entorno de desarrollo con

Python 3.11 o superior
Node.js y npm para el servidor Web MCP
Cuenta de Bright Data – Regístrese y cree un token de API (hay disponibles créditos de prueba gratuitos).
Clave API de Nebius – Cree una clave en Nebius AI Studio (haga clic en + Obtener clave API). Puede utilizarla gratuitamente. No se requiere perfil de facturación.
Entorno virtual Python – Mantiene las dependencias aisladas; consulte la documentación devenv.

Configuración del entorno

Cree el directorio de su proyecto e instale las dependencias:

python -m venv venv
# macOS/Linux: source venv/bin/activate
# Windows: venvScripts\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 Agente, Tarea, Tripulación, Proceso
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

cargar_dotenv()

Configuración de Bright Data Web MCP

Cree un archivo .env con sus credenciales:

BRIGHT_DATA_API_TOKEN="su_api_token_aquí"
WEB_UNLOCKER_ZONE="su_zona_de_desbloqueo_web"
BROWSER_ZONE="su_zona_del_navegador"
NEBIUS_API_KEY="su_clave_nebius_api_key"

Necesita

API token: Genere un nuevo token de API desde su panel de Bright Data
Zona Web Unlocker: Crear una nueva zona Web Unlocker para sitios inmobiliarios
Zona API de navegador: Cree una nueva zona Browser API para sitios inmobiliarios con mucho JavaScript
Clave API de Nebius: Ya creada en Requisitos previos

Configure el servidor LLM y Web MCP en review_intelligence.py:

llm = LLM(
    model="nebius/Qwen/Qwen3-235B-A22B",
    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

Defina agentes especializados para diferentes aspectos del análisis de reseñas. El agente review scraper extrae reseñas de clientes de múltiples plataformas y devuelve datos JSON limpios y estructurados con texto de reseña, valoraciones, fechas y fuente de plataforma. Este agente tiene un conocimiento experto en web scraping, con un profundo conocimiento de las estructuras de las plataformas de reseñas y la capacidad de eludir las medidas anti-bot.

def build_review_scraper_agent(mcp_tools):
    return Agente(
        role="Recopilador de datos de reseñas",
        objetivo=(
            "Extraer reseñas de clientes de múltiples plataformas y devolver datos JSON limpios y "
            "datos JSON estructurados con texto de la reseña, valoraciones, fechas y fuente de la plataforma".
        ),
        backstory=(
            "Experto en web scraping con profundo conocimiento de las estructuras de las plataformas de reseñas. "
            "Experto en eludir medidas anti-bot y extraer conjuntos de datos completos de reseñas "
            "de Amazon, Yelp, Google Reviews y otras plataformas".
        ),
        tools=mcp_tools,
        llm=llm,
        max_iter=3,
        verbose=True,
    )

El agente analizador de opiniones analiza las opiniones sobre tres aspectos clave: Calidad del soporte, Satisfacción con los precios y Facilidad de uso. Proporciona puntuaciones numéricas y razonamientos detallados para cada categoría. Este agente está especializado en el procesamiento del lenguaje natural y el análisis de los sentimientos de los clientes, con experiencia en la identificación de indicadores emocionales y patrones de opinión específicos de cada aspecto.

def build_sentiment_analyzer_agent():
    return Agente(
        role="Especialista en análisis de sentimientos",
        goal=(
            "Analizar el sentimiento de las opiniones en tres aspectos clave: Calidad del soporte, "
            "Satisfacción con los precios y Facilidad de uso. Proporcione puntuaciones numéricas y "
            "razonamientos detallados para cada categoría".
        ),
        backstory=(
            "Científico de datos especializado en procesamiento de lenguaje natural y "
            "análisis del sentimiento del cliente. Experto en identificar indicadores emocionales, pistas de contexto, "
            "y patrones de opinión específicos de cada aspecto en las opiniones de los clientes."
        ),
        llm=llm,
        max_iter=2,
        verbose=Verdadero,
    )

El agente generador de información transforma los resultados del análisis de opiniones en información empresarial procesable. Identifica tendencias, destaca problemas críticos y proporciona recomendaciones específicas para mejorar. Este agente aporta experiencia en el análisis estratégico con habilidades en la optimización de la experiencia del cliente y la traducción de los datos de comentarios en acciones empresariales concretas.

def build_insights_generator_agent():
    return Agente(
        role="Analista de Inteligencia de Negocio",
        objetivo=(
            "Transformar los resultados del análisis de opiniones en información empresarial procesable. "
            "Identificar tendencias, resaltar problemas críticos y proporcionar "
            "recomendaciones específicas de mejora".
        ),
        backstory=(
            "Analista estratégico con experiencia en optimización de la experiencia del cliente. "
            "Hábil en traducir los datos de feedback del cliente en acciones concretas de negocio "
            "acciones concretas y marcos de prioridades".
        ),
        llm=llm,
        max_iter=2,
        verbose=Verdadero,
    )

Montaje y ejecución de la tripulación

Cree tareas para cada etapa del proceso de análisis. La tarea de scraping recopila reseñas de páginas de productos especificadas y genera JSON estructurado con información de la plataforma, texto de la reseña, valoraciones, fechas y estado de verificación.

def build_scraping_task(agente, producto_urls):
    return Tarea(
        description=f "Recoge opiniones de estas páginas de productos: {product_urls}",
        expected_output="""{
            "opiniones": [
                {
                    "plataforma": "amazon",
                    "review_text": "Gran producto, envío rápido...",
                    "rating": 5,
                    "date": "2024-01-15",
                    "reviewer_name": "John D.",
                    "verified_purchase": true
                }
            ],
            "total_reviews": 150,
            "platforms_scraped": ["amazon", "yelp"]
        }""",
        agent=agente,
    )

La tarea de análisis de opiniones procesa las opiniones para analizar los aspectos de asistencia, precios y facilidad de uso. Devuelve puntuaciones numéricas, clasificaciones de opiniones, temas clave y recuentos de opiniones para cada categoría.

def crear_tarea_análisis_de_sentimiento(agente):
    return Tarea(
        description="Analizar la opinión sobre los aspectos de soporte, precio y facilidad de uso",
        expected_output="""{
            "aspect_analysis": {
                "calidad_soporte": {
                    "puntuación": 4.2,
                    "sentimiento": "positive",
                    "key_themes": ["responsive", "helpful", "knowledgeable"],
                    "review_count": 45
                },
                "pricing_satisfaction": {
                    "puntuación": 3.1,
                    "sentimiento": "mixed",
                    "key_themes": ["caro", "valor", "competitivo"],
                    "review_count": 67
                },
                "ease_of_use": {
                    "score": 4.7,
                    "sentiment": "muy positivo",
                    "key_themes": ["intuitivo", "sencillo", "fácil de usar"],
                    "review_count": 89
                }
            }
        }""",
        agente=agente,
    )

La tarea 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 puntos fuertes y recomendaciones estratégicas.

def build_insights_task(agente):
    return Tarea(
        description="Generar información empresarial práctica a partir del análisis de opiniones",
        expected_output="""{
            "executive_summary": "La satisfacción general del cliente es fuerte...",
            "priority_actions": [
                "Abordar las preocupaciones sobre precios mediante la comunicación de valores"
                "Mantener excelentes estándares de facilidad de uso"
            ],
            "risk_areas": ["Sensibilidad al precio entre los nuevos clientes"],
            "strengths": ["Intuitive user experience", "Quality support team"],
            "recommended_focus": "Optimización de la estrategia de precios"
        }""",
        agent=agente,
    )

Análisis de sentimiento basado en aspectos

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

def analizar_sentimiento_aspecto(opiniones, palabras_clave_aspecto):
    """Analizar el sentimiento para aspectos específicos mencionados en las reseñas."""
    aspecto_reseñas = []
    
    para reseña en reseñas:
        text = review.get('texto_reseña', '').lower()
        if any(keyword in text for keyword in aspect_keywords):
            blob = TextBlob(opinión['texto_opinión'])
            puntuación_sentimiento = blob.sentimiento.polaridad
            
            aspect_reviews.append({
                'text': reseña['texto_reseña'],
                'puntuación_sentimiento': puntuación_sentimiento,
                'valoración': review.get('valoración', 0),
                'plataforma': review.get('plataforma', '')
            })
    
    Devuelve aspect_reviews

Categorización de opiniones en temas (asistencia, precios, facilidad de uso)

La función de categorización organiza las opiniones en temas de asistencia, 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 precio incluyen menciones de coste, valor y asequibilidad.

def categorizar_por_aspectos(opiniones):
    """Clasifica las opiniones en temas de asistencia, precio y facilidad de uso."""
    
    support_keywords = ['soporte', 'ayuda', 'servicio', 'cliente', 'respuesta', 'asistencia']
    pricing_keywords = ['precio', 'coste', 'caro', 'barato', 'valor', 'dinero', 'asequible']
    usability_keywords = ['fácil', 'difícil', 'intuitivo', 'complicado', 'fácil de usar', 'interfaz']
    
    categorized = {
        asistencia": analyze_aspect_sentiment(opiniones, support_keywords),
        precio: analyze_aspect_sentiment(opiniones, precio_palabras_clave),
        'facilidad_de_uso': analyze_aspect_sentiment(opiniones, palabras_clave_usabilidad)
    }
    
    devolver categorizado

Puntuación del sentimiento para cada tema

Implementa la lógica de puntuación que convierte el análisis de sentimiento en valoraciones numéricas y categorías significativas.

def calcular_puntuaciones_de_aspecto(categorized_reviews):
    """Calcular puntuaciones numéricas para cada categoría de aspecto."""
    
    puntuaciones = {}
    
    for aspecto, opiniones in opiniones_categorizadas.items():
        if not opiniones:
            scores[aspect] = {'score': 0, 'count': 0, 'sentiment': 'neutral'}
            continue
            
        # Calcular la puntuación media
        puntuaciones_sentimiento = [r['puntuación_sentimiento'] for r in opiniones]
        avg_sentiment = sum(puntuaciones_sentimiento) / len(puntuaciones_sentimiento)
        
        # Convertir a escala 1-5
        puntuación_normalizada = ((sentimiento_avg + 1) / 2) * 5
        
        # Determinar la categoría de sentimiento
        si avg_sentiment > 0.3
            sentiment_category = 'positive'
        elif avg_sentiment < -0.3:
            sentiment_category = 'negative'
        si no
            sentiment_category = 'neutral'
            
        puntuaciones[aspecto] = {
            'puntuación': round(puntuación_normalizada, 1),
            'count': len(opiniones),
            'sentimiento': categoría_sentimiento,
            'raw_sentiment': round(avg_sentiment, 2)
        }
    
    devolver puntuaciones

Generación del informe final

Complete la ejecución del flujo de trabajo orquestando todos los agentes y tareas en secuencia. La función principal crea agentes especializados para el scraping, el análisis de sentimientos y la generación de insights. Reúne estos agentes en un equipo con procesamiento secuencial de tareas.

def analizar_revisiones(urls_producto):
    """Función principal para orquestar el flujo de trabajo de inteligencia de revisión."""
    
    with MCPServerAdapter(server_params) as mcp_tools:
        # Crear agentes
        scraper_agent = build_review_scraper_agent(mcp_tools)
        sentiment_agent = build_sentiment_analyzer_agent()
        insights_agent = build_insights_generator_agent()
        
        # Crear tareas
        scraping_task = build_scraping_task(scraper_agent, product_urls)
        sentiment_task = build_sentiment_analysis_task(agente_sentimiento)
        insights_task = build_insights_task(insights_agent)
        
        # Reunir la tripulación
        tripulación = Tripulación(
            agentes=[scraper_agent, sentiment_agent, insights_agent],
            tasks=[scraping_task, sentiment_task, insights_task],
            process=Process.sequential,
            verbose=Verdadero
        )
        
        return equipo.inicio()

if __name__ == "__main__":
    product_urls = [
        "<https://www.amazon.com/product-example-1>"
        "<https://www.yelp.com/biz/business-example>"
    ]
    
    try:
        result = analizar_revisiones(producto_urls)
        print("¡Análisis de inteligencia de reseñas completado!")
        print(json.dumps(resultado, sangría=2))
    except Excepción as e:
        print(f "Análisis fallido: {str(e)}")

Ejecutar el análisis:

python análisis_inteligencia.py

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

Extrayendo datos exhaustivos de reseñas de múltiples plataformas
Analizando las diferencias con la competencia y el posicionamiento en el mercado
Procesando patrones de sentimiento y puntuando la calidad de las reseñas
Identificación de menciones de características e inteligencia de precios
Proporciona recomendaciones estratégicas y alertas de riesgo

Conclusión

Al automatizar la inteligencia de reseñas con CrewAI y la potente plataforma de datos web de Bright Data, puede obtener información más profunda sobre los clientes, agilizar su análisis competitivo y tomar decisiones empresariales más inteligentes. Con los productos de Bright Data y las soluciones de raspado web anti-bot líderes del sector, estará equipado para ampliar la recopilación de reseñas y el análisis de opiniones para cualquier sector. Para conocer las últimas estrategias y actualizaciones, explore el blog de Bright Data u obtenga más información en nuestras detalladas guías de web scraping para empezar a maximizar el valor de las opiniones de sus clientes hoy mismo.

Prueba gratuita Inicia sesión con Google