Effizientes Crawlen von Dokumentationsseiten mit Olostep

Das Crawlen von Webseiten bezeichnet den automatisierten Prozess, bei dem Webseiten besucht, Links verfolgt und Inhalte strukturiert gesammelt werden. Diese Methode wird häufig eingesetzt, um umfangreiche Informationen von Dokumentationsseiten, Artikeln, Wissensdatenbanken und anderen Online-Ressourcen zu erfassen.

Das Crawlen einer gesamten Webseite und die anschließende Umwandlung des Inhalts in ein Format, das von einem KI-Agenten genutzt werden kann, gestaltet sich jedoch als komplexer als zunächst angenommen. Dokumentationsseiten enthalten oft verschachtelte Seiten, wiederholte Navigationslinks, Standardinhalte und inkonsistente Seitenstrukturen. Darüber hinaus muss der extrahierte Inhalt gereinigt, organisiert und in einer Weise gespeichert werden, die für nachgelagerte KI-Arbeitsabläufe wie Abruf, Frage-Antwort-Systeme oder agentenbasierte Systeme nützlich ist.

In diesem Leitfaden erfahren Sie, warum Olostep anstelle von Scrapy oder Selenium verwendet werden sollte, wie Sie alles für Ihr Web-Crawling-Projekt einrichten, ein einfaches Crawling-Skript zum Scrapen einer Dokumentationswebsite schreiben und schließlich ein Frontend mit Gradio erstellen, damit jeder einen Link und andere Parameter angeben kann, um Webseiten zu crawlen.

Olostep statt Scrapy oder Selenium wählen

Scrapy ist zwar leistungsstark, wurde jedoch als vollständiges Scraping-Framework entwickelt. Dies ist nützlich, wenn Sie tiefgehende Kontrolle wünschen, bedeutet jedoch auch mehr Einrichtung und einen höheren Ingenieuraufwand.

Selenium ist besser bekannt für die Automatisierung von Browsern. Es ist nützlich für die Interaktion mit JavaScript-lastigen Seiten, jedoch nicht speziell für den Dokumentations-Crawling-Workflow konzipiert.

Mit Olostep hingegen wird der Ansatz viel direkter: Suchen, Crawlen, Scrapen und Strukturieren von Webdaten über eine einzige Anwendungsprogrammierschnittstelle (API), die LLM-freundliche Ausgaben wie Markdown, Text, HTML und strukturiertes JSON unterstützt. Das bedeutet, dass Sie nicht manuell Teile für Entdeckung, Extraktion, Formatierung und nachgelagerte KI-Nutzung zusammenfügen müssen.

Für Dokumentationsseiten kann dies einen deutlich schnelleren Weg von der URL zum nutzbaren Inhalt bieten, da Sie weniger Zeit mit dem Aufbau des Crawling-Stacks verbringen und mehr Zeit mit den Inhalten, die Sie tatsächlich benötigen, arbeiten. Wenn Sie mehr über nützliche Tools für die Automatisierung erfahren möchten, könnten Sie sich auch einige kostenlose KI-Tools zur Dokumentationserstellung ansehen.

Installation der Pakete und Einrichtung des API-Schlüssels

Zuerst installieren Sie die in diesem Projekt verwendeten Python-Pakete. Das offizielle Olostep-Software-Entwicklungskit (SDK) erfordert Python 3.11 oder höher.

pip install olostep python-dotenv tqdm

Diese Pakete übernehmen die Hauptbestandteile des Workflows:

• olostep verbindet Ihr Skript mit der Olostep-API.
• python-dotenv lädt Ihren API-Schlüssel aus einer .env-Datei.
• tqdm fügt eine Fortschrittsanzeige hinzu, damit Sie die gespeicherten Seiten verfolgen können.

Erstellen Sie anschließend ein kostenloses Olostep-Konto, öffnen Sie das Dashboard und generieren Sie einen API-Schlüssel auf der Seite für API-Schlüssel. Die offiziellen Dokumentationen und Integrationen von Olostep verweisen die Benutzer auf das Dashboard zur Einrichtung des API-Schlüssels.

Erstellen Sie dann eine .env-Datei in Ihrem Projektordner:

OLOSTEP_API_KEY=your_real_api_key_here

Dies hält Ihren API-Schlüssel von Ihrem Python-Code getrennt, was eine sauberere und sicherere Methode zur Verwaltung von Anmeldeinformationen darstellt.

Erstellung des Crawlerskripts

In diesem Teil des Projekts werden wir das Python-Skript erstellen, das eine Dokumentationswebsite crawlt, jede Seite im Markdown-Format extrahiert, den Inhalt bereinigt und lokal als einzelne Dateien speichert. Wir werden den Projektordner erstellen, eine Python-Datei hinzufügen und dann den Code Schritt für Schritt schreiben, sodass er leicht zu folgen und zu testen ist.

