Crawl4AI-Tutorial: Webcrawler für KI-Anwendungen mit Docker

Inhalt

Crawl4AI ist ein Open-Source-Webcrawler für KI-Anwendungen. Er rendert Seiten mit viel JavaScript und liefert sauberes Markdown, bereinigtes HTML, Seitenmetadaten und Links, die ein LLM direkt verarbeiten kann. Außerdem kann er selbst ein LLM aufrufen, um gezielt Informationen zu extrahieren. In diesem Tutorial bauen wir das Docker-Image von Crawl4AI, betreiben es als REST-API-Server und gehen einfache Crawls, die Nutzung aus Python, fortgeschrittene Parameter und die LLM-basierte Extraktion durch.

Moderne LLM-Anwendungen brauchen oft mehr als eine Verbindung zur OpenAI-API. In der Praxis sind aktuelle, spezifische Informationen nötig, die über die Trainingsdaten des Modells hinausgehen. Das ist die Idee hinter Retrieval Augmented Generation (RAG) (auf Englisch).

Denken Sie an einen Bot für Wettbewerbsanalysen, der die Websites der Konkurrenz beobachtet, an einen Rechercheassistenten mit Zugriff auf wissenschaftliche Veröffentlichungen oder an eine E-Commerce-KI, die Preise in mehreren Shops verfolgt. Der Zugriff auf die Daten ist dabei nur die halbe Miete. Sie brauchen die Daten auch in einem Format, das LLMs gut verarbeiten können.

Moderne Websites liefern ihre Inhalte kaum noch als einfaches HTML aus. Sie laden Inhalte per JavaScript nach dem ersten Seitenaufbau nach, einfache HTTP-Anfragen reichen also nicht. Sie brauchen einen Crawler, der JavaScript ausführt und wartet, bis die Inhalte geladen sind, so wie ein echter Browser. In einem Onlineshop erscheinen Produktpreise zum Beispiel oft erst, nachdem JavaScript gelaufen ist, und auf einer Nachrichtenseite laden Artikel vielleicht erst beim Scrollen.

Crawl4AI hat zwei Vorteile, die für KI-Anwendungen zählen. Erstens verarbeitet es dank asynchroner Verarbeitung viele Anfragen gleichzeitig. Wenn Ihre Anwendung Hunderte Seiten schnell analysieren muss, macht diese Nebenläufigkeit bei der Performance viel aus.

Zweitens ist Crawl4AI für die Arbeit mit LLMs gebaut, sowohl beim Format der Ausgabe als auch darin, dass es KI zur Verbesserung der Extraktion nutzen kann. Statt sich mit aufwendiger HTML-Bereinigung oder fragilen Parsing-Regeln herumzuschlagen, bekommen Sie saubere, strukturierte Daten, die direkt in ein LLM gehen können.

Da Crawl4AI Open Source ist, können Sie den Code einsehen, an Ihre Anforderungen anpassen und Ihre Infrastruktur nach Bedarf skalieren, ohne die Grenzen proprietärer Werkzeuge. (Eine weitere Option beschreibt unsere Anleitung zum Crawlen von Websites für LLMs mit Firecrawl (auf Englisch).)

In dieser Anleitung richten wir Crawl4AI mit Docker ein. Die Docker-Variante von Crawl4AI startet einen Webserver, der mehrere Crawl-Anfragen gleichzeitig bearbeitet. Außerdem stellt sie eine REST-API zum Crawlen bereit, die sich in praktisch jede Anwendung einbinden lässt.

Das Docker-Image von Crawl4AI bauen

Zum Zeitpunkt des Schreibens ist Crawl4AI bei Version 0.3.73. Die Version hat erst kürzlich die vollständige API und Docker-Unterstützung eingeführt, inklusive offizieller Docker-Container, allerdings nur für arm64-CPUs.

Da Sie Crawl4AI sehr wahrscheinlich auf einem x86-Server betreiben wollen, müssen wir das Image selbst bauen.

1. Klonen Sie das Repository auf Ihren Rechner:

   1 git clone https://github.com/unclecode/crawl4ai.git
   

2. Wechseln Sie in das geklonte Repository:

   1 cd crawl4ai
   

