Direkte Antwort: Crawlbase Es integriert sich als spezialisiertes Werkzeug in einen agentenbasierten Workflow mit LangChain und ermöglicht den Echtzeit-Abruf von Webdaten während der Ausführung. Dadurch können LLMs Live-Webinhalte abrufen, verarbeiten und nutzen und so fundierte Antworten generieren, anstatt sich ausschließlich auf statische Trainingsdaten zu stützen.

So verwenden Sie Crawlbase und LangChainSie integrieren es als Werkzeug in einen LangChain- oder LangGraph-Agenten, damit Ihr Modell während der Ausführung Webdaten in Echtzeit abrufen kann.

Ziel dieses Leitfadens ist es, Ihnen eine funktionierende Implementierung zur Verfügung zu stellen, die Sie ausführen, testen und iterativ weiterentwickeln können.

Anstatt sich nur auf vorab erlerntes Wissen zu verlassen, kann der Agent selbst entscheiden, wann er neue oder externe Informationen benötigt. CrawlbaseDie Antwort verarbeiten und diese Daten nutzen, um fundierte Ausgaben zu generieren.

Das bedeutet Einwickeln Crawlbase Crawling API Als LangChain-Tool wird es in einem ReAct-ähnlichen Agenten registriert, sodass das Modell entscheiden kann, wann Daten abgerufen und wann direkt geantwortet wird. Das Ergebnis ist eine einfache, aber leistungsstarke Pipeline:

1
Benutzeranfrage → Agentenlogik → Crawlbase Abruf → strukturierter Text → fundierte Antwort

Crawlbase LangChain kümmert sich um Proxy-Rotation, Blockierung und JavaScript-Rendering. Die Orchestrierung übernimmt LangChain. Das Modell konzentriert sich auf logisches Denken.

Wenn Sie ein vollständiges, lauffähiges Projekt nachvollziehen möchten, können Sie es hier klonen: ScraperHub/how-to-use-crawlbase-with-langchain-for-ai-data-pipelines

Zum Abschnitt springen

Warum verwenden Crawlbase für LangChain-Datenpipelines?

A LangChain Der Agent ist ein LLM-basiertes System, das selbstständig Aktionen ausführt, anstatt nur Text zu generieren. Er beantwortet nicht nur Fragen, sondern kann basierend auf den Benutzereingaben Tools aufrufen, Daten abrufen oder mehrstufige Schlussfolgerungen ziehen.

Sobald man einem Agenten diese Art von Freiheit einräumt, stößt man auf ein praktisches Problem. Er benötigt Zugriff auf reale Daten, und das Internet ist die naheliegende Quelle. Genau dort beginnen die Probleme meist.

Standardmäßige Scraping-Ansätze stoßen aufgrund von Blockierungen, dynamischen Inhalten und Skalierungsproblemen schnell an ihre Grenzen. Crawlbase Löst diese Probleme auf Infrastrukturebene, sodass Ihre Agentenlogik sauber bleibt.

Anstatt Proxys, Wiederholungsversuche oder Headless-Browser zu verwalten, ruft Ihr Agent einfach ein Tool auf und erhält eine strukturierte Ausgabe.

Dies ermöglicht ein robusteres System, in dem:

  • Der Agent arbeitet mit sauberem, lesbarem Text anstelle von rohem HTML.
  • Seiten mit hohem JavaScript-Aufkommen können bei Bedarf geladen werden.
  • Fehler werden als strukturierte Signale sichtbar, nicht als stille Fehler.
  • Sie vermeiden die Wartung einer separaten Scraping-Infrastruktur.

Noch wichtiger ist jedoch, dass es die Qualität Ihrer Ergebnisse verbessert.

Ohne reale Daten basiert das Modell auf Vermutungen, die auf seinem bisherigen Wissen beruhen. Crawlbase Innerhalb dieser Schleife kann sie aktuelle Informationen abrufen und ihre Antwort auf konkrete Daten stützen. Dadurch wird aus einer allgemeinen Antwort etwas, worauf man sich tatsächlich verlassen kann.

Architektur: Der Ablauf eines geerdeten KI-Agenten