Zuerst erstellen Sie einen Projektordner für Ihren Crawler. Innerhalb dieses Ordners erstellen Sie eine neue Python-Datei mit dem Namen crawl_docs_with_olostep.py.

Jetzt fügen wir den Code schrittweise zu dieser Datei hinzu. Dies erleichtert das Verständnis, was jeder Teil des Skripts tut und wie der gesamte Crawler zusammenarbeitet.

Festlegung der Crawleinstellungen

Beginnen Sie damit, die erforderlichen Bibliotheken zu importieren. Definieren Sie dann die Haupt-Crawleinstellungen, wie die Start-URL, die Crawltiefe, das Seitenlimit sowie Ein- und Ausschlussregeln und den Ausgabeverzeichnis, in dem die Markdown-Dateien gespeichert werden. Diese Werte steuern, wie viel der Dokumentationsseite gecrawlt wird und wo die Ergebnisse gespeichert werden.

import os
import re
from pathlib import Path
from urllib.parse import urlparse
from dotenv import load_dotenv
from tqdm import tqdm
from olostep import Olostep
START_URL = "https://docs.olostep.com/"
MAX_PAGES = 10
MAX_DEPTH = 1
INCLUDE_URLS = [
 "/**"
]
EXCLUDE_URLS = []
OUTPUT_DIR = Path("olostep_docs_output")

Erstellung einer Hilfsfunktion zur Generierung sicherer Dateinamen

Jede gecrawlte Seite muss als eigene Markdown-Datei gespeichert werden. Dazu benötigen wir eine Hilfsfunktion, die eine URL in einen sauberen und dateisystemfreundlichen Dateinamen umwandelt. Dies vermeidet Probleme mit Schrägstrichen, Symbolen und anderen Zeichen, die in Dateinamen nicht gut funktionieren.

def slugify_url(url: str) -> str:
 parsed = urlparse(url)
 path = parsed.path.strip("/")
 if not path:
 path = "index"
 filename = re.sub(r"[^a-zA-Z0-9/_-]+", "-", path)
 filename = filename.replace("/", "__").strip("-_")
 return f"{filename or 'page'}.md"

Erstellung einer Hilfsfunktion zum Speichern von Markdown-Dateien

Fügen Sie nun Hilfsfunktionen hinzu, um den extrahierten Inhalt vor dem Speichern zu verarbeiten.

Die erste Funktion bereinigt das Markdown, indem sie überflüssige Schnittstellentexte, wiederholte Leerzeilen und unerwünschte Seitenelemente wie Feedbackaufforderungen entfernt. Dies hilft, die gespeicherten Dateien auf den tatsächlichen Dokumentationsinhalt zu konzentrieren.

def clean_markdown(markdown: str) -> str:
 text = markdown.replace("\r\n", "\n").strip()
 text = re.sub(r"\[\s*\u200b?\s*\]\(#.*?\)", "", text, flags=re.DOTALL)
 lines = [line.rstrip() for line in text.splitlines()]
 start_index = 0
 for index in range(len(lines) - 1):
 title = lines[index].strip()
 underline = lines[index + 1].strip()
 if title and underline and set(underline) == {"="}:
 start_index = index
 break
 else:
 for index, line in enumerate(lines):
 if line.lstrip().startswith("# "):
 start_index = index
 break
 lines = lines[start_index:]
 for index, line in enumerate(lines):
 if line.strip() == "War diese Seite hilfreich?":
 lines = lines[:index]
 break
 cleaned_lines: list[str] = []
 for line in lines:
 stripped = line.strip()
 if stripped in {"Seite kopieren", "JaNein", "⌘I"}:
 continue
 if not stripped and cleaned_lines and not cleaned_lines[-1]:
 continue
 cleaned_lines.append(line)
 return "\n".join(cleaned_lines).strip()

Die zweite Funktion speichert das bereinigte Markdown im Ausgabeverzeichnis und fügt die Quell-URL oben in die Datei ein. Es gibt auch eine kleine Hilfsfunktion, um alte Markdown-Dateien zu löschen, bevor ein neues Crawlergebnis gespeichert wird.

def save_markdown(output_dir: Path, url: str, markdown: str) -> None:
 output_dir.mkdir(parents=True, exist_ok=True)
 filepath = output_dir / slugify_url(url)
 content = f"""---
source_url: {url}
---
{markdown}
"""
 filepath.write_text(content, encoding="utf-8")

Es gibt auch eine kleine Hilfsfunktion, um alte Markdown-Dateien zu löschen, bevor ein neues Crawlergebnis gespeichert wird.