3. Öffnen Sie die Datei main.py und entfernen Sie diese Zeile:

   1 app.mount("/mkdocs", StaticFiles(directory="site", html=True), name="mkdocs")
   

   Diese Zeile bindet die Dokumentation von Crawl4AI ein und liefert sie über den Webserver aus. Wir brauchen sie nicht, und sie würde einen zweiten Build-Schritt erfordern, den wir vorerst vermeiden wollen.

   Hinweis: Das kann sich künftig ändern. Wenn Sie die Zeile nicht finden, ist das kein Problem. Machen Sie einfach mit den nächsten Schritten weiter.

4. Bauen Sie jetzt mit diesem Befehl das Docker-Image:

   1docker build -f Dockerfile -t pondhouse/crawl4ai:beta-1 --build-arg INSTALL_TYPE=all .
   

   Hinweis: Statt INSTALL_TYPE auf all zu setzen, können Sie auch basic verwenden. Die volle Version brauchen Sie für die KI-gestützte Extraktion. Wenn Sie nur crawlen wollen, ohne KI-Extraktion, reicht die Basisversion.

So nutzen Sie die API von Crawl4AI

Das Docker-Image ist gebaut. Jetzt starten wir es und sehen uns an, wie man es benutzt.

1docker run -p 11235:11235 \
2-e OPENAI_API_KEY=<your-openai-api-key> \
3-e MAX_CONCURRENT_TASKS=5 \
4pondhouse/crawl4ai:beta-1

• OPENAI_API_KEY: Ihr OpenAI-API-Schlüssel. Wir brauchen ihn später für die KI-Extraktion.

  Hinweis: Crawl4AI verbindet sich über litellm mit LLMs, Sie können also die meisten Provider verwenden, die liteLLM anbietet. Ändern Sie dazu einfach den Parameter provider in den unten beschriebenen Anfragen.

• MAX_CONCURRENT_TASKS: die maximale Zahl gleichzeitiger Aufgaben, die der Crawler bearbeitet. Passen Sie den Wert an die Leistung Ihres Servers an.

Mehr brauchen wir nicht, um Crawl4AI zu betreiben. Die Beispiele unten verwenden einfache curl-Befehle, Sie können aber jeden REST-Client nutzen.

Ein einfacher Web-Crawl

Zuerst ein einfacher Crawl:

1curl -X POST 'http://127.0.0.1:11235/crawl' \
2-H 'Content-Type: application/json' \
3-d '{
4  "urls": "https://pondhouse-data.com"
5}'

Das Ergebnis sieht so aus:

1{ "task_id": "377fd003-2cd2-49bf-9f18-ee843ca21179" }

Wir bekommen das Crawl-Ergebnis nicht direkt, weil Crawl4AI asynchron crawlt. (Die asynchrone Verarbeitung vieler Anfragen gehört zu seinen besten Funktionen.) Zurück kommt die ID der Crawl-Aufgabe.

Jetzt müssen wir warten, bis der Crawl fertig ist. Dazu rufen wir wiederholt diesen Endpunkt auf:

1curl 'http://127.0.0.1:11235/task/<task_id_from_above>'

Die Antwort ist ein riesiges JSON-Objekt, uns interessiert aber vor allem das Feld status.

Um bei curl und Bash zu bleiben, lesen wir den Status mit jq aus:

1curl 'http://127.0.0.1:11235/task/377fd003-2cd2-49bf-9f18-ee843ca21179' | jq .status

Sobald der Status completed ist, ist die Aufgabe erledigt, und die Antwort enthält auch die Crawl-Ergebnisse. Ein weiterer API-Aufruf ist nicht nötig.

Die Ergebnisse stehen im Feld result, das vier interessante Eigenschaften hat:

1. result.cleaned_html enthält eine bereinigte HTML-Version der Seite:

   1 curl 'http://127.0.0.1:11235/task/<task-id>' | jq .result.cleaned_html
   

2. result.markdown enthält eine Markdown-Version der Seite. Für die meisten KI-Anwendungsfälle ist das das bessere Format, denn die HTML-Tags aus der vorigen Variante brauchen Sie meist nicht.

   1 curl 'http://127.0.0.1:11235/task/<task-id>' | jq .result.markdown
   

