Créez un agent de génération de prospects IA avec Bright Data

La génération de prospects est le moteur des ventes, mais pour la plupart des équipes, elle reste un goulot d’étranglement frustrant. Les approches traditionnelles sont lentes, biaisées et difficiles à mettre à l’échelle, piégeant vos meilleurs talents dans un cycle de recherche manuelle, de saisie de données et de conjectures. Mais que se passerait-il si vous pouviez transformer cette fonction essentielle, autrefois fastidieuse, en un avantage automatisé et transparent ?

Dans ce guide, vous apprendrez :
– Qu’est-ce que la génération de prospects par l’IA ?
– Pourquoi l’IA est plus efficace que les méthodes traditionnelles
– Comment créer votre propre agent de génération de prospects étape par étape
– Comment Bright Data optimise votre flux de travail

C’est parti !

Qu’est-ce que la génération de prospects par IA ?

En termes simples, la génération de prospects par IA est le processus qui consiste à utiliser l’IA pour trouver, collecter, enrichir et qualifier automatiquement des clients potentiels pour votre entreprise. Elle transforme les données brutes en opportunités commerciales exploitables.

Considérez-le comme un représentant commercial hautement efficace, axé sur les données, qui travaille 24 heures sur 24, 7 jours sur 7. Il ne se contente pas de trouver des prospects, il les comprend.

Un agent IA exécute un flux de travail automatisé et transparent basé sur quatre actions clés :

Récupération : il utilise de manière autonome des outils tels que les Scrapers de Bright Data pour collecter des données brutes à partir de sources ciblées (par exemple, Linkedin, sites web d’entreprises). C’est sa méthode pour « interagir avec l’environnement externe ».
Enrichir : l’agent prend ces données brutes, qui sont généralement des informations détaillées sur une entreprise, et utilise d’autres outils pour y ajouter des informations cruciales. Il trouve automatiquement les adresses e-mail, les numéros de téléphone, les données sur les technologies utilisées, les informations sur le financement de l’entreprise et d’autres données accessibles au public.
Notation : c’est là que le cœur de l’agent IA, à savoir la « prise de décision » et la « résolution de problèmes », prend tout son sens. À l’aide des données enrichies, il qualifie un prospect. Par exemple :
- Notation basée sur des règles : « Si secteur d’activité = Technologie et nombre d’employés > 50, ajoutez 10 points. »
- Raisonnement basé sur le LLM : un LLM analyse le profil du prospect et les actualités de l’entreprise afin d’évaluer leur adéquation à partir d’une invite nuancée décrivant votre profil client idéal (ICP). Il est capable de comprendre des critères complexes difficiles à codifier à l’aide de règles simples.
Engagement : enfin, l’agent effectue une action. Il ne se contente pas de l’analyse. Il peut automatiquement ajouter le prospect qualifié à un CRM, générer un e-mail de prospection personnalisé ou même envoyer un premier message sur une autre plateforme, bouclant ainsi la boucle entre la découverte et le premier contact.

Pourquoi la génération traditionnelle de prospects échoue

Pendant des décennies, le processus de vente pour la génération de prospects est resté largement manuel. Un commercial recherche manuellement des prospects, évalue leur potentiel sur la base d’informations limitées et espère que son suivi aboutira dans une boîte de réception bien remplie au bon moment. Cette approche n’est pas seulement dépassée, elle est fondamentalement erronée. Voici pourquoi les méthodes traditionnelles ne conviennent pas à votre équipe commerciale :

1.Biais humain dans la qualification : le processus manuel repose fortement sur l’intuition et les jugements subjectifs. Un commercial peut inconsciemment donner la priorité aux prospects provenant d’entreprises familières ou occupant des postes spécifiques.

2.Des prospects qui passent entre les mailles du filet : la génération manuelle de prospects est un processus chaotique qui consiste à passer d’un onglet à l’autre, d’une feuille de calcul à l’autre et d’une entrée CRM à l’autre. Il est inévitable que des prospects prometteurs se perdent dans des feuilles Excel désordonnées, soient oubliés dans les onglets du navigateur ou ne soient jamais saisis dans le système dans la précipitation des activités. Chaque prospect qui vous échappe représente un manque à gagner direct pour votre entonnoir de conversion.

