Creación de un agente de generación de clientes potenciales con IA utilizando datos brillantes

La generación de clientes potenciales es el alma de las ventas, pero para la mayoría de los equipos sigue siendo un cuello de botella frustrante. Los enfoques tradicionales son lentos, sesgados y difíciles de escalar, lo que atrapa a sus mejores talentos en un ciclo de búsqueda manual, introducción de datos y conjeturas. Pero, ¿y si pudiera transformar esta función crítica de una tarea tediosa en una ventaja automatizada y fluida?

En esta guía aprenderás:
– Qué es la generación de clientes potenciales mediante IA
– Por qué la IA supera a los métodos tradicionales
– Cómo crear su propio agente de generación de clientes potenciales paso a paso
– Cómo Bright Data potencia su flujo de trabajo

¡Empecemos!

¿Qué es la generación de leads con IA?

En términos sencillos, la generación de clientes potenciales mediante IA es el proceso de utilizar la IA para encontrar, recopilar, enriquecer y calificar automáticamente a los clientes potenciales para su negocio. Transforma los datos brutos en oportunidades de venta viables.

Piensa en ello como un representante de desarrollo de ventas altamente eficiente y basado en datos que trabaja las 24 horas del día, los 7 días de la semana. No solo encuentra clientes potenciales, sino que los comprende.

Un agente de IA realiza un flujo de trabajo automatizado y fluido basado en cuatro acciones clave:

1. Rastrear: utiliza de forma autónoma herramientas como los Scrapers de Bright Data para recopilar datos sin procesar de fuentes específicas (por ejemplo, Linkedin, sitios web de empresas). Este es su método para «interactuar con el entorno externo».
2. Enriquecer: el agente toma estos datos sin procesar, que suelen ser detalles de una empresa, y utiliza otras herramientas para añadir información crucial. Encuentra automáticamente direcciones de correo electrónico, números de teléfono, datos sobre tecnología, noticias sobre la financiación de la empresa y otros datos disponibles públicamente.
3. Puntuación: aquí es donde destaca el núcleo de «toma de decisiones» y «resolución de problemas» del agente de IA. Utilizando los datos enriquecidos, califica a un cliente potencial. Por ejemplo:
   • Puntuación basada en reglas: «Si industria = Tecnología y número de empleados > 50, añadir 10 puntos».
   • Razonamiento basado en LLM: un LLM analiza el perfil del cliente potencial y las noticias de la empresa para evaluar su idoneidad basándose en una indicación matizada que describe su perfil de cliente ideal (ICP). Puede comprender criterios complejos que son difíciles de codificar con reglas simples.
4. Interactuar: Por último, el agente realiza una acción. No se limita al análisis. Puede añadir automáticamente el cliente potencial cualificado a un CRM, generar un correo electrónico de contacto personalizado o incluso enviar un primer mensaje de contacto en otra plataforma, cerrando el ciclo desde el descubrimiento hasta el primer contacto.

Por qué falla la generación tradicional de clientes potenciales

Durante décadas, el proceso de ventas para la generación de clientes potenciales ha seguido siendo en gran medida manual. Un representante de ventas busca manualmente clientes potenciales, juzga su potencial basándose en información limitada y espera que su seguimiento llegue a una bandeja de entrada llena en el momento adecuado. Este enfoque no solo está desfasado, sino que es fundamentalmente defectuoso. He aquí por qué los métodos tradicionales están fallando a su equipo de ventas:

1.Sesgo humano en la calificación: el proceso manual se basa en gran medida en corazonadas y juicios subjetivos. Un representante puede dar prioridad inconscientemente a los clientes potenciales de empresas conocidas o puestos específicos.

2.Clientes potenciales que se pierden: la generación manual de clientes potenciales es un proceso caótico que consiste en cambiar entre pestañas, hojas de cálculo y entradas de CRM. Es inevitable que los clientes potenciales prometedores se pierdan en hojas de Excel desordenadas, se olviden en pestañas del navegador o nunca se introduzcan en el sistema en el primer momento de actividad. Cada cliente potencial que se pierde es un ingreso que sale directamente de su embudo.