3. result.metadata enthält die Metadaten aus dem Seitenkopf, etwa Titel, Seitenbeschreibung oder og:image.

   1curl 'http://127.0.0.1:11235/task/<task-id>' | jq .result.metadata
   

   Das Ergebnis sieht so aus:

   1{
   2  "title": "Pondhouse Data - Customized AI Solutions for your business",
   3  "description": "Find relevant information faster than ever!",
   4  "keywords": null,
   5  "author": null,
   6  "og:title": "Pondhouse AI - Customized AI Solutions for your business",
   7  "og:description": "Find relevant information faster than ever!",
   8  "og:image": "https://www.pondhouse-data.com/pondhouse-data-header.png",
   9  "twitter:card": "summary_large_image",
   10  "twitter:site": "@techscienceandy",
   11  "twitter:title": "Pondhouse AI - Customized AI Solutions for your business",
   12  "twitter:description": "Find relevant information faster than ever!",
   13  "twitter:image": "https://www.pondhouse-data.com/pondhouse-data-header.png"
   14}
   

4. result.links ist besonders interessant, denn Crawl4AI kann einiges mit Links anfangen. Vor allem extrahiert es alle internen und externen Links der Seite und ordnet sie entsprechend zu. Die Linkanalyse sprengt den Rahmen dieses Beitrags, Crawl4AI hat dazu aber eine gute Anleitung in der Dokumentation.

   1curl 'http://127.0.0.1:11235/task/<task-id>' | jq .result.links
   

Die API von Crawl4AI aus Python nutzen

Der Vollständigkeit halber zeigen wir hier, wie Sie die Anfragen von oben in Python mit der Bibliothek requests stellen:

1import time
2
3import requests
4
5timeout = 120  # Sekunden
6
7request_data = {
8    "urls": "https://pondhouse-data.com"
9}
10response = requests.post("http://127.0.0.1:11235/crawl", json=request_data)
11task_id = response.json()["task_id"]
12
13start_time = time.time()
14while True:
15    # Auf Timeout prüfen
16    if time.time() - start_time > timeout:
17        raise TimeoutError(f"Task {task_id} timeout")
18
19    result = requests.get(f"http://127.0.0.1:11235/task/{task_id}")
20    status = result.json()
21
22    if status["status"] == "completed":
23        break
24
25    time.sleep(2)

Fortgeschrittene Parameter der Crawl4AI-API

Einen einfachen Crawl zu starten ist leicht, es gibt aber eine Reihe von Parametern, die Sie setzen können:

1    "urls": "<your-url>",
2    "crawler_params": {
3        # Browser-Konfiguration
4        "headless": True,                    # Im Headless-Modus laufen
5        "browser_type": "chromium",          # chromium/firefox/webkit
6        "user_agent": "custom-agent",        # Eigener User-Agent
7        "proxy": "http://proxy:8080",        # Proxy-Konfiguration
8
9        # Performance und Verhalten
10        "page_timeout": 30000,               # Timeout für das Laden der Seite (ms)
11        "verbose": True,                     # Ausführliches Logging aktivieren
12
13        # Schutz vor Bot-Erkennung
14        "simulate_user": True,               # Menschliches Verhalten simulieren
15        "magic": True,                       # Erweiterter Schutz vor Erkennung
16        "override_navigator": True,          # Navigator-Eigenschaften überschreiben
17
18        # Session-Verwaltung
19        "user_data_dir": "./browser-data",   # Speicherort des Browserprofils
20        "use_managed_browser": True,         # Persistenten Browser verwenden
21    }

Die meisten dieser Parameter erklären sich selbst, die letzten beiden brauchen aber eine Erklärung. Mit der Session-Verwaltung von Crawl4AI behalten Sie den Zustand über mehrere Anfragen hinweg und können komplexe Crawls über mehrere Seiten abwickeln, was besonders bei dynamischen Websites hilft.

Mehr dazu auf diesen beiden Seiten der Dokumentation:

• Session-Verwaltung: hier
• Umgang mit dynamischen Inhalten: hier

Daten mit der LLM-Extraktion von Crawl4AI auslesen

Bisher haben wir einfache Crawls ausgeführt. Jetzt nutzen wir die KI-Extraktion von Crawl4AI.

Angenommen, wir wollen Websites crawlen und dabei ganz bestimmte Informationen finden, etwa wem ein Unternehmen gehört.