3.Disponibilité limitée des équipes : votre équipe commerciale ne peut travailler que 40 heures par semaine (si vous avez de la chance). Elle a besoin de sommeil, de vacances et de week-ends. Ce n’est toutefois pas le cas d’Internet. Les clients potentiels recherchent des solutions à toute heure, mais votre processus manuel ne peut répondre qu’aux heures de bureau. C’est pourquoi

Pourquoi la génération de prospects par l’IA est-elle importante ?

La génération de prospects alimentée par l’IA n’est pas seulement une mise à niveau, c’est une transformation complète du processus de vente. Elle est importante car elle remédie directement aux principales failles des méthodes traditionnelles en offrant :

Automatisation totale : elle prend en charge les tâches répétitives et chronophages de recherche et de collecte de données, libérant ainsi votre équipe qui peut se concentrer sur la conclusion des ventes.
Fonctionnement 24 heures sur 24, 7 jours sur 7 : contrairement à une équipe humaine, un agent IA travaille sans interruption, garantissant qu’aucune opportunité n’est manquée en raison des fuseaux horaires.
Décisions basées sur les données : elle remplace les conjectures et les préjugés humains par une qualification objective, basée sur des critères, vous garantissant de ne poursuivre que les prospects les plus prometteurs.
Réponse instantanée : l’IA peut identifier et prendre contact avec un prospect en quelques minutes, ce qui augmente considérablement les taux d’engagement et de conversion.
Échelle illimitée : elle peut analyser sans effort des milliers de prospects, ce qui permet à votre entreprise d’étendre sa portée sans augmenter proportionnellement ses effectifs.

Maintenant que vous avez vu comment l’IA remodèle la prospection commerciale, il est important de comprendre comment créer votre propre agent. Voyons maintenant comment vous pouvez créer votre propre agent de génération de prospects alimenté par l’IA.

Créer votre agent de génération de prospects basé sur l’IA

Dans cette section, nous allons vous guider pas à pas dans la création de votre agent de génération de prospects basé sur l’IA. Nous allons créer un agent rationalisé qui automatise l’ensemble du flux de travail. Vous verrez à quel point il est facile de combiner Bright Data et Streamlit pour créer un système qui travaille sans relâche pour vous.

Prérequis

Configurez votre environnement de développement avec les exigences suivantes :

(Python 3.9) ou supérieur
Compte Bright Data: inscrivez-vous et créez un jeton API (crédits d’essai gratuits disponibles)
Clé API OpenAI: créez une clé dans votre tableau de bord OpenAI pour les intégrations et l’accès LLM
Un éditeur de code tel que VS Code ou PyCharm
L’environnement virtuel Python isole les dépendances.
La bibliothèqueStreamlit fournit une interface utilisateur interactive, permettant aux utilisateurs d’utiliser l’outil.

Configuration de l’environnement

Créez votre répertoire de projet et installez les dépendances. Commencez par configurer un environnement virtuel propre afin d’éviter tout conflit avec d’autres projets Python.

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

Créez un nouveau fichier appelé lead_generator.py et ajoutez les importations suivantes. Ces bibliothèques gèrent le Scraping web, le traitement de texte, les embeddings et l’interface utilisateur.

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

Configuration Bright Data

Stockez vos identifiants API en toute sécurité à l’aide de variables d’environnement. Créez un fichier .env pour stocker vos identifiants, en séparant les informations sensibles de votre code.

BRIGHT_DATA_API_TOKEN="votre_token_api_bright_data_ici"
OPENAI_API_KEY="votre_clé_api_openai_ici"

Vous avez besoin :

Jeton API Bright Data : générez-le à partir de votre tableau de bord Bright Data
Clé API OpenAI : pour la génération de texte LLM