def clear_output_dir(output_dir: Path) -> None:
 if not output_dir.exists():
 return
 for filepath in output_dir.glob("*.md"):
 filepath.unlink()

Erstellung der Hauptlogik des Crawlers

Dies ist der Hauptteil des Skripts. Es lädt den API-Schlüssel aus der .env-Datei, erstellt den Olostep-Client, startet das Crawlen, wartet, bis es abgeschlossen ist, ruft jede gecrawlte Seite als Markdown ab, bereinigt den Inhalt und speichert ihn lokal.

Dieser Abschnitt verbindet alles und verwandelt die einzelnen Hilfsfunktionen in einen funktionierenden Dokumentations-Crawler.

def main() -> None:
 load_dotenv()
 api_key = os.getenv("OLOSTEP_API_KEY")
 if not api_key:
 raise RuntimeError("Fehlender OLOSTEP_API_KEY in Ihrer .env-Datei.")
 client = Olostep(api_key=api_key)
 crawl = client.crawls.create(
 start_url=START_URL,
 max_pages=MAX_PAGES,
 max_depth=MAX_DEPTH,
 include_urls=INCLUDE_URLS,
 exclude_urls=EXCLUDE_URLS,
 include_external=False,
 include_subdomain=False,
 follow_robots_txt=True,
 )
 print(f"Crawl gestartet: {crawl.id}")
 crawl.wait_till_done(check_every_n_secs=5)
 pages = list(crawl.pages())
 clear_output_dir(OUTPUT_DIR)
 for page in tqdm(pages, desc="Seiten speichern"):
 try:
 content = page.retrieve(["markdown"])
 markdown = getattr(content, "markdown_content", None)
 if markdown:
 save_markdown(OUTPUT_DIR, page.url, clean_markdown(markdown))
 except Exception as exc:
 print(f"Fehler beim Abrufen von {page.url}: {exc}")
 print(f"Fertig. Dateien gespeichert in: {OUTPUT_DIR.resolve()}")
if __name__ == "__main__":
 main()

Hinweis: Das vollständige Skript ist hier verfügbar: kingabzpro/web-crawl-olostep, ein Web-Crawler und eine Starter-Webanwendung, die mit Olostep erstellt wurde.

Testen des Web-Crawling-Skripts

Sobald das Skript fertig ist, führen Sie es von Ihrem Terminal aus:

python crawl_docs_with_olostep.py

Während das Skript läuft, sehen Sie, wie der Crawler die Seiten verarbeitet und sie nacheinander als Markdown-Dateien in Ihrem Ausgabeverzeichnis speichert.

Nach Abschluss des Crawls öffnen Sie die gespeicherten Dateien, um den extrahierten Inhalt zu überprüfen. Sie sollten saubere, lesbare Markdown-Versionen der Dokumentationsseiten sehen.

Zu diesem Zeitpunkt ist Ihr Dokumentationsinhalt bereit für die Verwendung in KI-Workflows wie Suche, Abruf oder agentenbasierte Systeme. Wenn Sie an der Automatisierung der explorativen Datenanalyse interessiert sind, könnten Sie auch effiziente Python-Skripte zur Automatisierung in Betracht ziehen.

Erstellung der Olostep-Web-Crawling-Webanwendung

In diesem Teil des Projekts werden wir eine einfache Webanwendung auf Basis des Crawlerskripts erstellen. Anstatt die Python-Datei jedes Mal zu bearbeiten, bietet diese Anwendung eine einfachere Möglichkeit, eine Dokumentations-URL einzugeben, Crawleinstellungen auszuwählen, den Crawl auszuführen und die gespeicherten Markdown-Dateien an einem Ort anzuzeigen.

Der Frontend-Code für diese Anwendung ist in app.py im Repository verfügbar: web-crawl-olostep/app.py.

Diese Anwendung bietet einige nützliche Funktionen:

• Ermöglicht die Eingabe einer Start-URL für den Crawl.
• Ermöglicht die Festlegung der maximalen Anzahl zu crawlender Seiten.
• Ermöglicht die Steuerung der Crawltiefe.
• Ermöglicht das Hinzufügen von Ein- und Ausschluss-URL-Mustern.
• Führt den Backend-Crawler direkt über die Benutzeroberfläche aus.
• Speichert die gecrawlten Seiten in einem Ordner basierend auf der URL.
• Zeigt alle gespeicherten Markdown-Dateien in einem Dropdown-Menü an.
• Vorschau jeder Markdown-Datei direkt in der Anwendung.
• Ermöglicht das Löschen vorheriger Crawlergebnisse mit einem einzigen Klick.

Um die Anwendung zu starten, führen Sie aus:

