LangChain Loader für Web-Seiten und Site-Crawling#

Der EnConvert Loader für LangChain verwandelt Web-Seiten und ganze Sites in LangChain Documents. Einzelne URLs zu Markdown erfassen oder eine ganze Site durchsuchen und ein Document pro RAG-bereitem Chunk zurückgeben. Jedes Seiten-Rendering trägt einen render_quality-Score (0,0–1,0) in seinen Metadaten, sodass eine blockierte oder leere Seite gekennzeichnet wird, anstatt stillschweigend vertraut zu werden.

Paket: langchain-enconvert · Quelle: enconvert/langchain-enconvert · Erfordert: langchain-core>=0.3 · Lizenz: MIT

Installation#

pip install langchain-enconvert

Fügen Sie Ihren API-Schlüssel hinzu#

Der Loader benötigt eine Anmeldedaten: EnConvert API Key.

from langchain_enconvert import EnconvertLoader

loader = EnconvertLoader(api_key="sk_...")
# Oder setzen Sie $ENCONVERT_API_KEY und lassen Sie den Parameter weg
loader = EnconvertLoader()

Generieren Sie einen privaten API-Schlüssel im Dashboard. Private Schlüssel beginnen mit sk_. Öffentliche pk_-Schlüssel werden abgelehnt.

Öffentliche Schlüssel funktionieren nicht. Schlüssel, die mit pk_ beginnen, sind für Browser-Widgets gedacht und werden vom Loader abgelehnt. Mehr erfahren Sie unter Private Keys.

EnconvertLoader verwenden#

Der Loader unterstützt zwei Modi.

Einige URLs erfassen#

URLs einzeln in Markdown Documents umwandeln:

from langchain_enconvert import EnconvertLoader

loader = EnconvertLoader(urls=["https://example.com", "https://example.com/pricing"])
docs = loader.load()

Die Metadaten jedes Document tragen: - source: die URL - render_quality: eine Zahl von 0,0 (blockiert/leer) bis 1,0 (sauberes Rendering)

Eine Site in Chunks durchsuchen#

Eine ganze Site durchsuchen und ein Document pro Inhalts-Chunk zurückgeben, bereit für RAG:

from langchain_enconvert import EnconvertLoader

loader = EnconvertLoader(
    ingest_url="https://docs.example.com",
    mode="sitemap",  # oder "crawl" oder "hybrid"
    max_pages=100
)
docs = loader.load()  # Blockiert bis zum Abschluss des Crawls

Die Metadaten jedes Document tragen die Chunk-eigene source-URL, Titel und Abschnitt-Kontext.

Der Loader fragt den Ingestion-Job bis zum Abschluss ab, also .load() ist synchron. Für echtes Async verwenden Sie .lazy_load(), um ein Document nach dem anderen zu iterieren.

Eine RAG-Pipeline bauen#

Den Loader in einen Text Splitter und einen Vector Store verketten:

from langchain_enconvert import EnconvertLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

# Laden und teilen
loader = EnconvertLoader(ingest_url="https://docs.example.com", mode="sitemap")
docs = loader.load()

# Einbetten und indexieren
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = splitter.split_documents(docs)

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)

# Abfragen
retriever = vectorstore.as_retriever()
relevant = retriever.invoke("Wie installiere ich das?")

Fehlerbehebung#

raise ValueError("Provide either urls or ingest_url, but not both") Sie übergaben sowohl urls= als auch ingest_url= an den Loader. Wählen Sie eine: einzelne URLs erfassen oder eine Site durchsuchen. Das Übergeben keiner wirft auch einen Fehler.

AuthenticationError: 401 Unauthorized Der API-Schlüssel ist falsch oder fehlt. Überprüfen Sie, dass Sie api_key= oder die $ENCONVERT_API_KEY-Umgebungsvariable auf einen privaten Schlüssel (beginnt mit sk_) setzen. Öffentliche Schlüssel werden sofort abgelehnt.

Die Ladezeit scheint sehr lang. Site-Crawls sind asynchron. Der Loader fragt, bis der Job fertig ist, was für eine große Site mehrere Minuten dauern kann. Verwenden Sie für eine reaktionsschnelle Benutzeroberfläche das async API (await loader.aload() in einem async-Kontext) oder fragen Sie den Job-Status direkt über /v2/ingest/{job_id} ab.

render_quality ist sehr niedrig für Seiten, die ich sauber zu lesen erwartet habe. Ein niedriger Score (< 0,5) bedeutet, die Seite ist blockiert, leer oder schweres JavaScript, das nicht rechtzeitig gerendert wurde. Überprüfen Sie die rohe source-URL in einem Browser, um zu sehen, was die Seite tatsächlich liefert. Ist es eine Single-Page App, könnte ein zweites Rendering erfolgreich sein; ist es blockiert, gibt es keinen Wiederversuch.

Quelle und Links#

Quelle: enconvert/langchain-enconvert
Paket: PyPI
Lizenz: MIT
LangChain-Dokumentation: python.langchain.com
Zugrunde liegende API: Introduction

Häufig gestellte Fragen#

Wie lade ich eine einzelne URL in ein Document?#

from langchain_enconvert import EnconvertLoader
loader = EnconvertLoader(urls=["https://example.com"])
docs = loader.load()

Der Inhalt jedes Document ist das Markdown der Seite, und Metadaten tragen die source-URL und render_quality-Score.

Wie durchsuche und indexiere ich eine ganze Site?#

loader = EnconvertLoader(ingest_url="https://docs.example.com", mode="sitemap", max_pages=100)
docs = loader.load()

Der Loader blockiert bis zum Abschluss des Crawls, gibt dann ein Document pro Chunk zurück. Verwenden Sie mode="crawl" für HTTP-Crawling, "sitemap" zum Sitemap-Parsen oder "hybrid" für beides.

Wie überprüfe ich die render_quality einer Seite?#

Die Metadaten jedes Document enthalten render_quality, ein Score von 0,0 bis 1,0. Ein niedriger Score bedeutet, die Seite war blockiert oder leer. Verzweigen Sie, bevor Sie indexieren:

for doc in docs:
    if doc.metadata.get('render_quality', 1.0) > 0.5:
        vectorstore.add_documents([doc])

Kann ich Documents streaming iterieren?#

Ja, verwenden Sie .lazy_load():

for doc in loader.lazy_load():
    print(doc.page_content[:100])

Was, wenn ich viele Sites durchsuchen muss?#

Erstellen Sie einen Loader pro Site und rufen Sie .load() nacheinander auf, oder verwenden Sie .aload() in einem async-Kontext, um Crawls parallel zu verteilen.

← Langflow LlamaIndex →

API Documentation