Erstellen Sie einen KI-Agenten zur Lead-Generierung mit Bright Data

Die Lead-Generierung ist das Herzstück des Vertriebs, stellt jedoch für die meisten Teams nach wie vor einen frustrierenden Engpass dar. Herkömmliche Ansätze sind langsam, voreingenommen und schwer skalierbar, sodass Ihre besten Mitarbeiter in einem Kreislauf aus manueller Suche, Dateneingabe und Spekulationen gefangen sind. Was wäre, wenn Sie diese wichtige Funktion von einer mühsamen Aufgabe in einen nahtlosen, automatisierten Vorteil verwandeln könnten?

In diesem Leitfaden erfahren Sie:
– Was KI-Lead-Generierung ist
– Warum KI herkömmliche Methoden übertrifft
– Wie Sie Schritt für Schritt Ihren eigenen Lead-Generierungsagenten aufbauen
– Wie Bright Data Ihren Workflow optimiert

Los geht’s!

Was ist KI-Lead-Generierung?

Einfach ausgedrückt ist KI-Lead-Generierung der Prozess, bei dem künstliche Intelligenz eingesetzt wird, um potenzielle Kunden für Ihr Unternehmen automatisch zu finden, zu sammeln, anzureichern und zu qualifizieren. Dabei werden Rohdaten in umsetzbare Verkaufschancen umgewandelt.

Stellen Sie sich das als einen hocheffizienten, datengesteuerten Vertriebsmitarbeiter vor, der rund um die Uhr arbeitet. Er findet nicht nur Leads, sondern versteht sie auch.

Ein KI-Agent führt einen nahtlosen, automatisierten Workflow durch, der auf vier Schlüsselaktionen basiert:

Scrape – Er nutzt autonom Tools wie die Scraper von Bright Data, um Rohdaten aus gezielten Quellen (z. B. Linkedin, Unternehmenswebsites) zu sammeln. Dies ist seine Methode zur „Interaktion mit der externen Umgebung”.
Anreichern – Der Agent nimmt diese Rohdaten, bei denen es sich in der Regel um Details zu einem Unternehmen handelt, und verwendet andere Tools, um wichtige Informationen hinzuzufügen. Er findet automatisch E-Mail-Adressen, Telefonnummern, Tech-Stack-Daten, Nachrichten zur Unternehmensfinanzierung und andere öffentlich verfügbare Daten.
Bewertung – Hier kommt der Kern der KI-Agentin zum Tragen: „Entscheidungsfindung“ und „Problemlösung“. Anhand der angereicherten Daten qualifiziert sie einen Lead. Beispiel:
- Regelbasierte Bewertung: „Wenn Branche = Technologie und Mitarbeiterzahl > 50, 10 Punkte hinzufügen.”
- LLM-gestütztes Denken: Ein LLM analysiert das Profil des Leads und Unternehmensnachrichten, um die Eignung anhand einer nuancierten Eingabe zu bewerten, die Ihr Ideal Customer Profile (ICP) beschreibt. Es kann komplexe Kriterien verstehen, die mit einfachen Regeln nur schwer zu kodifizieren sind.
Engagieren: Schließlich führt der Agent eine Aktion durch. Es bleibt nicht nur bei der Analyse. Es kann den qualifizierten Lead automatisch zu einem CRM hinzufügen, eine personalisierte Outreach-E-Mail generieren oder sogar eine First-Touch-Nachricht auf einer anderen Plattform senden und so den Kreislauf von der Entdeckung bis zum ersten Kontakt schließen.

Warum die traditionelle Lead-Generierung versagt

Seit Jahrzehnten erfolgt der Verkaufsprozess zur Lead-Generierung weitgehend manuell. Ein Vertriebsmitarbeiter sucht manuell nach potenziellen Kunden, beurteilt deren Potenzial anhand begrenzter Informationen und hofft, dass seine Nachfassaktion zum richtigen Zeitpunkt in einem überfüllten Posteingang landet. Dieser Ansatz ist nicht nur veraltet, sondern auch grundlegend fehlerhaft. Hier sind die Gründe, warum traditionelle Methoden Ihr Vertriebsteam im Stich lassen:

1.Menschliche Voreingenommenheit bei der Qualifizierung: Der manuelle Prozess stützt sich stark auf Bauchgefühl und subjektive Urteile. Ein Vertriebsmitarbeiter könnte unbewusst Leads von bekannten Unternehmen oder bestimmten Positionen priorisieren.