python app.py

Danach startet Gradio einen lokalen Webserver und stellt einen Link wie diesen zur Verfügung:

• Running on local URL: http://127.0.0.1:7860
• Um einen öffentlichen Link zu erstellen, setzen Sie share=True in launch().

Sobald die Anwendung läuft, öffnen Sie die lokale URL in Ihrem Browser. In unserem Beispiel haben wir der Anwendung die Claude Code-Dokumentations-URL gegeben und sie gebeten, 50 Seiten mit einer Tiefe von 5 zu crawlen.

Wenn Sie auf „Crawl ausführen“ klicken, übergibt die Anwendung Ihre Einstellungen an den Backend-Crawler und startet den Crawl. Im Terminal können Sie den Fortschritt verfolgen, während die Seiten nacheinander gecrawlt und gespeichert werden.

Nach Abschluss des Crawls enthält der Ausgabeverzeichnis die gespeicherten Markdown-Dateien. In diesem Beispiel würden Sie sehen, dass 50 Dateien hinzugefügt wurden.

Das Dropdown-Menü in der Anwendung wird dann automatisch aktualisiert, sodass Sie jede gespeicherte Datei öffnen und sie direkt in der Weboberfläche als korrekt formatiertes Markdown anzeigen können.

Dies macht den Crawler viel benutzerfreundlicher. Anstatt jedes Mal Werte im Code zu ändern, können Sie verschiedene Dokumentationsseiten und Crawleinstellungen über eine einfache Benutzeroberfläche testen. Das erleichtert auch das Teilen des Projekts mit anderen, die möglicherweise nicht direkt mit Python arbeiten möchten.

Fazit

Web-Crawling besteht nicht nur darin, Seiten von einer Website zu sammeln. Die eigentliche Herausforderung besteht darin, diesen Inhalt in saubere, strukturierte Dateien umzuwandeln, die ein KI-System tatsächlich nutzen kann. In diesem Projekt haben wir ein einfaches Python-Skript und eine Gradio-Anwendung verwendet, um diesen Prozess erheblich zu vereinfachen.

Ebenso wichtig ist, dass der Workflow schnell genug für den praktischen Einsatz ist. In unserem Beispiel dauerte das Crawlen von 50 Seiten mit einer Tiefe von 5 nur etwa 50 Sekunden, was zeigt, dass Sie Dokumentationsdaten schnell vorbereiten können, ohne eine umfangreiche Pipeline aufzubauen.

Dieses Setup kann auch über einen einmaligen Crawl hinausgehen. Sie können es so planen, dass es täglich mit Cron oder dem Task Scheduler ausgeführt wird und sogar nur die Seiten aktualisiert, die sich geändert haben. Dadurch bleibt Ihre Dokumentation aktuell, während nur eine geringe Anzahl von Credits verwendet wird.

Für Teams, die einen solchen Workflow benötigen, um wirtschaftlich sinnvoll zu sein, wurde Olostep mit diesem Ziel entwickelt. Es ist erheblich kostengünstiger als der Aufbau oder die Wartung einer internen Crawling-Lösung und mindestens 50 % günstiger als vergleichbare Alternativen auf dem Markt.

Mit wachsendem Bedarf sinken die Kosten pro Anfrage, was es zu einer praktischen Wahl für größere Dokumentationspipelines macht. Diese Kombination aus Zuverlässigkeit, Skalierbarkeit und starken wirtschaftlichen Kennzahlen ist der Grund, warum einige der am schnellsten wachsenden KI-nativen Startups auf Olostep setzen, um ihre Dateninfrastruktur zu unterstützen.

Abid Ali Awan (@1abidaliawan) ist ein zertifizierter Datenwissenschaftler, der es liebt, Maschinenlernmodelle zu entwickeln. Derzeit konzentriert er sich auf die Erstellung von Inhalten und das Schreiben technischer Blogs über Technologien im Bereich Maschinenlernen und Datenwissenschaft. Abid hat einen Master-Abschluss in Technologiemanagement und einen Bachelor-Abschluss in Telekommunikationsengineering. Sein Ziel ist es, ein KI-Produkt zu entwickeln, das mithilfe eines graphbasierten neuronalen Netzwerks für Studenten, die mit psychischen Erkrankungen kämpfen, hilfreich ist.

Erhalten Sie das kostenlose E-Book ‚KDnuggets Artificial Intelligence Pocket Dictionary‘ zusammen mit dem führenden Newsletter zu Datenwissenschaft, Maschinenlernen, KI und Analytik direkt in Ihr Postfach.

Durch das Abonnieren akzeptieren Sie die Datenschutzrichtlinie von KDnuggets.

„`

Bildquelle: ai-generated-gemini