fix: add binary files via LFS only

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
 .idea/
 .env
-__pycache__/
+__pycache__/
+tests.py

chroma_db/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93417808fc00afc794b4c90d34635008d3120ef7768cbb920dc97a5d7f026032
+size 876544

chroma_db/d365f4bc-8099-45f4-bdc0-9c299960820d/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2679902f7ee9902bd54e85a1e4b822cccb4a163c0d49ae93b57d42d40edf49d0
+size 42360000

chroma_db/d365f4bc-8099-45f4-bdc0-9c299960820d/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f14d42069445548e1fceb9acb767255a21e1e9d11c021b2d5999d5cbf4d2b705
+size 100

chroma_db/d365f4bc-8099-45f4-bdc0-9c299960820d/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d23a36b9568bb6826f624d484e2f255a46e20e70a60792401044c7e37f93ccd
+size 40000

requirements.txt

@@ -8,4 +8,15 @@ pandas
 scipy
 plotly
 dotenv
-mistralai
+mistralai
+fastapi
+uvicorn
+pydantic
+aiohttp
+markdown
+lxml[html_clean]
+readability-lxml
+chromadb
+markdownify
+html2markdown
+smolagents

src/agent/mistral_agent.py

@@ -5,6 +5,8 @@ from mistralai import Mistral
 from src.agent.utils.tooling import generate_tools_json
 from src.agent.tools import (
     calculate_sum,
+    retrieve_knowledge,
+    visit_webpage,
 )
 
 load_dotenv()
@@ -14,10 +16,12 @@ class MistralAgent:
         self.api_key = os.getenv("MISTRAL_API_KEY")
         self.agent_id = os.getenv("AGENT_ID")
         self.client = Mistral(api_key=self.api_key)
-        self.model = "mistral-small"
+        self.model = "mistral-large"
         self.prompt = None
         self.names_to_functions = {
             "calculate_sum": calculate_sum,
+            "retrieve_knowledge": retrieve_knowledge,
+            "visit_webpage": visit_webpage,
         }
         self.tools = self.get_tools()
 
@@ -27,5 +31,7 @@ class MistralAgent:
         return generate_tools_json(
             [
                 calculate_sum,
+                retrieve_knowledge,
+                visit_webpage,
             ]
         ).get('tools')

src/agent/tools/__init__.py

@@ -1 +1,3 @@
-from .calculator import calculate_sum
+from .calculator import calculate_sum
+from .retrieve_knowledge import retrieve_knowledge
+from .visit_webpage import visit_webpage

src/agent/tools/retrieve_knowledge.py

@@ -0,0 +1,45 @@
+from src.agent.utils.tooling import tool
+
+def format_the(query, results):
+
+    if results ==  "No relevant data found in the knowledge database. Have you checked any webpages or use any tools? If so, please try to find more relevant data.":
+        return results
+    else:
+        formatted_text = f"# Knowledge for '{query}' \n\n"
+        formatted_text += f"Fetched {len(results['documents'])} relevant documents.\n\n"
+        try:
+            for i in range(len(results['documents'])):
+                formatted_text += f"## Document {i + 1} ---\n"
+                formatted_text += f"- Content: '''\n{results['documents'][i]}\n'''\n"
+                formatted_text += f"- Metadata: {results['metadatas'][i]}\n"
+                formatted_text += f"---\n\n"
+        except Exception as e:
+            return f"Error: Index out of range. Please check the results structure. {str(e)}"
+        return formatted_text
+
+@tool
+def retrieve_knowledge(query: str, n_results: int = 2) -> str:
+    """
+    Retrieves knowledge from a database with a provided query.
+    Args:
+        query (str): The query to search for in the vector store.
+        n_results (int, optional): The number of results to return. Default is 1.
+    """
+    try:
+        from src.agent.utils.vector_store import retrieve_from_database
+        distance_threshold = 0.4
+        results = retrieve_from_database(
+            query=query,
+            n_results=n_results,
+            distance_threshold=distance_threshold
+        )
+        results_formatted = format_the(query, results)
+        if results_formatted:
+            return results_formatted
+        else:
+            return "No relevant data found in the knowledge database. Have you checked any webpages or use any tools? If so, please try to find more relevant data."
+
+    except Exception as e:
+        print(f"Error retrieving knowledge: {e}")
+        return f"No relevant data found in the knowledge database. Have you checked any webpages or use any tools? If so, please try to find more relevant data."
+

src/agent/tools/visit_webpage.py

@@ -0,0 +1,58 @@
+from src.agent.utils.tooling import tool
+from src.agent.utils.vector_store import chunk_content, load_in_vector_db
+
+
+
+@tool
+def visit_webpage(url: str) -> str:
+    """
+    Visits a webpage at the given URL and reads its content as a markdown string.
+    This tool is useful for extracting information from web pages in a structured format after a search.
+    Args:
+        url (str): The URL of the webpage to visit.
+    """
+    try:
+        from src.web2llm.app.scraper import scrape_url
+        from src.web2llm.app.converter import html_to_markdown
+        import re
+        import requests
+        from markdownify import markdownify
+        from requests.exceptions import RequestException
+        from smolagents.utils import truncate_content
+        from urllib.parse import urlparse
+
+    except ImportError as e:
+        raise ImportError(
+            f"You must install packages `markdownify` and `requests` to run this tool: for instance run `pip install markdownify requests` : {e}"
+        ) from e
+
+    forbidden_domains = ["universetoday.com"]
+
+    parsed_url = urlparse(url)
+    domain = parsed_url.netloc
+
+    if domain in forbidden_domains:
+        return "This domain is forbidden and cannot be accessed, please try another one."
+
+    try:
+        # Web2LLM app
+        result = scrape_url(url, clean=True)
+        markdown_content = html_to_markdown(result["clean_html"])
+
+        load_in_vector_db(
+            markdown_content,
+            metadatas={
+                "title": result["title"],
+                "url": url,
+            }
+        )
+        return "The webpage has been successfully visited: content has been vectorized and stored in the knowledge base."
+
+    except requests.exceptions.Timeout:
+        return "The request timed out. Please try again later or check the URL."
+
+    except RequestException as e:
+        return f"Error fetching the webpage: {str(e)}"
+
+    except Exception as e:
+        return f"An unexpected error occurred: {str(e)}"

src/agent/utils/vector_store.py