2.Leads, die durch das Raster fallen: Die manuelle Lead-Generierung ist ein chaotischer Prozess, bei dem zwischen Registerkarten, Tabellenkalkulationen und CRM-Einträgen hin- und hergewechselt wird. Es ist unvermeidlich, dass vielversprechende Leads in unübersichtlichen Excel-Tabellen verloren gehen, in Browser-Registerkarten vergessen werden oder in der Hektik der ersten Aktivitäten gar nicht erst in das System eingegeben werden. Jeder Lead, der verloren geht, ist Umsatz, der direkt aus Ihrem Trichter verschwindet.

3.Begrenzte Verfügbarkeit von Teams: Ihr Vertriebsteam kann nur 40 Stunden pro Woche arbeiten (wenn Sie Glück haben). Es braucht Schlaf, Urlaub und Wochenenden. Das Internet hingegen nicht. Potenzielle Kunden recherchieren rund um die Uhr nach Lösungen, aber Ihr manueller Prozess kann nur während der Geschäftszeiten reagieren. Dies

Warum KI-basierte Lead-Generierung wichtig ist

Die KI-gestützte Lead-Generierung ist nicht nur eine Verbesserung, sondern eine vollständige Transformation des Vertriebsprozesses. Sie ist wichtig, weil sie die Kernprobleme traditioneller Methoden direkt angeht, indem sie Folgendes bietet:

Vollständige Automatisierung: Sie übernimmt die sich wiederholenden, zeitaufwändigen Aufgaben der Suche und Datenerfassung, sodass sich Ihr Team auf den Abschluss von Geschäften konzentrieren kann.
24/7-Betrieb: Im Gegensatz zu einem menschlichen Team arbeitet ein KI-Agent rund um die Uhr und stellt sicher, dass keine Gelegenheit aufgrund von Zeitzonen verpasst wird.
Datengestützte Entscheidungen: Sie ersetzt menschliche Vermutungen und Vorurteile durch objektive, kriterienbasierte Qualifikationen und stellt sicher, dass Sie nur die vielversprechendsten Leads verfolgen.
Sofortige Reaktion: KI kann innerhalb von Minuten einen Lead identifizieren und Kontakt aufnehmen, was die Interaktionsraten und die Konversionsrate drastisch erhöht.
Unbegrenzte Skalierbarkeit: Er kann mühelos Tausende von potenziellen Kunden analysieren, sodass Ihr Unternehmen seine Reichweite skalieren kann, ohne die Mitarbeiterzahl proportional zu erhöhen.

Nachdem Sie nun gesehen haben, wie KI die Vertriebsreichweite verändert, ist es wichtig zu verstehen, wie Sie Ihre eigenen Angelegenheiten aufbauen können. Als Nächstes schauen wir uns an, wie Sie Ihren eigenen KI-gestützten Lead-Generierungsagenten aufbauen können.

Aufbau Ihres KI-Agenten zur Lead-Generierung

In dieser Frage werden wir Schritt für Schritt die Erstellung Ihres KI-Agenten zur Lead-Generierung durchgehen. Wir werden einen optimierten Agenten erstellen, der den gesamten Workflow automatisiert. Sie werden sehen, wie einfach Bright Data und Streamlit zusammenarbeiten, um ein System zu schaffen, das unermüdlich für Sie arbeitet.

Voraussetzungen

Richten Sie Ihre Entwicklungsumgebung mit den folgenden Anforderungen ein:

(Python 3.9) oder höher
Bright Data-Konto: Registrieren Sie sich und erstellen Sie einen API-Token (kostenlose Testguthaben verfügbar)
OpenAI-API-Schlüssel: Erstellen Sie in Ihrem OpenAI-Dashboard einen Schlüssel für Embeddings und LLM-Zugriff
Ein Code-Editor wie VS Code oder PyCharm
Python Virtual Environment isoliert Abhängigkeiten.
Die Streamlit -Bibliothek bietet eine interaktive Benutzeroberfläche, über die Benutzer das Tool nutzen können.

Einrichten der Umgebung

Erstellen Sie Ihr Projektverzeichnis und installieren Sie Abhängigkeiten. Beginnen Sie mit der Einrichtung einer sauberen virtuellen Umgebung, um Konflikte mit anderen Python-Projekten zu vermeiden.

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

Erstellen Sie eine neue Datei namens lead_generator.py und fügen Sie die folgenden Importe hinzu. Diese Bibliotheken übernehmen das Web-Scraping, die Textverarbeitung, die Einbettungen und die Benutzeroberfläche.

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

Bright Data-Konfiguration

Speichern Sie Ihre API-Anmeldedaten sicher mithilfe von Umgebungsvariablen. Erstellen Sie eine .env- Datei, um Ihre Anmeldedaten zu speichern, und halten Sie sensible Informationen von Ihrem Code getrennt.

BRIGHT_DATA_API_TOKEN="Ihr_Bright_Data_API-Token_hier"
OPENAI_API_KEY="Ihr_OpenAI_API-Schlüssel_hier"

Sie benötigen:

Bright Data API-Token: Generieren Sie diesen über Ihr Bright Data-Dashboard
OpenAI-API-Schlüssel: Für die LLM-Textgenerierung

Schritt 1: Daten mit Bright Data sammeln

Es ist an der Zeit, eine Konfiguration einzurichten, um Lead-Daten beispielsweise aus LinkedIn-Profilen zu erhalten.

Wenn Sie mit der Funktionsweise der Web Scraper-APIs von Bright Data nicht vertraut sind, sollten Sie zunächst die Dokumentation lesen.

Kurz gesagt, Web Scraper-APIs bieten API-Endpunkte, mit denen Sie öffentliche Daten aus bestimmten Domänen abrufen können. Im Hintergrund initialisiert und führt Bright Data eine vorgefertigte Scraping-Aufgabe auf seinen Servern aus. Diese APIs übernehmen die IP-Rotation, die CAPTCHA-Lösung und andere Maßnahmen, um öffentliche Daten von Webseiten effektiv und ethisch einwandfrei zu sammeln. Sobald die Aufgabe abgeschlossen ist, werden die gescrapten Daten in ein strukturiertes Format geparst und Ihnen als Snapshot zur Verfügung gestellt.

Der allgemeine Arbeitsablauf ist also wie folgt:

Lösen Sie den API-Aufruf aus, um eine Web-Scraping-Aufgabe zu starten.
Überprüfen Sie regelmäßig, ob der Snapshot mit den gescrapten Daten bereitsteht.
Rufen Sie die Daten aus dem Snapshot ab, sobald er verfügbar ist.

Sie können die oben beschriebene Logik mit nur wenigen Zeilen Code implementieren

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

    def collect_leads(self, filters: Dict[str, Any], limit: int = 10) -> List[Dict[str, Any]]:
        # Suche auslösen
        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 []

        # Abfragen, bis bereit
        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 []

Schritt 2: Qualifizierung von Leads mit KI

Wenn Sie Roh-Leads gesammelt haben, besteht die nächste Herausforderung darin, herauszufinden, welche davon zu Ihrem idealen Kundenprofil passen. Anstelle einer manuellen Bewertung können Sie einen KI-Qualifizierer verwenden, der Suchparameter extrahiert, Leads analysiert, Relevanzbewertungen zuweist und die besten Übereinstimmungen hervorhebt.

In der folgenden Klasse zeigen wir, wie Sie diesen Workflow mit LangChain und OpenAi erstellen können.

   """KI-gestützte Lead-Qualifizierung und -Bewertung"""

    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)

        # Aufforderung zur Qualifizierung
        self.analysis_prompt = PromptTemplate(
            input_variables=["query", "lead"],
            template="""
            Originalabfrage: {query}
            Lead: {lead}

            JSON mit folgenden Angaben zurückgeben:
            - Punktzahl (1-100)
            - Analyse
            - Schwachstellen
            - Wertversprechen
            - Entscheidungsebene
            - Engagementwahrscheinlichkeit
"""
        )

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

    def qualify(self, lead: dict, query: str) -> dict:
        """Qualify a single lead"""
        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:
        """Leads qualifizieren und bewerten"""
        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):
        """FAISS-Vektorspeicher für semantische Suche erstellen"""
        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)

Schritt 3: Streamlit-Benutzeroberfläche für die Interaktion

Dies ist die UI-Ebene, die alles miteinander verbindet, indem Sie API-Schlüssel konfigurieren, KI-Einstellungen steuern und Leads mit übersichtlichen Grafiken erkunden können

st.set_page_config(page_title="KI-gestützter Lead-Generierungsagent", page_icon="🎯", layout="wide")

# Header
st.title("🔎 KI-gestützter Lead-Generierungsagent")

# Sidebar-Einstellungen
with st.sidebar:
    st.header("API-Schlüssel")
    bright_data_api_key = st.text_input("Bright Data API-Schlüssel", type="password")
    openai_api_key = st.text_input("OpenAI API-Schlüssel", type="password")
    st.header("Einstellungen")
    model_name = st.selectbox("OpenAI-Modell", ["gpt-3.5-turbo", "gpt-4"])
    max_leads = st.slider("Max. Leads", 5, 50, 10)

# Chat-Schnittstelle
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("Beschreiben Sie Ihre idealen Leads...")

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

    # Platzhalter: KI extrahiert Filter und ruft Leads ab
    st.chat_message("assistant").markdown("Filter extrahiert, Leads werden abgerufen...")