3.Disponibilidad limitada de los equipos: su equipo de ventas solo puede trabajar 40 horas a la semana (si tiene suerte). Necesitan dormir, vacaciones y fines de semana. Sin embargo, Internet no. Los clientes potenciales buscan soluciones a todas horas, pero su proceso manual solo puede responder durante el horario laboral. Esto

Por qué es importante la generación de clientes potenciales mediante IA

La generación de clientes potenciales impulsada por la IA no es solo una mejora, es una transformación completa del proceso de ventas. Es importante porque aborda directamente los principales fallos de los métodos tradicionales al ofrecer:

• Automatización total: se encarga de las tareas repetitivas y que requieren mucho tiempo, como la búsqueda y la recopilación de datos, lo que libera a su equipo para que se centre en cerrar acuerdos.
• Funcionamiento 24/7: a diferencia de un equipo humano, un agente de IA trabaja las 24 horas del día, lo que garantiza que no se pierda ninguna oportunidad debido a las zonas horarias.
• Decisiones basadas en datos: sustituye las conjeturas y los sesgos humanos por una calificación objetiva basada en criterios, lo que garantiza que solo se persigan los clientes potenciales con mayor potencial.
• Respuesta instantánea: la IA puede identificar e iniciar el contacto con un cliente potencial en cuestión de minutos, lo que aumenta drásticamente las tasas de interacción y conversión.
• Escala ilimitada: puede analizar sin esfuerzo miles de clientes potenciales, lo que permite a su empresa ampliar su alcance sin aumentar proporcionalmente su plantilla.

Ahora que ha visto cómo la IA está transformando el alcance de las ventas, es importante comprender cómo crear su propio agente. A continuación, veamos cómo puede crear su propio agente de generación de clientes potenciales basado en IA.

Creación de su agente de generación de clientes potenciales con IA

En esta pregunta, le guiaremos paso a paso por la creación de su agente de generación de clientes potenciales con IA. Crearemos un agente optimizado que automatiza todo el flujo de trabajo. Verá lo fácil que es combinar Bright Data y Streamlit para crear un sistema que trabaje sin descanso para usted.

Requisitos previos

Configura tu entorno de desarrollo con estos requisitos:

• (Python 3.9) o superior
• Cuenta de Bright Data: regístrese y cree un token API (créditos de prueba gratuitos disponibles)
• Clave API de OpenAI: crea una clave en tu panel de control de OpenAI para incrustaciones y acceso a LLM
• Un editor de código como VS Code o PyCharm
• El entorno virtual de Python mantiene las dependencias aisladas.
• La bibliotecaStreamlit proporciona una interfaz de usuario interactiva, lo que permite a los usuarios utilizar la herramienta.

Configuración del entorno

Cree el directorio de su proyecto e instale las dependencias. Comience por configurar un entorno virtual limpio para evitar conflictos con otros proyectos de Python.

python -m venv venv
# macOS/Linux: source venv/bin/activate
# Windows: venvScriptsactivate
pip install langchain langchain-community langchain-openai streamlit python-dotenv 

Cree un nuevo archivo llamado lead_generator.py y añada las siguientes importaciones. Estas bibliotecas se encargan del Scraping web, el procesamiento de texto, las incrustaciones y la interfaz de usuario.

import base64
import json
import streamlit as st
import os
import requests
from dotenv import load_dotenv
from typing import Dict, List, Any

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
from langchain.schema import Document
from langchain.agents import initialize_agent, AgentType, Tool
from langchain.memory import ConversationBufferMemory
from langchain.callbacks import StreamlitCallbackHandler

load_dotenv()

Configuración de Bright Data

Almacene sus credenciales API de forma segura utilizando variables de entorno. Cree un archivo .env para almacenar sus credenciales, manteniendo la información confidencial separada de su código.