Étape 1 : Collecte de données avec Bright Data

Il est temps de configurer le système pour obtenir des données sur les prospects à partir, par exemple, des profils LinkedIn.

Si vous ne savez pas comment fonctionnent les API Web Scraper de Bright Data, nous vous recommandons de consulter d’abord la documentation.

En bref, les API Web Scraper fournissent des points de terminaison API qui vous permettent de récupérer des données publiques à partir de domaines spécifiques. En arrière-plan, Bright Data initialise et exécute une tâche de scraping prête à l’emploi sur ses serveurs. Ces API gèrent la rotation des adresses IP, la résolution de CAPTCHA et d’autres mesures permettant de collecter de manière efficace et éthique des données publiques à partir de pages web. Une fois la tâche terminée, les données scrapées sont analysées dans un format structuré et mises à votre disposition sous forme d’instantané.

Ainsi, le flux de travail général est le suivant :

Déclenchez l’appel API pour lancer une tâche de Scraping web.
Vérifiez périodiquement si l’instantané contenant les données récupérées est prêt.
Récupérez les données à partir de l’instantané dès qu’il est disponible.

Vous pouvez implémenter la logique ci-dessus en quelques lignes de code seulement

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

    def collect_leads(self, filters: Dict[str, Any], limit: int = 10) -> List[Dict[str, Any]]:
        # Déclencher la recherche
        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 []

        # Poller jusqu'à ce que prêt
        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 []

Étape 2 : Qualifier les prospects avec l’IA

Une fois que vous avez collecté des prospects bruts, le défi suivant consiste à déterminer lesquels correspondent à votre profil client idéal. Au lieu d’une notation manuelle, vous pouvez utiliser un outil de qualification basé sur l’IA qui extrait les paramètres de recherche, analyse les prospects, attribue des scores de pertinence et met en évidence les meilleures correspondances.

Dans la classe ci-dessous, nous montrons comment créer ce flux de travail avec LangChain et OpenAi.

   « Qualification et notation des prospects grâce à l'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)

        # Invite pour la qualification
        self.analysis_prompt = PromptTemplate(
            input_variables=["query", "lead"],
            template="""
            Requête d'origine : {query}
            Prospect : {lead}

            Renvoyer JSON avec :
            - score (1-100)
            - analyse
            - points faibles
            - proposition de valeur
            - niveau du décideur
            - probabilité d'engagement
"""
        )

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

    def qualify(self, lead: dict, query: str) -> dict:
        """Qualifier un seul prospect"""
        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:
        """Qualifier et classer les prospects"""
        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):
        """Construire un magasin de vecteurs FAISS pour la recherche sémantique"""
        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)

Étape 3 : Interface utilisateur Streamlit pour l’interaction

Il s’agit de la couche d’interface utilisateur qui relie tous les éléments en vous permettant de configurer les clés API, de contrôler les paramètres d’IA et d’explorer les prospects à l’aide de visuels clairs

st.set_page_config(page_title="Agent de génération de prospects IA", page_icon="🎯", layout="wide")

# En-tête
st.title("🔎 Agent de génération de prospects IA")

# Paramètres de la barre latérale
avec st.sidebar :
    st.header("Clés API")
    bright_data_api_key = st.text_input("Clé API Bright Data", type="password")
    openai_api_key = st.text_input("Clé API OpenAI", type="password")
    st.header("Paramètres")
    model_name = st.selectbox("Modèle OpenAI", ["gpt-3.5-turbo", "gpt-4"])
    max_leads = st.slider("Nombre maximal de prospects", 5, 50, 10)

# Interface 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("Décrivez vos prospects idéaux...")

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

    # Espace réservé : l'IA extrait les filtres et récupère les prospects
    st.chat_message("assistant").markdown("Filtres extraits, récupération des prospects...")