@@ -0,0 +1,236 @@
+import os
+from dotenv import load_dotenv
+from mistralai import Mistral
+import numpy as np
+import time
+import chromadb
+from chromadb.config import Settings
+import json
+import hashlib
+
+load_dotenv()
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+COLLECTION_NAME = "webpages_collection"
+PERSIST_DIRECTORY = "./chroma_db"
+
+def vectorize(input_texts, batch_size=5):
+    """
+    Get the text embeddings for the given inputs using Mistral API.
+    """
+    try:
+        client = Mistral(api_key=MISTRAL_API_KEY)
+    except Exception as e:
+        print(f"Error initializing Mistral client: {e}")
+        return []
+
+    embeddings = []
+
+    for i in range(0, len(input_texts), batch_size):
+        batch = input_texts[i:i + batch_size]
+        while True:
+            try:
+                embeddings_batch_response = client.embeddings.create(
+                    model="mistral-embed",
+                    inputs=batch
+                )
+                time.sleep(1)
+                embeddings.extend([data.embedding for data in embeddings_batch_response.data])
+                break
+            except Exception as e:
+                if "rate limit exceeded" in str(e).lower():
+                    print("Rate limit exceeded. Retrying after 10 seconds...")
+                    time.sleep(10)
+                else:
+                    print(f"Error in embedding batch: {e}")
+                    raise
+
+    return embeddings
+
+
+def chunk_content(markdown_content, chunk_size=2048):
+    """
+    Vectorizes the given markdown content into chunks of specified size without cutting sentences.
+    """
+    def find_sentence_end(text, start):
+        """Find the nearest sentence end from the start index."""
+        punctuations = {'.', '!', '?'}
+        end = start
+        while end < len(text) and text[end] not in punctuations:
+            end += 1
+        while end < len(text) and text[end] in punctuations:
+            end += 1
+        while end > start and text[end - 1] not in punctuations:
+            end -= 1
+        return end
+
+    chunks = []
+    start = 0
+
+    while start < len(markdown_content):
+        end = min(start + chunk_size, len(markdown_content))
+        end = find_sentence_end(markdown_content, end)
+        chunks.append(markdown_content[start:end].strip())
+        start = end
+
+    return chunks
+
+
+def generate_chunk_id(chunk):
+    """Generate a unique ID for a chunk using SHA-256 hash."""
+    return hashlib.sha256(chunk.encode('utf-8')).hexdigest()
+
+
+def load_in_vector_db(markdown_content, metadatas=None, collection_name=COLLECTION_NAME):
+    """
+    Load the text embeddings into a ChromaDB collection for efficient similarity search.
+    """
+    try:
+        client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+    except Exception as e:
+        print(f"Error initializing ChromaDB client: {e}")
+        return
+
+    try:
+        if collection_name not in [col.name for col in client.list_collections()]:
+            collection = client.create_collection(collection_name)
+        else:
+            collection = client.get_collection(collection_name)
+    except Exception as e:
+        print(f"Error accessing collection: {e}")
+        return
+
+    try:
+        existing_items = collection.get()
+    except Exception as e:
+        print(f"Error retrieving existing items: {e}")
+        return
+
+    existing_ids = set()
+
+    if 'ids' in existing_items:
+        existing_ids.update(existing_items['ids'])
+
+    chunks = chunk_content(markdown_content)
+    text_to_vectorize = []
+
+    for chunk in chunks:
+        chunk_id = generate_chunk_id(chunk)
+        if chunk_id not in existing_ids:
+            text_to_vectorize.append(chunk)
+
+    print(f"New chunks to vectorize: {len(text_to_vectorize)}")
+
+    if text_to_vectorize:
+        embeddings = vectorize(text_to_vectorize)
+        for embedding, chunk in zip(embeddings, text_to_vectorize):
+            chunk_id = generate_chunk_id(chunk)
+            if chunk_id not in existing_ids:
+                try:
+                    collection.add(
+                        embeddings=[embedding],
+                        documents=[chunk],
+                        metadatas=[metadatas],
+                        ids=[chunk_id]
+                    )
+                    existing_ids.add(chunk_id)
+                except Exception as e:
+                    print(f"Error adding embedding to collection: {e}")
+
+
+def retrieve_from_database(query, collection_name=COLLECTION_NAME, n_results=5, distance_threshold=None):
+    """
+    Retrieve the most similar documents from the vector store based on the query.
+    """
+    try:
+        client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+        collection = client.get_collection(collection_name)
+    except Exception as e:
+        print(f"Error accessing collection: {e}")
+        return
+
+    try:
+        query_embeddings = vectorize([query])
+    except Exception as e:
+        print(f"Error vectorizing query: {e}")
+        return
+
+    try:
+        raw_results = collection.query(
+            query_embeddings=query_embeddings,
+            n_results=n_results,
+            include=["documents", "metadatas", "distances"]
+        )
+    except Exception as e:
+        print(f"Error querying collection: {e}")
+        return
+
+    if distance_threshold is not None:
+        filtered_results = {
+            "ids": [],
+            "distances": [],
+            "metadatas": [],
+            "documents": []
+        }
+        for i, distance in enumerate(raw_results['distances'][0]):
+            if distance <= distance_threshold:
+                filtered_results['ids'].append(raw_results['ids'][0][i])
+                filtered_results['distances'].append(distance)
+                filtered_results['metadatas'].append(raw_results['metadatas'][0][i])
+                filtered_results['documents'].append(raw_results['documents'][0][i])
+        results = filtered_results
+
+        if len(results['documents']) == 0:
+            return "No relevant data found in the knowledge database. Have you checked any webpages? If so, please try to find more relevant data."
+        else:
+            return results
+    else:
+        return raw_results
+
+
+def search_documents(collection_name=COLLECTION_NAME, query=None, query_embedding=None, metadata_filter=None, n_results=10):
+    """
+    Search for documents in a ChromaDB collection.
+
+    :param collection_name: The name of the collection to search within.
+    :param query: The text query to search for (optional).
+    :param query_embedding: The embedding query to search for (optional).
+    :param metadata_filter: A filter to apply to the metadata (optional).
+    :param n_results: The number of results to return (default is 10).
+    :return: The search results.
+    """
+    client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+    collection = client.get_collection(collection_name)
+
+    if query:
+        query_embedding = vectorize([query])[0]
+
+    if query_embedding:
+        results = collection.query(query_embeddings=[query_embedding], n_results=n_results, where=metadata_filter)
+    else:
+        results = collection.get(where=metadata_filter, limit=n_results)
+
+    return results
+
+
+def delete_documents(collection_name=COLLECTION_NAME, ids=None):
+    """
+    Delete documents from a ChromaDB collection based on their IDs.
+
+    :param collection_name: The name of the collection.
+    :param ids: A list of IDs of the documents to delete.
+    """
+    client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+    collection = client.get_collection(collection_name)
+
+    collection.delete(ids=ids)
+    print(f"Documents with IDs {ids} have been deleted from the collection {collection_name}.")
+
+def delete_collection(collection_name=COLLECTION_NAME):
+    """
+    Delete a ChromaDB collection.
+
+    :param collection_name: The name of the collection to delete.
+    """
+    client = chromadb.PersistentClient(path=PERSIST_DIRECTORY)
+    client.delete_collection(collection_name)
+    print(f"Collection {collection_name} has been deleted.")

src/web2llm/app/__init__.py

@@ -0,0 +1,5 @@
+"""
+Web Scraper et Convertisseur Markdown.
+"""
+
+__version__ = "0.1.0" 

src/web2llm/app/api/__init__.py

@@ -0,0 +1,7 @@
+"""
+Module API REST pour le Web Scraper et Convertisseur Markdown.
+"""
+
+from src.web2llm.app.api.routes import router
+
+__all__ = ['router'] 

src/web2llm/app/api/models.py

@@ -0,0 +1,52 @@
+"""
+Modèles de données pour l'API.
+"""
+from typing import List, Optional, Dict, Union, Any
+from pydantic import BaseModel, HttpUrl, validator, Field
+
+
+class ScrapeRequest(BaseModel):
+    """Modèle pour une requête de scraping."""
+    url: str = Field(..., description="URL à scraper")
+    save: bool = Field(False, description="Sauvegarder le résultat en fichier Markdown")
+    filename: Optional[str] = Field(None, description="Nom du fichier pour la sauvegarde")
+    clean: bool = Field(True, description="Nettoyer le HTML avant conversion")
+
+    @validator('url')
+    def url_must_be_valid(cls, v):
+        """Validation de l'URL."""
+        if not v.startswith(('http://', 'https://')):
+            raise ValueError('URL doit commencer par http:// ou https://')
+        return v
+
+
+class MultipleScrapeRequest(BaseModel):
+    """Modèle pour une requête de scraping multiple."""
+    urls: List[str] = Field(..., description="Liste d'URLs à scraper")
+    save: bool = Field(True, description="Sauvegarder les résultats en fichiers Markdown")
+    
+    @validator('urls')
+    def urls_must_be_valid(cls, v):
+        """Validation des URLs."""
+        for url in v:
+            if not url.startswith(('http://', 'https://')):
+                raise ValueError(f'URL {url} doit commencer par http:// ou https://')
+        return v
+
+
+class ScrapeResponse(BaseModel):
+    """Modèle pour la réponse de scraping."""
+    url: str = Field(..., description="URL scrapée")
+    title: Optional[str] = Field(None, description="Titre de la page")
+    markdown: Optional[str] = Field(None, description="Contenu en Markdown")
+    saved: bool = Field(False, description="Indique si le fichier a été sauvegardé")
+    saved_path: Optional[str] = Field(None, description="Chemin du fichier sauvegardé")
+    success: bool = Field(..., description="Indique si le scraping a réussi")
+    error: Optional[str] = Field(None, description="Message d'erreur éventuel")
+
+
+class MultipleScrapeResponse(BaseModel):
+    """Modèle pour la réponse de scraping multiple."""
+    total: int = Field(..., description="Nombre total d'URLs traitées")
+    success: int = Field(..., description="Nombre d'URLs traitées avec succès")
+    results: List[ScrapeResponse] = Field(..., description="Résultats pour chaque URL") 

src/web2llm/app/api/routes.py