BRIGHT_DATA_API_TOKEN="tu_bright_data_api_token_aquí"
OPENAI_API_KEY="tu_openai_api_key_aquí"

Necesitas:

• Token de API de Bright Data: géneralo desde tu panel de control de Bright Data
• Clave API de OpenAI: para la generación de texto LLM

Paso 1: Recopilación de datos con Bright Data

Es hora de configurar los ajustes para obtener datos de clientes potenciales, por ejemplo, de perfiles de Linkedin.

Si no está familiarizado con el funcionamiento de las API de Web Scraper de Bright Data, vale la pena consultar primero la documentación.

En resumen, las API de Scraping web proporcionan puntos finales de API que le permiten recuperar datos públicos de dominios específicos. Entre bastidores, Bright Data inicializa y ejecuta una tarea de scraping ya preparada en sus servidores. Estas API se encargan de la rotación de IP, la Resolución de CAPTCHA y otras medidas para recopilar de forma eficaz y ética datos públicos de páginas web. Una vez completada la tarea, los datos recopilados se analizan en un formato estructurado y se ponen a su disposición en forma de instantánea.

Por lo tanto, el flujo de trabajo general es el siguiente:

1. Activar la llamada a la API para iniciar una tarea de Scraping web.
2. Compruebe periódicamente si la instantánea que contiene los datos extraídos está lista.
3. Recuperar los datos de la instantánea una vez que estén disponibles.

Puede implementar la lógica anterior con solo unas pocas líneas de código

class BrightDataCollector:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.brightdata.com/conjuntos_de_datos/v3"
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def collect_leads(self, filters: Dict[str, Any], limit: int = 10) -> List[Dict[str, Any]]:
        # Activar búsqueda
        r = requests.post(
            f"{self.base_url}/trigger",
            headers={**self.headers, "Content-Type": "application/json"},
            params={"dataset_id": "gd_your_lead_dataset_id", "type": "discover_new", "limit_per_input": str(limit)},
            json=[{
                "keyword": f"{filters.get('role','')} {filters.get('industry','')}".strip(),
                "location": filters.get("location", "")
            }]
        )
        snapshot_id = r.json().get("snapshot_id")
        if not snapshot_id:
            return []

        # Sondear hasta que esté listo
        url = f"{self.base_url}/snapshot/{snapshot_id}?format=json"
        for _ in range(30):
            snap = requests.get(url, headers=self.headers)
            if snap.status_code == 200:
                return snap.json()
            time.sleep(5)
        return []

Paso 2: Calificar clientes potenciales con IA

Una vez recopilados los clientes potenciales sin procesar, el siguiente reto es determinar cuáles se ajustan a su perfil de cliente ideal. En lugar de realizar una puntuación manual, puede utilizar un calificador de IA que extrae los parámetros de búsqueda, analiza los clientes potenciales, asigna puntuaciones de relevancia y destaca las mejores coincidencias.

En la clase siguiente, mostramos cómo crear este flujo de trabajo con LangChain y OpenAi.

   """Calificación y puntuación de clientes potenciales con IA"""

    def __init__(self, api_key: str):
        self.llm = ChatOpenAI(api_key=api_key, model_name="gpt-3.5-turbo", temperature=0.3)
        self.embeddings = OpenAIEmbeddings(api_key=api_key)

        # Solicitud de calificación
        self.analysis_prompt = PromptTemplate(
            input_variables=["query", "lead"],
            template="""
            Consulta original: {query}
            Cliente potencial: {lead}

            Devuelve JSON con:
            - puntuación (1-100)
            - análisis
            - puntos débiles
            - propuesta de valor
            - nivel del responsable de la toma de decisiones
            - probabilidad de compromiso
            """
        )

        self.analysis_chain = LLMChain(llm=self.llm, prompt=self.analysis_prompt)

    def qualify(self, lead: dict, query: str) -> dict:
        """Calificar un solo cliente potencial"""
        result = self.analysis_chain.run(query=query, lead=json.dumps(lead))
        return {**lead, **json.loads(result)}

    def batch_qualify(self, leads: list, query: str) -> list:
        """Calificar y clasificar clientes potenciales"""
        results = [self.qualify(lead, query) for lead in leads]
        return sorted(results, key=lambda x: x["score"], reverse=True)

    def vector_store(self, leads: list):
        """Crear almacén vectorial FAISS para búsqueda semántica"""
        docs = [Document(page_content=f"{l['name']} {l['title']} {l['company']}", metadata={"i": i})
                for i, l in enumerate(leads)]
        return FAISS.from_documents(docs, self.embeddings)