Im Wesentlichen besteht dieses System aus drei Ebenen, von denen jede eine ganz bestimmte Aufgabe hat.

  • CrawlbaseKunden Es verarbeitet die eigentlichen Webanfragen. Es kommuniziert mit dem Crawlbase Crawling API, wechselt bei Bedarf zwischen regulären und JavaScript-Tokens und gibt strukturierte Antworten zurück.
  • fetch_web_page tool sitzt in der Mitte. Es nimmt den rohen HTML-Code von Crawlbase, bereinigt den Text und wandelt ihn in lesbaren Text um, mit dem das Modell arbeiten kann.
  • LangGraph-Agent ist der Entscheidungsträger. Er prüft die Anfrage des Benutzers und entscheidet, ob er Daten abrufen muss oder direkt antworten kann.

Der Ablauf sieht folgendermaßen aus:

Wenn ein Benutzer eine Anfrage sendet, versucht der Agent zunächst, diese zu analysieren. Falls die Antwort neue oder externe Daten erfordert, ruft er die entsprechende Funktion auf. fetch_web_page Werkzeug.

Dieses Tool sendet dann eine Anfrage über CrawlbaseDiese Plattform kümmert sich um alle komplexen Details wie Proxys, Blockierung und JavaScript-Rendering. Sobald die Seite abgerufen wurde, liefert sie strukturierte Daten als Antwort.

Das Tool entfernt anschließend den HTML-Code, bereinigt den Inhalt und kürzt ihn so, dass er den Vorgaben des Modells entspricht. Dieser bereinigte Text wird an den Agenten zurückgesendet, der ihn zur Generierung einer fundierten Antwort verwendet.

Der Kerngedanke hierbei ist die Trennung der Zuständigkeiten.

Das Modell konzentriert sich auf das logische Denken. Das Werkzeug konzentriert sich auf die Aufbereitung nutzbarer Daten. Crawlbase Kümmert sich um alles, was mit dem Zugriff auf das Internet zu tun hat.

Da jede Schicht eine klar definierte Rolle hat, ist das System einfacher zu warten und zu skalieren. Man kann die Denkweise des Agenten ändern, ohne die Datenabfrage zu beeinflussen, und umgekehrt.

Umsetzung: Einrichtung des Projekts

Nun gehen wir das Ganze genauso durch, wie Sie es tatsächlich auf Ihrem Rechner einrichten würden.

Schritt 1: Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie Folgendes haben:

  • Python 3.11 oder neuer, da es gut mit modernen LangChain- und LangGraph-Systemen kompatibel ist.
  • Crawlbase TokenVerwenden Sie für die meisten HTML-Seiten das reguläre Token und halten Sie ein JavaScript-Token für Seiten bereit, die auf clientseitiges Rendering angewiesen sind.
  • An Anthropischer API-Schlüssel für den Beispielagenten. Wenn Sie später einen anderen Anbieter verwenden möchten, bleibt das allgemeine Vorgehen gleich.

Schritt 2: Klonen Sie das Repository

Führen Sie in Ihrem Terminal Folgendes aus:

1
2
git klonen https://github.com/ScraperHub/how-to-use-crawlbase-with-langchain-for-ai-data-pipelines.git
cd Anleitung zur Verwendung von Crawlbase mit Langchain für KI-Datenpipelines

Dadurch wird das Projekt in einen neuen Ordner heruntergeladen und Sie erhalten ein vollständiges, funktionsfähiges Projekt, bei dem alle Komponenten bereits miteinander verbunden sind.

Schritt 3: Umgebungsvariablen konfigurieren

Erstellen Sie .env Datei im Projektverzeichnis:

1
2
3
CRAWLBASE_REGULAR_TOKEN=Ihr_Token
CRAWLBASE_JS_TOKEN=Ihr_JS-Token
ANTHROPIC_API_KEY=Ihr_Schlüssel

Mithilfe dieser Zugangsdaten kann der Agent Webdaten abrufen und Antworten generieren.

Schritt 4: Installieren Sie Abhängigkeiten

1
pip install langgraph langchain langchain-core langchain-anthropic httpx python-dotenv pydantic pytest

