Chargeur LangChain pour Pages Web et Crawl de Sites#

Le chargeur EnConvert pour LangChain convertit les pages web et les sites entiers en LangChain Documents. Percevez les URL individuelles en markdown ou parcourez un site entier et retournez un Document par chunk prêt pour RAG. Chaque rendu de page porte un score render_quality (0,0–1,0) dans ses métadonnées, de sorte qu'une page bloquée ou vide est signalée plutôt que d'être silencieusement confiée.

Installation#

pip install langchain-enconvert

Ajoutez votre clé API#

Le chargeur nécessite une accréditation : Clé API EnConvert.

from langchain_enconvert import EnconvertLoader

loader = EnconvertLoader(api_key="sk_...")
# Ou définissez $ENCONVERT_API_KEY et omettez le paramètre
loader = EnconvertLoader()

Générez une clé API privée dans le tableau de bord. Les clés privées commencent par sk_. Les clés publiques pk_ sont rejetées.

Utiliser EnconvertLoader#

Le chargeur supporte deux modes.

Percevoir quelques URL#

Convertir les URL individuelles en Documents markdown :

from langchain_enconvert import EnconvertLoader

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

Les métadonnées de chaque Document portent : - source : l'URL - render_quality : un nombre de 0,0 (bloqué/vide) à 1,0 (rendu propre)

Parcourir un site en chunks#

Parcourez un site entier et retournez un Document par chunk de contenu, prêt pour RAG :

from langchain_enconvert import EnconvertLoader

loader = EnconvertLoader(
    ingest_url="https://docs.example.com",
    mode="sitemap",  # ou "crawl" ou "hybrid"
    max_pages=100
)
docs = loader.load()  # Bloque jusqu'à l'achèvement du crawl

Les métadonnées de chaque Document portent l'URL source propre au chunk, le titre et le contexte de la section.

Le chargeur interroge le travail d'ingestion jusqu'à l'achèvement, donc .load() est synchrone. Pour du vrai async, utilisez .lazy_load() pour itérer un Document à la fois.

Construire un pipeline RAG#

Chaînez le chargeur dans un splitter de texte et un magasin vectoriel :

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

# Charger et diviser
loader = EnconvertLoader(ingest_url="https://docs.example.com", mode="sitemap")
docs = loader.load()

# Incorporer et indexer
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
chunks = splitter.split_documents(docs)

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

# Requête
retriever = vectorstore.as_retriever()
relevant = retriever.invoke("Comment installer ceci ?")

Dépannage#

raise ValueError("Provide either urls or ingest_url, but not both") Vous avez transmis à la fois urls= et ingest_url= au chargeur. Choisissez un : percevoir les URL individuelles ou parcourir un site. Transmettre aucun lève aussi une erreur.

AuthenticationError: 401 Unauthorized La clé API est incorrecte ou manquante. Vérifiez que vous avez défini api_key= ou la variable d'environnement $ENCONVERT_API_KEY sur une clé privée (commence par sk_). Les clés publiques sont rejetées immédiatement.

Le temps de chargement semble très long. Les crawls de sites sont asynchrones. Le chargeur interroge jusqu'à l'achèvement du travail, ce qui peut prendre plusieurs minutes sur un grand site. Pour une UX réactive, utilisez l'API async (await loader.aload() dans un contexte async) ou interrogez directement l'état du travail via /v2/ingest/{job_id}.

render_quality est très bas pour les pages que je m'attendais à lire correctement. Un score bas (< 0,5) signifie que la page est bloquée, vide ou a du JavaScript lourd qui n'a pas été rendu à temps. Vérifiez l'URL source brute dans un navigateur pour voir ce que la page livre réellement. S'il s'agit d'une application mono-page, un deuxième rendu pourrait réussir ; s'il est bloqué, il n'y a pas de retry.

Source et liens#

• Source : enconvert/langchain-enconvert
• Paquet : PyPI
• Licence : MIT
• Documentation LangChain : python.langchain.com
• API sous-jacente : Introduction

Questions fréquemment posées#

Comment charger une seule URL dans un Document ?#

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

Le contenu de chaque Document est le markdown de la page, et les métadonnées portent l'URL source et le score render_quality.

Comment parcourir et indexer un site entier ?#

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

Le chargeur bloque jusqu'à l'achèvement du crawl, puis retourne un Document par chunk. Utilisez mode="crawl" pour le crawling HTTP, "sitemap" pour l'analyse du sitemap, ou "hybrid" pour les deux.

Comment vérifier la render_quality d'une page ?#

Les métadonnées de chaque Document incluent render_quality, un score de 0,0 à 1,0. Un score bas signifie que la page était bloquée ou vide. Branchez avant d'indexer :

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

Puis-je transmettre les Documents un à la fois ?#

Oui, utilisez .lazy_load() :

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

Que faire si j'ai besoin de parcourir de nombreux sites ?#

Créez un chargeur par site et appelez .load() séquentiellement, ou utilisez .aload() dans un contexte async pour distribuer les crawls en parallèle.