Paso 3: Interfaz de usuario Streamlit para la interacción

Esta es la capa de interfaz de usuario que lo une todo, ya que permite configurar claves API, controlar los ajustes de IA y explorar clientes potenciales con imágenes claras

st.set_page_config(page_title="Agente de generación de clientes potenciales con IA", page_icon="🎯", layout="wide")

# Encabezado
st.title("🔎 Agente de generación de clientes potenciales con IA")

# Ajustes de la barra lateral
with st.sidebar:
    st.header("Claves API")
    bright_data_api_key = st.text_input("Clave API de Bright Data", type="password")
    openai_api_key = st.text_input("Clave API de OpenAI", type="password")
    st.header("Ajustes")
    model_name = st.selectbox("Modelo OpenAI", ["gpt-3.5-turbo", "gpt-4"])
    max_leads = st.slider("Máximo de clientes potenciales", 5, 50, 10)

# Interfaz de chat
if "messages" not in st.session_state:
    st.session_state.messages = []

for msg in st.session_state.messages:
    with st.chat_message(msg["role"]):
        st.markdown(msg["content"])

user_input = st.chat_input("Describe tus clientes potenciales ideales...")

if user_input:
    st.session_state.messages.append({"role": "user", "content": user_input})
    st.chat_message("user").markdown(user_input)

    # Marcador de posición: la IA extrae filtros y obtiene clientes potenciales
    st.chat_message("assistant").markdown("Extracting filters, fetching leads...")

# Mostrar una tarjeta de cliente potencial sencilla
def display_lead_card(lead: Dict[str, Any]):
    with st.expander(f"{lead.get('name')} - {lead.get('title')} en {lead.get('company')}"):
        st.write(f"Ubicación: {lead.get('location', 'N/A')}")
        st.write(f"Correo electrónico: {lead.get('email', 'N/A')}")
        st.write(f"LinkedIn: {lead.get('linkedin', 'N/A')}")
        st.write(f"Puntuación: {lead.get('score', 0)}/100")

# Ejemplo de clientes potenciales
sample_leads = [
    {"name": "Jane Doe", "title": "Marketing Manager", "company": "Fintech Co", "location": "CA", "email": "[email protected]", "linkedin": "linkedin.com/janedoe", "score": 85}
]

st.subheader("Clientes potenciales cualificados")
for lead in sample_leads:
    display_lead_card(lead)

Con esta interfaz de usuario, los usuarios no solo obtienen puntuaciones JSON sin procesar, sino que también pueden ver de un vistazo los clientes potenciales clasificados, información detallada y el potencial de interacción.

Paso 4: Automatizar los seguimientos

Después de calificar a sus clientes potenciales, aún deberá interactuar con ellos en el momento adecuado y con el mensaje adecuado. Ahí es donde entra en juego la automatización. La clase FollowUpAutomator genera correos electrónicos personalizados, mensajes de Linkedin y seguimientos, y luego los programa y ejecuta en una secuencia estructurada.