Die Verwendung einer virtuellen Umgebung wird empfohlen, wenn Sie mehrere Python-Projekte verwalten.

Optional: Schnelltest mit Rauch

Bevor Sie dies in LangChain einbinden, sollten Sie überprüfen, ob Ihr Token funktioniert.

Sie können einen einfachen Live-Test wie diesen durchführen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
"""Optionaler Live-Rauchtest gegen Crawlbase (keine Spott- oder Verhöhnungsversuche).
Setzen Sie RUN_CRAWLBASE_LIVE=1 und ein gültiges CRAWLBASE_REGULAR_TOKEN, und führen Sie dann Folgendes aus:
    python code/scripts/smoke_crawlbase.py
"" "

ab __Zukunft__ importieren Anmerkungen

importieren os
importieren sys
ab Pfadlib importieren Path

# Importe aus Code zulassen/
_CODE = Path(__file__).resolve().parent.parent
if str(_CODE) kein Frontalunterricht. in sys.path:
    sys.path.insert(0, str(_CODE))

ab dotenv importieren load_dotenv

load_dotenv(_CODE / ".env")
load_dotenv(_CODE.parent / ".env")

def Haupt-() -> int:
    if os.environ.get("RUN_CRAWLBASE_LIVE") != "1":
        print(„Setzen Sie RUN_CRAWLBASE_LIVE=1, um diesen Smoke-Test auszuführen.“, Datei=sys.stderr)
        Rückkehr 0

    ab crawlbase_client importieren CrawlbaseKunden

    token = os.environ.get("CRAWLBASE_REGULAR_TOKEN", "").Streifen()
    if kein Frontalunterricht. Zeichen:
        print("CRAWLBASE_REGULAR_TOKEN ist erforderlich.", Datei=sys.stderr)
        Rückkehr 1

    url = os.environ.get("CRAWLBASE_SMOKE_URL", "https://example.com/")
    und  CrawlbaseClient.from_env() as Klient:
        data = client.fetch_json(url, use_javascript=falsch)

    pc = data.get("pc_status")
    print(f"OK url={data.get('URL')} pc_status={pc} original_status={data.get(„ursprünglicher_Status“)}")
    body = data.get("Karosserie", "")
    Vorschau = (body[:200] + "...") if Instanz(Körper, str) , len(body) > 200 sonst Körper
    print("Vorschau des Körpers:", Vorschau)
    Rückkehr 0 if pc == 200 or str(pc) == "200" sonst 2

if __name__ == "__hauptsächlich__":
    erhöhen SystemExit(main())

Dieser Schritt ist nicht zwingend erforderlich, hilft Ihnen aber, Probleme frühzeitig zu erkennen. Wenn dies funktioniert, kennen Sie Ihr Problem. Crawlbase Die Einrichtung ist korrekt, bevor der Agent hinzugefügt wird.

Schritt 5: Projekt ausführen

Jetzt können Sie den Agenten ausführen. Aus demselben Ordner:

1
python main.py „Aktuelle KI-News von heute“

Oder die Eingabe über stdin übergeben:

1
Echo "summize https://example.com" | python main.py

Wenn Sie den Befehl ausführen, wird eine vollständige Agentenschleife ausgelöst.

Ihre Anfrage wird an den LangGraph-Agenten weitergeleitet, der entscheidet, ob er direkt antworten kann oder externe Daten benötigt. Falls ja, ruft er die entsprechende Funktion auf. fetch_web_page Werkzeug.

Dieses Tool sendet eine Anfrage an CrawlbaseDie Seite wird abgerufen, in bereinigten Text umgewandelt und an den Agenten zurückgesendet. Das Modell verwendet diese Daten anschließend, um eine fundierte Antwort zu generieren.

Dies ist das Kernverhalten, das Sie entwickeln: ein Agent, der entscheiden kann, wann er Echtzeitinformationen abruft und diese effektiv nutzt.

Eine vollständige Übersicht über die Projektstruktur und die Konfigurationsoptionen finden Sie unter README.

Woran man erkennt, dass es funktioniert

Sobald alles korrekt eingerichtet ist, sollte sich das Ergebnis merklich von einer Standard-LLM-Antwort unterscheiden.

Wenn Sie nach aktuellen Ereignissen fragen, sollte die Antwort den aktuellen Stand widerspiegeln. Wenn Sie eine bestimmte URL angeben, sollte die Antwort eindeutig Inhalte von dieser Seite verwenden.

Sie werden außerdem feststellen, dass sich das Modell je nach Anfrage unterschiedlich verhält. Manchmal antwortet es sofort. In anderen Fällen ruft es die Daten zunächst ab.

Wenn etwas nicht funktioniert, gibt die Ausgabe in der Regel Aufschluss über die Ursache. Fehlende Tokens, blockierte Seiten oder JavaScript-intensive Websites werden als lesbare Meldungen anstatt als stille Fehlermeldungen angezeigt.

Das sind keine Probleme mit Ihrer Konfiguration. Es sind Signale dafür, dass Ihr System auf reale Bedingungen reagiert.

Fazit: Von statischen LLMs zu Live-Datenagenten

Integration Crawlbase Mit LangChain wird Ihr LLM von einem statischen Responder in ein System verwandelt, das auf Echtzeitinformationen zugreifen und diese überprüfen kann.

Statt sich auf veraltetes Wissen oder Vermutungen zu verlassen, kann Ihr Agent Live-Inhalte abrufen, sich an Veränderungen anpassen und fundierte Antworten liefern.

Dieses Muster wird unerlässlich, sobald Ihre Anwendung auf aktuelle Daten angewiesen ist, seien es Nachrichten, Preisinformationen, Dokumentationen oder Wettbewerbsanalysen.

Erstellen Sie Crawlbase KontoGenerieren Sie Ihre Token und fügen Sie sie dem Projekt hinzu. Sie erhalten 1,000 kostenlose Anfragen, um echte Abfragen gegen eine echte Pipeline zu testen, bevor Sie sich festlegen.

Häufig gestellte Fragen

Wann sollte use_javascript wahr sein?

Verwenden Sie diese Methode, wenn die benötigten Inhalte nicht im ursprünglichen HTML-Code enthalten sind und clientseitig gerendert werden. Dies ist typisch für moderne Frontend-Frameworks wie React oder Websites, die Inhalte dynamisch nach dem Seitenaufruf laden.

In dieser Konfiguration wird das Modell durch die Systemaufforderung angeleitet, zu entscheiden, wann diese Funktion aktiviert werden soll. use_javascript=true, Crawlbase Wechselt automatisch zu Ihrem JavaScript-Token.

Was passiert, wenn eine Website Crawler blockiert?

Wenn eine Website das Crawling blockiert, Crawlbase Gibt einen Fehlercode ungleich 200 zurück pc_statusund Ihr Tool zeigt dies als lesbare Meldung an, anstatt stillschweigend einen Fehler zu melden.

Von dort aus kann der Agent sich anpassen. Er könnte dieselbe URL per JavaScript-Rendering aufrufen, auf eine andere Quelle umschalten oder seine Antwort basierend auf seinen Kenntnissen anpassen. Auf Produktebene empfiehlt es sich außerdem, Ausweichstrategien einzuplanen, beispielsweise Benutzer auf offizielle APIs zu verweisen oder Sonderfälle bei Bedarf manuell zu behandeln.

Wie kann ich das über eine Demo hinaus skalieren?

Sobald man über kleine, synchrone Anfragen hinausgeht, ist der einfachste Weg der Wechsel zu Crawlbase Enterprise CrawlerEs ist für asynchrone, umfangreiche Arbeitslasten konzipiert und passt direkt in Ihre bestehende Infrastruktur.

Sie müssen nichts neu aufbauen. Konfigurieren Sie einfach einen Webhook und Füge ein paar Parameter hinzu zu deinem aktuellen Crawling API Anfragen.

Ab diesem Zeitpunkt wird Ihre Pipeline asynchron. Ihr Agent löst Crawls aus, und Ihr System verarbeitet die Ergebnisse, sobald sie eintreffen. Crawlbase kümmert sich weiterhin um den Webzugriff, sodass Sie sich darauf konzentrieren können, Ihre Pipeline bei zunehmender Skalierung zuverlässiger zu gestalten.