@@ -0,0 +1,159 @@
+"""
+Routes de l'API.
+"""
+import os
+from typing import Dict, List, Any
+
+from fastapi import APIRouter, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse, FileResponse
+
+from app.main import WebToMarkdown
+from app.api.models import (
+    ScrapeRequest, ScrapeResponse, 
+    MultipleScrapeRequest, MultipleScrapeResponse
+)
+
+router = APIRouter()
+processor = WebToMarkdown()
+
+
+@router.post("/scrape", response_model=ScrapeResponse, tags=["Scraping"])
+async def scrape_url(request: ScrapeRequest) -> Dict[str, Any]:
+    """
+    Scrape une URL et convertit le contenu en Markdown.
+    
+    - **url**: L'URL à scraper
+    - **save**: Si True, sauvegarde le résultat en fichier Markdown
+    - **filename**: Nom du fichier pour la sauvegarde (optionnel)
+    - **clean**: Si True, nettoie le HTML avant conversion
+    
+    Retourne le contenu en Markdown et d'autres informations.
+    """
+    result = processor.process_url(
+        url=request.url, 
+        save=request.save, 
+        filename=request.filename
+    )
+    
+    if not result["success"]:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors du scraping: {result.get('error', 'Erreur inconnue')}"
+        )
+    
+    return result
+
+
+@router.post("/scrape/save", tags=["Scraping"])
+async def scrape_and_save(request: ScrapeRequest) -> Dict[str, Any]:
+    """
+    Scrape une URL, convertit en Markdown et sauvegarde dans un fichier.
+    
+    - **url**: L'URL à scraper
+    - **filename**: Nom du fichier pour la sauvegarde (optionnel)
+    - **clean**: Si True, nettoie le HTML avant conversion
+    
+    Retourne le chemin du fichier sauvegardé et d'autres informations.
+    """
+    # Force la sauvegarde
+    request.save = True
+    
+    result = processor.process_url(
+        url=request.url, 
+        save=True, 
+        filename=request.filename
+    )
+    
+    if not result["success"]:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors du scraping: {result.get('error', 'Erreur inconnue')}"
+        )
+    
+    if not result["saved"] or not result["saved_path"]:
+        raise HTTPException(
+            status_code=500, 
+            detail="Échec de l'enregistrement du fichier"
+        )
+    
+    return {
+        "success": True,
+        "file_path": result["saved_path"],
+        "title": result["title"],
+        "url": result["url"]
+    }
+
+
+@router.post("/scrape/download", tags=["Scraping"])
+async def scrape_and_download(request: ScrapeRequest) -> FileResponse:
+    """
+    Scrape une URL, convertit en Markdown et renvoie directement le fichier.
+    
+    - **url**: L'URL à scraper
+    - **filename**: Nom du fichier pour la sauvegarde (optionnel)
+    - **clean**: Si True, nettoie le HTML avant conversion
+    
+    Retourne directement le fichier Markdown pour téléchargement.
+    """
+    # Force la sauvegarde
+    request.save = True
+    
+    result = processor.process_url(
+        url=request.url, 
+        save=True, 
+        filename=request.filename
+    )
+    
+    if not result["success"]:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Erreur lors du scraping: {result.get('error', 'Erreur inconnue')}"
+        )
+    
+    if not result["saved"] or not result["saved_path"]:
+        raise HTTPException(
+            status_code=500, 
+            detail="Échec de l'enregistrement du fichier"
+        )
+    
+    return FileResponse(
+        path=result["saved_path"],
+        media_type="text/markdown",
+        filename=os.path.basename(result["saved_path"])
+    )
+
+
+@router.post("/scrape/multiple", response_model=MultipleScrapeResponse, tags=["Scraping multiple"])
+async def scrape_multiple_urls(
+    request: MultipleScrapeRequest, 
+    background_tasks: BackgroundTasks
+) -> Dict[str, Any]:
+    """
+    Scrape plusieurs URLs en parallèle.
+    
+    - **urls**: Liste d'URLs à scraper
+    - **save**: Si True, sauvegarde les résultats en fichiers Markdown
+    
+    Retourne les résultats pour toutes les URLs.
+    """
+    if len(request.urls) > 10:
+        # Pour de nombreuses URLs, traiter en arrière-plan
+        background_tasks.add_task(
+            processor.process_multiple_urls, 
+            urls=request.urls, 
+            save=request.save
+        )
+        return {
+            "total": len(request.urls),
+            "success": None,  # Inconnu car traitement en arrière-plan
+            "results": [],
+            "message": f"Traitement de {len(request.urls)} URLs en arrière-plan"
+        }
+    
+    # Pour peu d'URLs, traiter immédiatement
+    result = processor.process_multiple_urls(
+        urls=request.urls, 
+        save=request.save
+    )
+    
+    return result 

src/web2llm/app/api/server.py

@@ -0,0 +1,85 @@
+"""
+Configuration du serveur FastAPI.
+"""
+import os
+import logging
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from dotenv import load_dotenv
+
+from app import __version__
+from app.api.routes import router
+
+# Chargement des variables d'environnement
+load_dotenv()
+
+# Configuration
+API_HOST = os.getenv("API_HOST", "0.0.0.0")
+API_PORT = int(os.getenv("API_PORT", 8000))
+
+# Création de l'application FastAPI
+app = FastAPI(
+    title="Web Scraper et Convertisseur Markdown API",
+    description="""
+    API pour scraper des sites web, nettoyer le contenu et le convertir en Markdown.
+    Idéal pour préparer des données pour les systèmes d'IA.
+    """,
+    version=__version__,
+    docs_url="/docs",
+    redoc_url="/redoc",
+)
+
+# Configuration CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Pour la production, limitez aux domaines autorisés
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Enregistrement des routes
+app.include_router(router, prefix="/api")
+
+# Gestionnaire d'exceptions
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """Gestionnaire global des exceptions."""
+    logging.error(f"Exception non gérée: {str(exc)}")
+    return JSONResponse(
+        status_code=500,
+        content={"detail": f"Erreur interne du serveur: {str(exc)}"}
+    )
+
+# Route racine
+@app.get("/", tags=["Informations"])
+async def root():
+    """Page d'accueil de l'API."""
+    return {
+        "name": "Web Scraper et Convertisseur Markdown API",
+        "version": __version__,
+        "docs": "/docs",
+        "redoc": "/redoc"
+    }
+
+# Vérification de la santé de l'API
+@app.get("/health", tags=["Informations"])
+async def health_check():
+    """Vérification de la santé de l'API."""
+    return {"status": "ok", "version": __version__}
+
+
+def start():
+    """Démarrage du serveur avec uvicorn."""
+    import uvicorn
+    uvicorn.run(
+        "app.api.server:app",
+        host=API_HOST,
+        port=API_PORT,
+        reload=True
+    )
+
+
+if __name__ == "__main__":
+    start() 

src/web2llm/app/converter/__init__.py

@@ -0,0 +1,7 @@
+"""
+Module de conversion HTML vers Markdown.
+"""
+
+from src.web2llm.app.converter.converter import MarkdownConverter, html_to_markdown, save_markdown
+
+__all__ = ['MarkdownConverter', 'html_to_markdown', 'save_markdown'] 

src/web2llm/app/converter/converter.py