class FollowUpAutomator:
    """Sistema básico de seguimiento automatizado para clientes potenciales calificados"""

    def __init__(self, api_key: str):
        self.llm = ChatOpenAI(api_key=api_key, model_name="gpt-3.5-turbo", temperature=0.7)

        # Plantillas simples
        self.initial_prompt = PromptTemplate(
            input_variables=["name", "company"],
            template="Escribe un correo electrónico de contacto breve y cordial a {name} en {company}."
        )
        self.followup_prompt = PromptTemplate(
            input_variables=["name", "company"],
            template="Escribe un correo electrónico de seguimiento cortés a {name} en {company}, con menos de 80 palabras."
        )
        self.linkedin_prompt = PromptTemplate(
            input_variables=["name", "industry"],
            template="Escribe un mensaje breve para conectar en LinkedIn con {name} en el sector {industry}."
        )

        self.initial_chain = LLMChain(llm=self.llm, prompt=self.initial_prompt)
        self.followup_chain = LLMChain(llm=self.llm, prompt=self.followup_prompt)
        self.linkedin_chain = LLMChain(llm=self.llm, prompt=self.linkedin_prompt)

    def create_sequence(self, lead: Dict[str, Any]) -> List[Dict[str, Any]]:
        """Crea una secuencia de contacto de 3 pasos para un cliente potencial"""
        return [
            {"day": 0, "type": "email", "content": self.initial_chain.run(name=lead["name"], company=lead["company"])},
            {"day": 2, "type": "linkedin", "content": self.linkedin_chain.run(name=lead["name"], industry=lead.get("industry", ""))},
            {"day": 7, "type": "email", "content": self.followup_chain.run(name=lead["name"], company=lead["company"])}
        ]

    def schedule(self, leads: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Asigna fechas a cada contacto"""
        scheduled = []
        for lead in leads:
            base = datetime.now()
            sequence = self.create_sequence(lead)
            for touch in sequence:
                touch["scheduled_date"] = base + timedelta(days=touch["day"])
                touch["lead"] = lead["name"]
            scheduled.append({"lead": lead["name"], "sequence": sequence})
        return scheduled

Paso 5: Completa el código y ejecútalo

Tu código final en lead_generator.py y ahora puedes ejecutarlo con:

streamlit run lead_generator.py

Cuando ejecuta el código completo, el asistente toma su consulta, extrae nuevos clientes potenciales de Bright Data y los enriquece con puntuaciones e información basada en IA. Se procesa cada lote de 10 clientes potenciales hasta que se analizan, puntúan y clasifican hasta 40 ofertas de empleo por relevancia, poder de decisión y probabilidad de compromiso. Por último, el conjunto completo de resultados enriquecidos se exporta a un archivo results.csv limpio, lo que le proporciona no solo una lista de contactos, sino una base de datos de clientes potenciales calificados por IA lista para actuar.

Conclusión

Ahora dispone de un marco completo para crear un agente de generación de clientes potenciales impulsado por IA que automatiza todo el flujo de trabajo de prospección. Este sistema recopila de forma autónoma datos nuevos de la web, los enriquece con contexto crucial, califica de forma inteligente los clientes potenciales en función de su perfil de cliente ideal y los prepara para una interacción inmediata.

El verdadero poder de este enfoque reside en su flexibilidad. Puede adaptar este marco a cualquier sector, desde SaaS y finanzas hasta comercio electrónico y contratación, simplemente modificando sus fuentes de datos objetivo y criterios de calificación en la configuración de Bright Data y LLM. El diseño modular le permite incorporar fácilmente nuevos puntos finales de datos, algoritmos de puntuación o canales de salida a medida que evoluciona su proceso de ventas.

Para crear flujos de trabajo más avanzados y potentes, le animamos a explorar toda la gama de Conjuntos de datos y soluciones en la documentación de Bright Data.

Cree hoy mismouna cuentagratuita en Bright Data y utilice sus créditos de prueba para empezar a crear su propio agente automatizado de generación de clientes potenciales. Transforme su canal de ventas de un grifo que gotea en un motor de ingresos predecible y de alta velocidad.