Les clés publiques ne fonctionneront pas. Les clés qui commencent par
pk_ sont destinées aux widgets du navigateur et sont rejetées par le chargeur. En savoir plus sur
Private Keys.
---
## Utiliser EnconvertLoader
Le chargeur supporte deux modes.
### Percevoir quelques URL
Convertir les URL individuelles en `Document`s markdown :
```python
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 :
```python
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 :
```python
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](https://github.com/enconvert/langchain-enconvert)
- **Paquet** : [PyPI](https://pypi.org/project/langchain-enconvert)
- **Licence** : MIT
- **Documentation LangChain** : [python.langchain.com](https://python.langchain.com)
- **API sous-jacente** : [Introduction](/docs/introduction.md)
---
## Questions fréquemment posées
### Comment charger une seule URL dans un Document ?
```python
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 ?
```python
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 :
```python
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()` :
```python
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.