---

Kurz bevor es weitergeht ...

Sie möchten zuverlässige KI-Agenten-Systeme bauen?

Wir haben auf Basis aktueller Forschung einen ausführlichen Leitfaden (auf Englisch) erstellt, wie Sie robuste KI-Agenten-Systeme bauen, die auch im produktiven Betrieb funktionieren. Der Leitfaden behandelt:

• die 14 systematischen Fehlerquellen in Multi-Agenten-Systemen
• belegte Best Practices für das Design von Agenten
• strukturierte Kommunikationsprotokolle und Prüfmechanismen

---

Mit der folgenden Anfrage ruft Crawl4AI ein LLM auf, das diese Information automatisch extrahiert:

1curl -X POST 'http://127.0.0.1:11235/crawl' \
2-H 'Content-Type: application/json' \
3-d '{
4  "urls": "https://pondhouse-data.com",
5  "extraction_config": {
6    "type": "llm",
7    "params": {
8      "provider": "openai/gpt-4o",
9      "api_token": "<your-openai-api-token>",
10      "instruction": "From the provided homepage data, extract the owners of the company."
11    }
12  }
13}'

Die extrahierten Ergebnisse stehen im Feld result.extracted_content. Es ist JSON-kodiert, deshalb dekodieren wir es mit dem fromjson-Filter von jq:

1curl 'http://127.0.0.1:11235/task/<task-id>' | jq '.result.extracted_content | fromjson'

1[
2  {
3    "index": 0,
4    "tags": ["owners"],
5    "content": ["Sascha Gstir", "Andreas Nigg"],
6    "error": false
7  }
8]

Das LLM hat beide Eigentümer des Unternehmens richtig zurückgegeben, und die ganze Pipeline lief mit nur zwei API-Aufrufen.

Andere LLM-Provider mit Crawl4AI verwenden

Wenn Sie einen anderen LLM-Provider wie Azure OpenAI verwenden wollen, hilft die Provider-Dokumentation von liteLLM, denn Crawl4AI nutzt intern liteLLM. Crawl4AI reicht api_token als API-Schlüssel an liteLLM weiter, setzen Sie also Ihren Azure-OpenAI-Schlüssel ein. liteLLM braucht außerdem Ihren Endpunkt und die API-Version, die Sie beim Start des Containers über die Umgebungsvariablen AZURE_API_BASE und AZURE_API_VERSION setzen. Der Teil nach azure/ ist der Name Ihres Deployments.

Eine Beispielanfrage mit Azure OpenAI:

1curl -X POST 'http://127.0.0.1:11235/crawl' \
2-H 'Content-Type: application/json' \
3-d '{
4  "urls": "https://pondhouse-data.com",
5  "extraction_config": {
6    "type": "llm",
7    "params": {
8      "provider": "azure/gpt-4o",
9      "api_token": "<your-azure-openai-api-key>",
10      "instruction": "From the provided homepage data, extract the owners of the company."
11    }
12  }
13}'

Dieselbe Art der LLM-Extraktion funktioniert auch mit PDFs und gescannten Dokumenten. Wie das mit einem Open-Source-Vision-Modell geht, zeigen wir in Dokumentenextraktion mit LLMs: Daten aus PDFs per KI auslesen.

Wenn Sie Webinhalte oder Dokumente für eine KI-Anwendung in Ihrem Unternehmen aufbereiten wollen, unterstützen wir Sie gern.

Weiterlesen

• Advanced RAG: Late Chunking (auf Englisch)
• DSPy: Prompts automatisch optimieren und erstellen (auf Englisch)
• Kostenlose Open-Source-Alternative zu ChatGPT: LibreChat
• LLM-Observability mit Langfuse
• RAGFlow: eine Open-Source-RAG-Engine für Ihre gecrawlten Dokumente

Über den Autor

Andreas Nigg

Mitgründer, Pondhouse Data

Andreas entwickelt seit mehr als acht Jahren Datenanwendungen. Bei Pondhouse Data konzipiert und baut er KI-Systeme und integriert sie in komplexe, gewachsene Unternehmensumgebungen.

Sprechen Sie mit Andreas über Ihr ProjektAuf LinkedIn folgen