# Afficher une fiche client simple
def display_lead_card(lead: Dict[str, Any]):
    with st.expander(f"{lead.get('name')} - {lead.get('title')} chez {lead.get('company')}"):
        st.write(f"Localisation : {lead.get('location', 'N/A')}")
        st.write(f"E-mail : {lead.get('email', 'N/A')}")
        st.write(f"LinkedIn : {lead.get('linkedin', 'N/A')}")
        st.write(f"Score : {lead.get('score', 0)}/100")

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

st.subheader(« Prospects qualifiés »)
for lead in sample_leads:
    display_lead_card(lead)

Grâce à cette interface utilisateur, les utilisateurs ne se contentent pas d’obtenir des scores JSON bruts, ils voient d’un seul coup d’œil le classement des prospects, des informations et le potentiel d’engagement.

Étape 4 : automatisation des suivis

Après avoir qualifié vos prospects, vous devrez encore les contacter au bon moment avec le bon message. C’est là que l’automatisation entre en jeu. La classe FollowUpAutomator génère des e-mails de prospection personnalisés, des messages Linkedin et des suivis, puis les planifie et les exécute dans un ordre structuré.

class FollowUpAutomator:
    """Système de suivi automatisé de base pour les prospects qualifiés"""

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

        # Modèles simples
        self.initial_prompt = PromptTemplate(
            input_variables=["name", "company"],
            template="Rédigez un e-mail de prospection court et convivial à {name} chez {company}."
        )
        self.followup_prompt = PromptTemplate(
            input_variables=["name", "company"],
            template="Rédigez un e-mail de suivi poli à {name} chez {company}, en moins de 80 mots."
        )
        self.linkedin_prompt = PromptTemplate(
            input_variables=["name", "industry"],
            template="Écrivez un court message de connexion LinkedIn à {name} dans le secteur {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]]:
        """Construit une séquence de prospection en 3 étapes pour un prospect"""
        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]]:
        """Attribue des dates à chaque contact"""
        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

Étape 5 : terminer le code et l’exécuter

Votre code final dans lead_generator.py et vous pouvez maintenant l’exécuter avec :

streamlit run lead_generator.py

Lorsque vous exécutez l’ensemble du code, l’assistant prend votre requête, extrait les nouveaux prospects de Bright Data et les enrichit grâce à un système de notation et d’analyse basé sur l’IA. Chaque lot de 10 prospects est traité jusqu’à ce que 40 offres d’emploi soient analysées, notées et classées par pertinence, pouvoir décisionnel et probabilité d’engagement. Enfin, l’ensemble complet des résultats enrichis est exporté dans un fichier results.csv propre, vous fournissant non seulement une liste de contacts, mais aussi une base de données de prospects qualifiés par l’IA, prête à l’emploi.

The final UI of the AI lead generation agent

Conclusion

Vous disposez désormais d’un cadre complet pour créer un agent de génération de prospects alimenté par l’IA qui automatise l’ensemble du processus de prospection. Ce système collecte de manière autonome des données récentes sur le web, les enrichit avec des informations contextuelles essentielles, qualifie intelligemment les prospects en fonction de votre profil client idéal et les prépare pour un engagement immédiat.

La véritable puissance de cette approche réside dans sa flexibilité. Vous pouvez adapter ce cadre à n’importe quel secteur, du SaaS à la finance en passant par le commerce électronique et le recrutement, en modifiant simplement vos sources de données cibles et vos critères de qualification dans les paramètres Bright Data et LLM. La conception modulaire vous permet d’intégrer facilement de nouveaux points de terminaison de données, des algorithmes de notation ou des canaux de sortie à mesure que votre processus de vente évolue.

Pour créer des flux de travail plus avancés et plus puissants, nous vous encourageons à explorer l’ensemble des Jeux de données et des solutions dans la documentation Bright Data.

Créez dès aujourd’huiun compte Bright Datagratuit et utilisez vos crédits d’essai pour commencer à créer votre propre agent automatisé de génération de prospects. Transformez votre pipeline de ventes, jusqu’alors peu efficace, en un moteur de revenus prévisible et à haute vitesse.

Contacter Ventes Essai gratuit