@@ -0,0 +1,407 @@
+"""
+Module de conversion du HTML en Markdown.
+"""
+import os
+import logging
+import re
+from typing import Optional, Dict, Any
+from html2markdown import convert
+from bs4 import BeautifulSoup
+import markdown
+from urllib.parse import urlparse, urljoin
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class MarkdownConverter:
+    """Classe pour convertir le HTML en Markdown avec options de nettoyage avancées."""
+    
+    def __init__(self, base_url: Optional[str] = None):
+        """
+        Initialise le convertisseur.
+        
+        Args:
+            base_url: URL de base pour résoudre les liens relatifs
+        """
+        self.base_url = base_url
+    
+    def fix_relative_urls(self, html_content: str, base_url: Optional[str] = None) -> str:
+        """
+        Remplace les URLs relatives par des URLs absolues.
+        
+        Args:
+            html_content: Le contenu HTML
+            base_url: L'URL de base pour résoudre les liens relatifs
+            
+        Returns:
+            HTML avec liens absolus
+        """
+        if not base_url and not self.base_url:
+            return html_content
+            
+        url_to_use = base_url if base_url else self.base_url
+        
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        # Corriger les liens
+        for a_tag in soup.find_all('a', href=True):
+            if not a_tag['href'].startswith(('http://', 'https://', 'mailto:', 'tel:', '#')):
+                a_tag['href'] = urljoin(url_to_use, a_tag['href'])
+        
+        # Corriger les images
+        for img_tag in soup.find_all('img', src=True):
+            if not img_tag['src'].startswith(('http://', 'https://', 'data:')):
+                img_tag['src'] = urljoin(url_to_use, img_tag['src'])
+        
+        return str(soup)
+    
+    def pre_process_html(self, html_content: str) -> str:
+        """
+        Pré-traitement du HTML pour améliorer la conversion en Markdown.
+        
+        Args:
+            html_content: Le contenu HTML
+            
+        Returns:
+            HTML pré-traité
+        """
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        # Supprimer tous les scripts et styles - Première passe critique
+        for element in soup.find_all(['script', 'style', 'noscript', 'iframe']):
+            element.decompose()
+        
+        # Supprimer les attributs JavaScript inline et styles
+        for tag in soup.find_all(True):
+            # Liste pour stocker les attributs à supprimer
+            attrs_to_remove = []
+            
+            for attr in tag.attrs:
+                # Supprimer style et attributs JavaScript
+                if attr == 'style' or attr.startswith('on'):
+                    attrs_to_remove.append(attr)
+            
+            # Supprimer les attributs identifiés
+            for attr in attrs_to_remove:
+                del tag[attr]
+        
+        # Convertir les divs qui se comportent comme des paragraphes en paragraphes réels
+        for div in soup.find_all('div'):
+            if not div.find(['div', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'table', 'ul', 'ol']):
+                div.name = 'p'
+        
+        # S'assurer que les listes sont correctement formatées
+        for ul in soup.find_all(['ul', 'ol']):
+            for child in ul.children:
+                if child.name != 'li' and child.name is not None:
+                    # Convertir ou envelopper dans un li
+                    if child.string and child.string.strip():
+                        new_li = soup.new_tag('li')
+                        child.wrap(new_li)
+        
+        # Traiter les tableaux pour une meilleure conversion
+        for table in soup.find_all('table'):
+            # S'assurer que chaque tableau a un thead et tbody
+            if not table.find('thead'):
+                thead = soup.new_tag('thead')
+                first_tr = table.find('tr')
+                if first_tr:
+                    first_tr.wrap(thead)
+            
+            # S'assurer que tbody existe
+            if not table.find('tbody'):
+                tbody = soup.new_tag('tbody')
+                for tr in table.find_all('tr')[1:]:
+                    tr.wrap(tbody)
+        
+        # Nettoyer les balises span inutiles
+        for span in soup.find_all('span'):
+            if not span.attrs:  # Si span n'a pas d'attributs
+                span.unwrap()
+        
+        # Supprimer les objets JavaScript/Flash/etc.
+        for obj in soup.find_all(['object', 'embed']):
+            obj.decompose()
+        
+        # Supprimer les formulaires (souvent inutiles pour l'extraction de contenu)
+        for form in soup.find_all('form'):
+            form.decompose()
+        
+        # Retourner le HTML pré-traité
+        return str(soup)
+    
+    def clean_markdown(self, markdown_content: str) -> str:
+        """
+        Nettoie le markdown généré.
+        
+        Args:
+            markdown_content: Le contenu Markdown
+            
+        Returns:
+            Markdown nettoyé
+        """
+        # Supprimer les lignes vides consécutives
+        markdown_content = re.sub(r'\n{3,}', '\n\n', markdown_content)
+        
+        # Nettoyer les liens qui ont pu être mal convertis
+        markdown_content = re.sub(r'\[(.+?)\]\s*\[\]', r'\1', markdown_content)
+        
+        # Supprimer les blocs de scripts JavaScript
+        markdown_content = re.sub(r'<script[^>]*>[\s\S]*?</script>', '', markdown_content)
+        
+        # Supprimer les blocs de style CSS
+        markdown_content = re.sub(r'<style[^>]*>[\s\S]*?</style>', '', markdown_content)
+        
+        # Supprimer les blocs CDATA qui pourraient contenir du JavaScript ou CSS
+        markdown_content = re.sub(r'<!\[CDATA\[[\s\S]*?\]\]>', '', markdown_content)
+        
+        # Nettoyer TOUTES les balises HTML, pas seulement certaines
+        markdown_content = re.sub(r'</?[a-zA-Z][^>]*>', '', markdown_content)
+        
+        # Nettoyer les balises <br> et les remplacer par des sauts de ligne
+        markdown_content = re.sub(r'<br\s*/?>',  '\n', markdown_content)
+        
+        # Nettoyer les espaces excessifs
+        markdown_content = re.sub(r' {2,}', ' ', markdown_content)
+        
+        # Nettoyer les attributs HTML restants et toutes les balises avec leurs attributs
+        markdown_content = re.sub(r'<([a-z0-9]+)(?:\s+[a-z0-9-]+(?:=(?:"[^"]*"|\'[^\']*\'))?)*\s*>', '', markdown_content)
+        markdown_content = re.sub(r'</[a-z0-9]+>', '', markdown_content)
+        
+        # Supprimer les commentaires HTML
+        markdown_content = re.sub(r'<!--[\s\S]*?-->', '', markdown_content)
+        
+        # Supprimer tous les caractères d'échappement HTML comme &nbsp;
+        markdown_content = re.sub(r'&[a-zA-Z]+;', ' ', markdown_content)
+        
+        # Supprimer les styles et scripts qui pourraient être intégrés dans des blocs de code
+        markdown_content = re.sub(r'```(?:javascript|js|css|style)[\s\S]*?```', '', markdown_content)
+        
+        # Supprimer les lignes qui ressemblent à du CSS (propriété: valeur;)
+        markdown_content = re.sub(r'^[a-z-]+:\s*[^;]+;\s*$', '', markdown_content, flags=re.MULTILINE)
+        
+        # Supprimer les lignes qui ressemblent à des déclarations JavaScript
+        markdown_content = re.sub(r'^var\s+[a-zA-Z0-9_$]+\s*=', '', markdown_content, flags=re.MULTILINE)
+        markdown_content = re.sub(r'^function\s+[a-zA-Z0-9_$]+\s*\(', '', markdown_content, flags=re.MULTILINE)
+        markdown_content = re.sub(r'^const\s+[a-zA-Z0-9_$]+\s*=', '', markdown_content, flags=re.MULTILINE)
+        markdown_content = re.sub(r'^let\s+[a-zA-Z0-9_$]+\s*=', '', markdown_content, flags=re.MULTILINE)
+        
+        # Supprimer les accolades isolées qui pourraient provenir de code
+        markdown_content = re.sub(r'^\s*[{}]\s*$', '', markdown_content, flags=re.MULTILINE)
+        
+        # Supprimer les doubles espaces après avoir enlevé les balises
+        markdown_content = re.sub(r' {2,}', ' ', markdown_content)
+        
+        # Nettoyer les lignes vides multiples qui peuvent être créées après suppression des balises
+        markdown_content = re.sub(r'\n{3,}', '\n\n', markdown_content)
+        
+        # Supprimer les lignes qui ne contiennent que des caractères non significatifs
+        markdown_content = re.sub(r'^\s*[;:.,_\-*+#]+\s*$', '', markdown_content, flags=re.MULTILINE)
+        
+        return markdown_content.strip()
+    
+    def html_to_markdown(self, html_content: str, url: Optional[str] = None) -> str:
+        """
+        Convertit le HTML en Markdown.
+        
+        Args:
+            html_content: Le contenu HTML
+            url: L'URL source pour résoudre les liens relatifs
+            
+        Returns:
+            Contenu au format Markdown
+        """
+        try:
+            # Pré-traiter le HTML
+            html_content = self.pre_process_html(html_content)
+            
+            # Fixer les URLs relatives si une URL est fournie
+            base_url = url or self.base_url
+            if base_url:
+                html_content = self.fix_relative_urls(html_content, base_url)
+            
+            # Approche 1: Utiliser html2markdown (la bibliothèque standard)
+            markdown_content_1 = convert(html_content)
+            markdown_content_1 = self.clean_markdown(markdown_content_1)
+            
+            # Si le résultat semble bon, on le retourne
+            if not ('<' in markdown_content_1 and '>' in markdown_content_1):
+                return markdown_content_1
+            
+            # Approche 2: Extraction directe avec BeautifulSoup
+            soup = BeautifulSoup(html_content, 'html.parser')
+            content_parts = []
+            
+            # Ajouter le titre
+            if soup.title:
+                content_parts.append(f"# {soup.title.string.strip()}\n\n")
+            
+            # Ajouter les titres et sous-titres
+            for i in range(1, 7):
+                for header in soup.find_all(f'h{i}'):
+                    content_parts.append(f"{'#' * i} {header.get_text().strip()}\n\n")
+            
+            # Ajouter les paragraphes
+            for p in soup.find_all('p'):
+                text = p.get_text().strip()
+                if text:
+                    content_parts.append(f"{text}\n\n")
+            
+            # Ajouter les listes non ordonnées
+            for ul in soup.find_all('ul'):
+                for li in ul.find_all('li'):
+                    content_parts.append(f"* {li.get_text().strip()}\n")
+                content_parts.append("\n")
+            
+            # Ajouter les listes ordonnées
+            for ol in soup.find_all('ol'):
+                for i, li in enumerate(ol.find_all('li')):
+                    content_parts.append(f"{i+1}. {li.get_text().strip()}\n")
+                content_parts.append("\n")
+            
+            # Ajouter les tableaux (version simple)
+            for table in soup.find_all('table'):
+                for tr in table.find_all('tr'):
+                    row = []
+                    for cell in tr.find_all(['td', 'th']):
+                        row.append(cell.get_text().strip())
+                    if row:
+                        content_parts.append("| " + " | ".join(row) + " |\n")
+                content_parts.append("\n")
+            
+            # Ajouter les citations
+            for blockquote in soup.find_all('blockquote'):
+                lines = blockquote.get_text().strip().split('\n')
+                for line in lines:
+                    if line.strip():
+                        content_parts.append(f"> {line.strip()}\n")
+                content_parts.append("\n")
+            
+            # Ajouter les blocs de code
+            for pre in soup.find_all('pre'):
+                content_parts.append("```\n")
+                content_parts.append(pre.get_text().strip() + "\n")
+                content_parts.append("```\n\n")
+            
+            # Ajouter les images
+            for img in soup.find_all('img'):
+                alt = img.get('alt', '')
+                src = img.get('src', '')
+                if src:
+                    content_parts.append(f"![{alt}]({src})\n\n")
+            
+            # Ajouter les liens
+            for a in soup.find_all('a'):
+                text = a.get_text().strip()
+                href = a.get('href', '')
+                if href and text:
+                    content_parts.append(f"[{text}]({href})\n\n")
+            
+            # Autres blocs de texte significatifs
+            for div in soup.find_all(['div', 'article', 'section', 'main']):
+                # Éviter les div qui contiennent déjà des éléments traités
+                if not div.find(['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'ul', 'ol', 'table']):
+                    text = div.get_text().strip()
+                    if len(text) > 100:  # Contenu significatif
+                        content_parts.append(f"{text}\n\n")
+            
+            markdown_content_2 = ''.join(content_parts)
+            
+            # Approche 3: Extraction de texte brut en dernier recours
+            if not markdown_content_2 or len(markdown_content_2) < 200:
+                markdown_content_3 = soup.get_text(separator='\n\n', strip=True)
+                # Nettoyer et structurer le texte brut
+                paragraphs = [p.strip() for p in markdown_content_3.split('\n\n') if p.strip()]
+                markdown_content_3 = '\n\n'.join(paragraphs)
+                
+                # Si cette approche donne un meilleur résultat, l'utiliser
+                if len(markdown_content_3) > len(markdown_content_2):
+                    markdown_content_2 = markdown_content_3
+            
+            # Nettoyer le résultat final
+            markdown_content_2 = self.clean_markdown(markdown_content_2)
+            
+            # Sélectionner la meilleure approche
+            if len(markdown_content_1) > len(markdown_content_2) and '<' not in markdown_content_1:
+                return markdown_content_1
+            else:
+                return markdown_content_2
+                
+        except Exception as e:
+            logger.error(f"Erreur lors de la conversion en Markdown: {str(e)}")
+            # Fallback: extraction simple du texte
+            soup = BeautifulSoup(html_content, 'html.parser')
+            text = soup.get_text(separator='\n\n', strip=True)
+            return self.clean_markdown(text)
+    
+    def save_markdown(self, markdown_content: str, filepath: str) -> bool:
+        """
+        Enregistre le contenu Markdown dans un fichier.
+        
+        Args:
+            markdown_content: Le contenu Markdown
+            filepath: Chemin où sauvegarder le fichier
+            
+        Returns:
+            True si la sauvegarde a réussi, False sinon
+        """
+        try:
+            # S'assurer que le répertoire existe
+            os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(markdown_content)
+            
+            logger.info(f"Contenu Markdown sauvegardé avec succès dans {filepath}")
+            return True
+        except Exception as e:
+            logger.error(f"Erreur lors de la sauvegarde du fichier Markdown: {str(e)}")
+            return False
+    
+    def markdown_to_html(self, markdown_content: str) -> str:
+        """
+        Convertit le Markdown en HTML (utile pour la prévisualisation).
+        
+        Args:
+            markdown_content: Le contenu Markdown
+            
+        Returns:
+            Contenu au format HTML
+        """
+        try:
+            return markdown.markdown(markdown_content, extensions=['tables', 'fenced_code'])
+        except Exception as e:
+            logger.error(f"Erreur lors de la conversion du Markdown en HTML: {str(e)}")
+            return f"<pre>{markdown_content}</pre>"
+
+
+# Fonctions utilitaires pour une utilisation rapide
+def html_to_markdown(html_content: str, url: Optional[str] = None) -> str:
+    """
+    Fonction utilitaire pour convertir HTML en Markdown.
+    
+    Args:
+        html_content: Le contenu HTML
+        url: L'URL source pour résoudre les liens relatifs
+        
+    Returns:
+        Contenu au format Markdown
+    """
+    converter = MarkdownConverter(base_url=url)
+    return converter.html_to_markdown(html_content, url)
+
+def save_markdown(markdown_content: str, filepath: str) -> bool:
+    """
+    Fonction utilitaire pour sauvegarder du Markdown dans un fichier.
+    
+    Args:
+        markdown_content: Le contenu Markdown
+        filepath: Chemin où sauvegarder le fichier
+        
+    Returns:
+        True si la sauvegarde a réussi, False sinon
+    """
+    converter = MarkdownConverter()
+    return converter.save_markdown(markdown_content, filepath) 

src/web2llm/app/main.py

@@ -0,0 +1,282 @@
+"""
+Module principal de l'application Web Scraper et Convertisseur Markdown.
+"""
+import os
+import logging
+import time
+from typing import Dict, Optional, Union, List
+from urllib.parse import urlparse
+import pathlib
+from dotenv import load_dotenv
+
+from src.web2llm.app.scraper.scraper import WebScraper
+from src.web2llm.app.converter.converter import MarkdownConverter
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Chargement des variables d'environnement
+load_dotenv()
+
+# Configuration
+OUTPUT_DIR = os.getenv('OUTPUT_DIR', './output')
+DEFAULT_FILENAME = os.getenv('DEFAULT_FILENAME', 'scraped_content')
+
+class WebToMarkdown:
+    """Classe principale combinant le scraping et la conversion en Markdown."""
+    
+    def __init__(self, output_dir: str = OUTPUT_DIR):
+        """
+        Initialise l'outil.
+        
+        Args:
+            output_dir: Répertoire où sauvegarder les fichiers Markdown
+        """
+        self.scraper = WebScraper()
+        self.converter = MarkdownConverter()
+        self.output_dir = output_dir
+        
+        # S'assurer que le répertoire de sortie existe
+        os.makedirs(self.output_dir, exist_ok=True)
+    
+    def generate_filename(self, url: str, title: Optional[str] = None, extension: str = '.md') -> str:
+        """
+        Génère un nom de fichier valide à partir de l'URL ou du titre.
+        
+        Args:
+            url: L'URL de la page
+            title: Le titre de la page (optionnel)
+            extension: L'extension du fichier (.md par défaut)
+            
+        Returns:
+            Un nom de fichier valide
+        """
+        if title:
+            # Nettoyer le titre pour en faire un nom de fichier valide
+            safe_title = "".join([c if c.isalnum() or c in [' ', '-', '_'] else "_" for c in title])
+            safe_title = safe_title.strip()
+            filename = safe_title[:100]  # Limiter la longueur mais permettre des noms plus longs
+        else:
+            # Utiliser l'URL
+            parsed_url = urlparse(url)
+            hostname = parsed_url.netloc
+            path = parsed_url.path.strip('/')
+            filename = f"{hostname}_{path}".replace('/', '_')
+        
+        # Remplacer les espaces par des tirets
+        filename = filename.replace(' ', '-')
+        
+        # S'assurer que le nom se termine par l'extension spécifiée
+        if not filename.endswith(extension):
+            filename += extension
+        
+        return filename
+    
+    def save_raw_html(self, html_content: str, filepath: str) -> bool:
+        """
+        Sauvegarde le contenu HTML brut dans un fichier.
+        
+        Args:
+            html_content: Le contenu HTML
+            filepath: Chemin où sauvegarder le fichier
+            
+        Returns:
+            True si la sauvegarde a réussi, False sinon
+        """
+        try:
+            # S'assurer que le répertoire existe
+            os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True)
+            
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            logger.info(f"Contenu HTML sauvegardé avec succès dans {filepath}")
+            return True
+        except Exception as e:
+            logger.error(f"Erreur lors de la sauvegarde du fichier HTML: {str(e)}")
+            return False
+    
+    def process_url(self, url: str, save: bool = False, 
+                  filename: Optional[str] = None) -> Dict[str, Union[str, None, bool]]:
+        """
+        Traite une URL: scraping, nettoyage et conversion en Markdown.
+        
+        Args:
+            url: L'URL à traiter
+            save: Si True, sauvegarde le résultat dans un fichier
+            filename: Nom du fichier pour la sauvegarde
+            
+        Returns:
+            Dictionnaire avec les résultats et le statut
+        """
+        result = {
+            "url": url,
+            "title": None,
+            "markdown": None,
+            "saved": False,
+            "saved_path": None,
+            "success": False,
+            "error": None,
+            "html_saved": False,
+            "html_saved_path": None
+        }
+        
+        try:
+            # Définir l'URL de base pour la conversion des liens relatifs
+            self.converter.base_url = url
+            
+            # Scraper l'URL
+            logger.info(f"Scraping de l'URL: {url}")
+            scraped_data = self.scraper.scrape(url, clean=True, extract_text=True)
+            
+            # Stocker le titre
+            result["title"] = scraped_data["title"]
+            
+            if not scraped_data["clean_html"]:
+                result["error"] = "Impossible de récupérer ou nettoyer le contenu HTML"
+                return result
+            
+            # Conversion en Markdown
+            logger.info("Conversion du HTML en Markdown")
+            markdown_content = self.converter.html_to_markdown(
+                scraped_data["clean_html"], url)
+            
+            # Vérifier si la conversion a produit un résultat significatif
+            if not markdown_content or len(markdown_content) < 100:
+                logger.warning("Conversion en Markdown insuffisante, tentative avec le texte brut")
+                
+                # Si le texte brut est disponible, l'utiliser comme alternative
+                if scraped_data["text_content"]:
+                    markdown_content = scraped_data["text_content"]
+                else:
+                    # Dernière tentative: extraire le texte à partir du HTML nettoyé
+                    from bs4 import BeautifulSoup
+                    soup = BeautifulSoup(scraped_data["clean_html"], 'html.parser')
+                    markdown_content = soup.get_text(separator='\n\n', strip=True)
+            
+            # Mise à jour du résultat
+            result["markdown"] = markdown_content
+            result["success"] = True
+            
+            # Sauvegarde si demandée
+            if save:
+                # Générer un nom de fichier si non spécifié
+                if not filename:
+                    filename = self.generate_filename(url, result["title"])
+                # S'assurer que l'extension est .md
+                elif not filename.endswith('.md'):
+                    filename += '.md'
+                
+                filepath = os.path.join(self.output_dir, filename)
+                
+                # Enregistrer le fichier Markdown
+                saved = self.converter.save_markdown(markdown_content, filepath)
+                result["saved"] = saved
+                result["saved_path"] = filepath if saved else None
+                
+                # Si la conversion en Markdown n'est pas optimale, sauvegarder aussi le HTML
+                if len(markdown_content) < 500 or "<" in markdown_content:
+                    html_filename = filename.replace('.md', '.html')
+                    html_filepath = os.path.join(self.output_dir, html_filename)
+                    html_saved = self.save_raw_html(scraped_data["clean_html"], html_filepath)
+                    result["html_saved"] = html_saved
+                    result["html_saved_path"] = html_filepath if html_saved else None
+                    
+                    if html_saved:
+                        logger.info(f"Le HTML a été sauvegardé en complément dans {html_filepath}")
+            
+            return result
+        
+        except Exception as e:
+            logger.error(f"Erreur lors du traitement de l'URL {url}: {str(e)}")
+            result["error"] = str(e)
+            
+            # En cas d'erreur, tenter de sauvegarder le HTML brut si disponible
+            if save and scraped_data and "raw_html" in scraped_data and scraped_data["raw_html"]:
+                if not filename:
+                    filename = self.generate_filename(url, result["title"], '.html')
+                else:
+                    filename = filename.replace('.md', '.html')
+                
+                html_filepath = os.path.join(self.output_dir, filename)
+                html_saved = self.save_raw_html(scraped_data["raw_html"], html_filepath)
+                
+                result["html_saved"] = html_saved
+                result["html_saved_path"] = html_filepath if html_saved else None
+                
+                if html_saved:
+                    logger.info(f"Sauvegarde de secours du HTML brut dans {html_filepath}")
+            
+            return result
+    
+    def process_multiple_urls(self, urls: List[str], save: bool = True) -> Dict[str, List[Dict]]:
+        """
+        Traite plusieurs URLs en parallèle.
+        
+        Args:
+            urls: Liste d'URLs à traiter
+            save: Si True, sauvegarde les résultats
+            
+        Returns:
+            Dictionnaire contenant les résultats pour chaque URL
+        """
+        results = []
+        
+        for url in urls:
+            result = self.process_url(url, save=save)
+            results.append(result)
+        
+        return {
+            "total": len(urls),
+            "success": sum(1 for r in results if r["success"]),
+            "results": results
+        }
+
+
+# Fonction pour une utilisation rapide en ligne de commande
+def process_url(url: str, save: bool = False, filename: Optional[str] = None) -> Dict:
+    """
+    Fonction utilitaire pour traiter rapidement une URL.
+    
+    Args:
+        url: L'URL à traiter
+        save: Si True, sauvegarde le résultat
+        filename: Nom du fichier pour la sauvegarde
+        
+    Returns:
+        Dictionnaire avec les résultats
+    """
+    processor = WebToMarkdown()
+    return processor.process_url(url, save, filename)
+
+
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Scraper et convertisseur Markdown")
+    parser.add_argument("url", help="URL à scraper")
+    parser.add_argument("--save", action="store_true", help="Sauvegarder en fichier Markdown")
+    parser.add_argument("--output", help="Nom du fichier de sortie")
+    parser.add_argument("--dir", help="Répertoire de sortie", default=OUTPUT_DIR)
+    
+    args = parser.parse_args()
+    
+    processor = WebToMarkdown(output_dir=args.dir)
+    result = processor.process_url(args.url, save=args.save, filename=args.output)
+    
+    if result["success"]:
+        print(f"Titre: {result['title']}")
+        print("\nContenu Markdown:")
+        print("-------------------")
+        print(result["markdown"][:500] + "..." if len(result["markdown"]) > 500 else result["markdown"])
+        
+        if result["saved"]:
+            print(f"\nFichier sauvegardé: {result['saved_path']}")
+        if result["html_saved"]:
+            print(f"\nFichier HTML sauvegardé: {result['html_saved_path']}")
+    else:
+        print(f"Erreur: {result['error']}")
+        if result["html_saved"]:
+            print(f"\nFichier HTML de secours sauvegardé: {result['html_saved_path']}") 

src/web2llm/app/scraper/__init__.py

@@ -0,0 +1,7 @@
+"""
+Module de scraping.
+"""
+
+from src.web2llm.app.scraper.scraper import WebScraper, scrape_url
+
+__all__ = ['WebScraper', 'scrape_url'] 

src/web2llm/app/scraper/scraper.py

@@ -0,0 +1,475 @@
+"""
+Module de scraping pour extraire le contenu des pages web.
+"""
+import os
+import logging
+from typing import Dict, Optional, Union, List
+import requests
+from bs4 import BeautifulSoup
+from readability import Document
+from dotenv import load_dotenv
+import re
+
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, 
+                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Chargement des variables d'environnement
+load_dotenv()
+
+# Configuration par défaut
+DEFAULT_USER_AGENT = os.getenv(
+    'USER_AGENT', 
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+)
+DEFAULT_TIMEOUT = int(os.getenv('REQUEST_TIMEOUT', 30))
+DEFAULT_MAX_RETRIES = int(os.getenv('MAX_RETRIES', 3))
+
+class WebScraper:
+    """Classe pour scraper des pages web et nettoyer leur contenu."""
+    
+    def __init__(self, user_agent: str = DEFAULT_USER_AGENT, 
+                 timeout: int = DEFAULT_TIMEOUT,
+                 max_retries: int = DEFAULT_MAX_RETRIES):
+        """
+        Initialise le scraper.
+        
+        Args:
+            user_agent: User-Agent à utiliser pour les requêtes HTTP
+            timeout: Délai d'attente en secondes pour les requêtes
+            max_retries: Nombre maximal de tentatives en cas d'échec
+        """
+        self.user_agent = user_agent
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.session = requests.Session()
+        self.session.headers.update({"User-Agent": self.user_agent})
+    
+    def fetch_url(self, url: str) -> Optional[str]:
+        """
+        Récupère le contenu HTML d'une URL.
+        
+        Args:
+            url: L'URL à scraper
+            
+        Returns:
+            Le contenu HTML ou None en cas d'échec
+        """
+        for attempt in range(self.max_retries):
+            try:
+                logger.info(f"Tentative {attempt + 1}/{self.max_retries} de récupération de {url}")
+                response = self.session.get(url, timeout=self.timeout)
+                response.raise_for_status()
+                
+                # Détection de l'encodage
+                encoding = response.encoding
+                
+                # Si le site ne spécifie pas d'encodage ou qu'il est incorrect, essayer de le détecter
+                if encoding == 'ISO-8859-1' or not encoding:
+                    detected_encoding = response.apparent_encoding
+                    if detected_encoding:
+                        response.encoding = detected_encoding
+                
+                return response.text
+            except requests.RequestException as e:
+                logger.error(f"Erreur lors de la récupération de {url}: {str(e)}")
+                if attempt == self.max_retries - 1:
+                    logger.error(f"Échec après {self.max_retries} tentatives.")
+                    return None
+        return None
+    
+    def extract_additional_content(self, soup: BeautifulSoup) -> str:
+        """
+        Extrait du contenu supplémentaire qui pourrait être ignoré par Readability.
+        
+        Args:
+            soup: Objet BeautifulSoup contenant la page HTML
+            
+        Returns:
+            Contenu HTML supplémentaire
+        """
+        additional_html = ""
+        
+        # Rechercher des sections de contenu courantes qui pourraient être manquées
+        content_selectors = [
+            'article', '.article', '.post', '.content', '.main-content',
+            'main', '#main', '#content', '.body', '.entry-content',
+            '.page-content', '[role="main"]', '[itemprop="articleBody"]',
+            '.blog-post', '.text', '.publication-content', '.story'
+        ]
+        
+        for selector in content_selectors:
+            elements = soup.select(selector)
+            if elements:
+                for element in elements:
+                    additional_html += str(element)
+        
+        # Si aucun contenu n'a été trouvé avec les sélecteurs, essayer d'autres méthodes
+        if not additional_html:
+            # Obtenir tous les paragraphes qui ont un contenu substantiel
+            paragraphs = []
+            for p in soup.find_all('p'):
+                text = p.get_text().strip()
+                # Considérer uniquement les paragraphes avec un contenu significatif
+                if len(text) > 50:  # Paragraphes d'au moins 50 caractères
+                    paragraphs.append(str(p))
+            
+            if paragraphs:
+                additional_html = "\n".join(paragraphs)
+        
+        return additional_html
+    
+    def remove_headers_footers(self, soup: BeautifulSoup) -> BeautifulSoup:
+        """
+        Supprime les headers, footers, scripts, styles et autres éléments non désirés des pages web,
+        avec une approche plus modérée pour préserver davantage de contenu.
+        
+        Args:
+            soup: L'objet BeautifulSoup contenant le HTML
+            
+        Returns:
+            L'objet BeautifulSoup nettoyé
+        """
+        # Liste des sélecteurs pour les headers et footers courants - version allégée
+        header_selectors = [
+            'header', '#header', '.header', '.site-header', 
+            '.masthead', '[role="banner"]'
+        ]
+        
+        footer_selectors = [
+            'footer', '#footer', '.footer', '.site-footer',
+            '.copyright', '[role="contentinfo"]'
+        ]
+        
+        # Sélecteurs essentiels pour les navbars
+        navbar_selectors = [
+            'nav', '.navbar', '.main-nav', 
+            '#navbar', '#navigation', '#menu',
+            '[role="navigation"]'
+        ]
+        
+        # Sélecteurs essentiels pour les sidebars
+        sidebar_selectors = [
+            'aside', '.sidebar', '#sidebar',
+            '[role="complementary"]'
+        ]
+        
+        # Éléments non désirés les plus courants et intrusifs
+        unwanted_selectors = [
+            '.ads', '.advertisement', '.banner', '.cookie-notice', 
+            '.popup', '.modal', '.newsletter-signup', 
+            '.cookie-banner', '.adsbygoogle', '.ad-container',
+            '.gdpr'
+        ]
+        
+        # Combiner tous les sélecteurs
+        all_selectors = header_selectors + footer_selectors + navbar_selectors + sidebar_selectors + unwanted_selectors
+        
+        # Supprimer tous ces éléments
+        for selector in all_selectors:
+            for element in soup.select(selector):
+                # Vérifier si l'élément contient du contenu significatif
+                text_content = element.get_text(strip=True)
+                
+                # Ignorer les éléments avec beaucoup de contenu textuel 
+                # (probablement du contenu principal mal classé)
+                if len(text_content) > 1000 and selector not in ['.ads', '.advertisement', '.cookie-notice', '.popup', '.modal']:
+                    # Ne pas supprimer - contient trop de contenu pour être juste un élément de navigation
+                    continue
+                
+                element.decompose()
+        
+        # Supprimer tous les scripts
+        for script in soup.find_all('script'):
+            script.decompose()
+        
+        # Supprimer tous les styles CSS
+        for style in soup.find_all('style'):
+            style.decompose()
+        
+        # Supprimer tous les noscript
+        for noscript in soup.find_all('noscript'):
+            noscript.decompose()
+            
+        # Supprimer tous les iframes
+        for iframe in soup.find_all('iframe'):
+            iframe.decompose()
+            
+        # Supprimer les attributs de style, onclick, onload, etc.
+        for tag in soup.find_all(True):
+            # Créer une liste des attributs à supprimer
+            attrs_to_remove = []
+            for attr in tag.attrs:
+                # Supprimer les attributs de style
+                if attr == 'style':
+                    attrs_to_remove.append(attr)
+                # Supprimer les gestionnaires d'événements JavaScript (onclick, onload, etc.)
+                elif attr.startswith('on'):
+                    attrs_to_remove.append(attr)
+                # Supprimer les classes qui pourraient indiquer des scripts/publicités
+                elif attr == 'class':
+                    classes = tag.get('class', [])
+                    if any(cls in ' '.join(classes) for cls in ['js-', 'ad-', 'ads-', 'script-', 'tracking']):
+                        attrs_to_remove.append(attr)
+            
+            # Supprimer les attributs identifiés
+            for attr in attrs_to_remove:
+                del tag[attr]
+        
+        return soup
+
+    def detect_nav_by_content(self, soup: BeautifulSoup) -> None:
+        """
+        Détecte et supprime les éléments de navigation et barres latérales 
+        en analysant leur contenu et leur position, de manière moins agressive.
+        
+        Args:
+            soup: L'objet BeautifulSoup à nettoyer
+        """
+        # 1. Détecter les éléments qui contiennent de nombreux liens
+        all_divs = soup.find_all(['div', 'section', 'ul', 'ol'])
+        for element in all_divs:
+            links = element.find_all('a')
+            
+            # Si un élément contient beaucoup de liens, c'est probablement un menu ou une barre latérale
+            # Augmenté le seuil de 5 à 8 liens pour être moins agressif
+            if len(links) > 8:
+                # Vérifier si les liens sont courts (typique des menus)
+                short_links = [link for link in links if len(link.get_text(strip=True)) < 20]
+                
+                # Augmenté le seuil de 70% à 85% pour être sûr que c'est vraiment un menu
+                if len(short_links) > len(links) * 0.85:
+                    # Vérifier s'il contient du texte informatif substantiel
+                    text_content = element.get_text(strip=True)
+                    # Si le contenu textuel est substantiel par rapport au nombre de liens, ne pas supprimer
+                    if len(text_content) > len(links) * 50:  # En moyenne 50 caractères de contenu par lien
+                        continue
+                    element.decompose()
+                    continue
+            
+            # Vérifier si c'est une liste de catégories, tags, etc.
+            # Liste plus restreinte de termes pour être moins agressif
+            list_terms = ['menu', 'navigation', 'liens', 'links']
+            
+            # Vérifier le texte de l'élément pour des indices, plus strict
+            element_text = element.get_text().lower()
+            if any(term in element_text for term in list_terms) and len(links) > 4:
+                # Vérifier la proportion de texte vs liens
+                if len(element_text) < 200:  # Seulement supprimer les petits éléments de navigation
+                    element.decompose()
+                continue
+                
+        # 2. Détecter les éléments par leur position (uniquement la première div)
+        main_content = soup.find('body')
+        if main_content:
+            # Examiner seulement le premier enfant direct du body (souvent la navigation)
+            # Réduit de 3 à 1 pour être moins agressif
+            children = list(main_content.children)
+            if children and len(children) > 0:
+                child = children[0]
+                if child.name in ['div', 'nav'] and not child.find(['h1', 'h2', 'article', 'p']):
+                    # Vérifier si c'est probablement une navigation sans contenu substantiel
+                    if child.find_all('a', limit=5) and len(child.get_text(strip=True)) < 200:
+                        child.decompose()
+                
+            # Examiner uniquement le dernier enfant direct du body (souvent le footer)
+            # Réduit à seulement le dernier enfant
+            if len(children) > 0:
+                child = children[-1]
+                if child.name in ['div', 'footer'] and not child.find(['h1', 'h2', 'article']):
+                    if 'copyright' in child.get_text().lower() or (
+                        child.find_all('a', limit=3) and len(child.get_text(strip=True)) < 150):
+                        child.decompose()
+        
+        # 3. Supprimer les éléments qui ont une largeur très réduite (sidebars)
+        # Réduit de 40% à 25% pour être moins agressif
+        for element in soup.find_all(True):
+            if 'style' in element.attrs:
+                style = element['style'].lower()
+                if 'width' in style:
+                    # Seulement si la largeur est très petite (moins de 25%)
+                    width_match = re.search(r'width\s*:\s*(\d+)%', style)
+                    if width_match and int(width_match.group(1)) < 25:
+                        # Vérifier qu'il s'agit bien d'un élément de navigation
+                        if element.find_all('a', limit=4) and not element.find(['p', 'article']) and len(element.get_text(strip=True)) < 300:
+                            element.decompose()
+
+    def clean_html(self, html_content: str) -> str:
+        """
+        Nettoie le HTML en utilisant readability-lxml pour extraire le contenu principal.
+        Version moins agressive pour préserver plus de contenu original.
+        
+        Args:
+            html_content: Le contenu HTML brut
+            
+        Returns:
+            Le HTML nettoyé avec le contenu principal
+        """
+        try:
+            # Parser le HTML
+            soup = BeautifulSoup(html_content, 'html.parser')
+            
+            # Récupérer la longueur du contenu original pour analyse
+            original_content_length = len(soup.get_text(strip=True))
+            
+            # Supprimer les headers, footers et autres éléments non désirés
+            soup = self.remove_headers_footers(soup)
+            
+            # Récupérer la longueur du contenu après première passe de nettoyage
+            post_header_footer_length = len(soup.get_text(strip=True))
+            
+            # Si on a déjà perdu plus de 30% du contenu, on ne fait pas de détection avancée
+            # qui risquerait de trop supprimer de contenu
+            if post_header_footer_length > original_content_length * 0.7:
+                # Détection avancée des éléments de navigation par leur contenu
+                self.detect_nav_by_content(soup)
+            
+            # Extraire le titre
+            title = soup.title.string if soup.title else "Sans titre"
+            
+            # Utiliser Readability pour extraire le contenu principal
+            doc = Document(html_content)
+            clean_html = doc.summary()
+            readability_title = doc.title()
+            
+            # Si le titre de Readability est plus informatif, l'utiliser
+            if readability_title and len(readability_title) > len(title):
+                title = readability_title
+            
+            # Parser le HTML nettoyé par Readability
+            clean_soup = BeautifulSoup(clean_html, 'html.parser')
+            
+            # Récupérer la longueur du contenu extrait par Readability
+            readability_content_length = len(clean_soup.get_text(strip=True))
+            
+            # Nettoyer aussi les headers et footers du contenu extrait par Readability
+            clean_soup = self.remove_headers_footers(clean_soup)
+            
+            # Appliquer la détection avancée uniquement si le contenu est conséquent
+            # et on ne veut pas trop perdre de contenu
+            if readability_content_length > 1000:
+                self.detect_nav_by_content(clean_soup)
+            
+            # Vérifier si le contenu extrait est suffisant
+            clean_text = clean_soup.get_text()
+            if len(clean_text) < 500:  # Si moins de 500 caractères, c'est probablement incomplet
+                # Extraire du contenu supplémentaire
+                additional_content = self.extract_additional_content(soup)
+                if additional_content:
+                    # Ajouter ce contenu au HTML nettoyé
+                    additional_soup = BeautifulSoup(additional_content, 'html.parser')
+                    
+                    # Nettoyer également ce contenu supplémentaire
+                    additional_soup = self.remove_headers_footers(additional_soup)
+                    self.detect_nav_by_content(additional_soup)
+                    
+                    # Créer un nouvel élément div pour contenir le contenu supplémentaire
+                    div = BeautifulSoup("<div class='additional-content'></div>", 'html.parser')
+                    div_tag = div.div
+                    
+                    # Ajouter chaque élément de contenu supplémentaire
+                    for element in additional_soup.children:
+                        if element.name:  # Ignorer les nœuds de texte
+                            div_tag.append(element)
+                    
+                    clean_soup.body.append(div_tag)
+                    clean_html = str(clean_soup)
+            
+            # Construire un HTML propre avec le titre et le contenu
+            full_html = f"<html><head><title>{title}</title></head><body><h1>{title}</h1>{clean_html}</body></html>"
+            
+            return full_html
+        except Exception as e:
+            logger.error(f"Erreur lors du nettoyage du HTML: {str(e)}")
+            # En cas d'erreur, retourner le HTML original
+            return html_content
+    
+    def get_text_content(self, html_content: str) -> str:
+        """
+        Extrait le texte brut à partir du HTML.
+        
+        Args:
+            html_content: Le contenu HTML
+            
+        Returns:
+            Le texte extrait sans balises HTML
+        """
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        # Supprimer les scripts et styles qui ne contiennent pas de contenu utile
+        for script_or_style in soup(['script', 'style', 'meta', 'noscript']):
+            script_or_style.decompose()
+        
+        # Obtenir le texte avec des sauts de ligne entre les éléments
+        text = soup.get_text(separator='\n', strip=True)
+        
+        # Nettoyer les sauts de ligne multiples
+        text = re.sub(r'\n{3,}', '\n\n', text)
+        
+        return text
+    
+    def scrape(self, url: str, clean: bool = True, extract_text: bool = False) -> Dict[str, Union[str, None]]:
+        """
+        Scrape une URL et retourne différentes versions du contenu.
+        
+        Args:
+            url: L'URL à scraper
+            clean: Si True, nettoie le HTML
+            extract_text: Si True, extrait également le texte brut
+            
+        Returns:
+            Dictionnaire contenant les différentes formes du contenu
+        """
+        result = {
+            "url": url,
+            "raw_html": None,
+            "clean_html": None,
+            "text_content": None,
+            "title": None,
+        }
+        
+        # Récupération du HTML
+        html_content = self.fetch_url(url)
+        if not html_content:
+            return result
+        
+        result["raw_html"] = html_content
+        
+        # Extraction du titre
+        try:
+            soup = BeautifulSoup(html_content, 'html.parser')
+            result["title"] = soup.title.string.strip() if soup.title else None
+        except Exception as e:
+            logger.error(f"Erreur lors de l'extraction du titre: {str(e)}")
+            pass
+        
+        # Nettoyage du HTML si demandé
+        if clean:
+            result["clean_html"] = self.clean_html(html_content)
+        
+        # Extraction du texte si demandé
+        if extract_text:
+            if result["clean_html"]:
+                result["text_content"] = self.get_text_content(result["clean_html"])
+            else:
+                result["text_content"] = self.get_text_content(html_content)
+        
+        return result
+
+
+# Fonction pratique pour une utilisation rapide
+def scrape_url(url: str, clean: bool = True, extract_text: bool = False) -> Dict[str, Union[str, None]]:
+    """
+    Fonction utilitaire pour scraper rapidement une URL.
+    
+    Args:
+        url: L'URL à scraper
+        clean: Si True, nettoie le HTML
+        extract_text: Si True, extrait également le texte brut
+        
+    Returns:
+        Dictionnaire contenant les différentes formes du contenu
+    """
+    scraper = WebScraper()
+    return scraper.scrape(url, clean, extract_text) 

src/web2llm/app/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Module d'utilitaires pour le scraper et le convertisseur.
+""" 

tools.json

@@ -17,5 +17,47 @@
                 ]
             }
         }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "retrieve_knowledge",
+            "description": "Retrieves knowledge from a database with a provided query.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The query to search for in the vector store."
+                    },
+                    "n_results": {
+                        "type": "integer",
+                        "description": "The number of results to return. Default is 1."
+                    }
+                },
+                "required": [
+                    "query"
+                ]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "visit_webpage",
+            "description": "Visits a webpage at the given URL and reads its content as a markdown string.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The URL of the webpage to visit."
+                    }
+                },
+                "required": [
+                    "url"
+                ]
+            }
+        }
     }
 ]