# Einfache Lead-Karte anzeigen
def display_lead_card(lead: Dict[str, Any]):
    with st.expander(f"{lead.get('name')} - {lead.get('title')} bei {lead.get('company')}"):
        st.write(f"Standort: {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"Punktzahl: {lead.get('score', 0)}/100")

# Beispiel-Leads
sample_leads = [
    {"name": "Jane Doe", "title": "Marketing Manager", "company": „Fintech Co”, „location”: „CA”, „email”: „[email protected]”, „linkedin”: „linkedin.com/janedoe”, „score”: 85}
]

st.subheader(„Qualifizierte Leads”)
for lead in sample_leads:
    display_lead_card(lead)

Mit dieser Benutzeroberfläche erhalten Benutzer nicht nur rohe JSON-Werte, sondern sehen auf einen Blick die Rangfolge der Leads, Einblicke und das Engagementpotenzial.

Schritt 4: Automatisierung von Follow-ups

Nachdem Sie Ihre Leads qualifiziert haben, müssen Sie sie noch zum richtigen Zeitpunkt mit der richtigen Botschaft ansprechen. Hier kommt die Automatisierung ins Spiel. Die Klasse FollowUpAutomator generiert personalisierte Outreach-E-Mails, Linkedin-Nachrichten und Follow-ups und plant und führt diese dann in einer strukturierten Abfolge aus.

Klasse FollowUpAutomator:
    """Einfaches automatisiertes Follow-up-System für qualifizierte Leads"""

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

        # Einfache Vorlagen
        self.initial_prompt = PromptTemplate(
            input_variables=["name", "company"],
            template="Schreiben Sie eine kurze, freundliche Kontakt-E-Mail an {name} bei {company}."
        )
        self.followup_prompt = PromptTemplate(
            input_variables=["name", "company"],
            template="Schreiben Sie eine höfliche Folge-E-Mail an {name} bei {company} mit maximal 80 Wörtern."
        )
        self.linkedin_prompt = PromptTemplate(
            input_variables=["name", "industry"],
            template="Schreiben Sie eine kurze LinkedIn-Verbindungsnachricht an {name} in der Branche {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]]:
        """Erstellt eine 3-stufige Outreach-Sequenz für einen Lead"""
        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]]:
        """Weist jedem Kontakt Termine zu"""
        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

Schritt 5: Code fertigstellen und ausführen

Ihr endgültiger Code in lead_generator.py kann nun mit folgendem Befehl ausgeführt werden:

streamlit run lead_generator.py

Wenn Sie den vollständigen Code ausführen, nimmt der Assistent Ihre Anfrage entgegen, ruft neue Leads aus Bright Data ab und bereichert sie mit KI-gesteuerten Bewertungen und Erkenntnissen. Jede Charge von 10 Leads wird verarbeitet, bis bis zu 40 Stellenanzeigen analysiert, bewertet und nach Relevanz, Entscheidungskraft und Engagementwahrscheinlichkeit gereiht sind. Schließlich wird der vollständige Satz der angereicherten Ergebnisse in eine saubere results.csv-Datei exportiert, sodass Sie nicht nur eine Liste mit Kontakten erhalten, sondern eine KI-qualifizierte Lead-Datenbank, die sofort einsatzbereit ist.

The final UI of the AI lead generation agent

Zusammenfassung

Sie verfügen nun über ein vollständiges Framework für die Erstellung eines KI-gestützten Lead-Generierungsagenten, der den gesamten Workflow der Kundenakquise automatisiert. Dieses System sammelt autonom neue Daten aus dem Internet, ergänzt sie mit wichtigen Kontextinformationen, qualifiziert Leads auf intelligente Weise anhand Ihres idealen Kundenprofils und bereitet sie für eine sofortige Kontaktaufnahme vor.

Die wahre Stärke dieses Ansatzes liegt in seiner Flexibilität. Sie können dieses Framework für jede Branche anpassen, von SaaS und Finanzen bis hin zu E-Commerce und Personalbeschaffung, indem Sie einfach Ihre Zieldatenquellen und Qualifizierungskriterien in den Bright Data- und LLM-Einstellungen ändern. Das modulare Design ermöglicht es Ihnen, neue Datenendpunkte, Bewertungsalgorithmen oder Ausgabekanäle einfach zu integrieren, wenn sich Ihr Vertriebsprozess weiterentwickelt.

Um noch fortschrittlichere und leistungsfähigere Workflows zu erstellen, empfehlen wir Ihnen, die gesamte Bandbreite der Datensätze und Lösungen in der Bright Data-Dokumentation zu erkunden.

Erstellen Sie noch heuteein kostenloses Bright Data-Konto und nutzen Sie Ihre Testgutschriften, um mit dem Aufbau Ihres eigenen automatisierten Lead-Generierungsagenten zu beginnen. Verwandeln Sie Ihre Vertriebspipeline von einem undichten Wasserhahn in einen vorhersehbaren, schnellen Umsatzmotor.

Vertrieb kontaktieren Gratis testen