Update app.py

app.py

@@ -1,18 +1,93 @@
-from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool
 import datetime
 import requests
 import pytz
 import yaml
-from tools.final_answer import FinalAnswerTool
+import os
+import nltk
 from bs4 import BeautifulSoup
-
+from nltk.tokenize import sent_tokenize
+from tools.final_answer import FinalAnswerTool
 from Gradio_UI import GradioUI
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
+# Descargar tokenizer de NLTK si no está disponible
+nltk.download("punkt")
+
+# Configurar el modelo de resumen desde Hugging Face en SmolAgents
+model = HfApiModel(
+    max_tokens=2096,
+    temperature=0.5,
+    model_id="facebook/bart-large-cnn",  # Modelo de resumen
+    custom_role_conversions=None,
+)
+
+@tool
+def save_scraped_data_as_markdown(scraped_data: dict, filename: str = None) -> str:
+    """Convierte el contenido scrapeado en un archivo Markdown mejor estructurado.
+
+    Mejoras:
+    - Resumen automático del contenido con NLP.
+    - Uso de encabezados, listas y negritas en Markdown.
+    - Guardado con timestamp para evitar sobrescribir archivos.
+
+    Args:
+        scraped_data: Diccionario con la URL y los datos extraídos.
+        filename: Nombre del archivo de salida (si no se da, se genera con timestamp).
+
+    Returns:
+        Mensaje de confirmación o error.
+    """
+    try:
+        url = scraped_data.get("url", "Desconocido")
+        content_list = scraped_data.get("scraped_data", [])
+
+        if not content_list:
+            return "No hay datos para guardar en Markdown."
+
+        # Tokenizar en oraciones
+        tokenized_sentences = [sent_tokenize(text) for text in content_list]
+        formatted_content = "\n\n".join([" ".join(sentences) for sentences in tokenized_sentences])
+
+        # Hacer resumen del contenido (limitamos a 1024 tokens por si el texto es muy largo)
+        if len(formatted_content.split()) > 100:
+            summarized_text = model.query(
+                prompt=f"Resume el siguiente texto:\n\n{formatted_content[:1024]}",
+                max_length=150,
+                min_length=50,
+            )
+        else:
+            summarized_text = formatted_content
+
+        # Mejorar la estructura Markdown
+        markdown_content = f"# Contenido extraído de {url}\n\n"
+        markdown_content += f"## Resumen\n\n> {summarized_text}\n\n"
+        markdown_content += "## Contenido Completo\n\n"
+
+        for paragraph in formatted_content.split("\n\n"):
+            if len(paragraph.split()) > 10:  # Si el párrafo es largo, lo tratamos como sección
+                markdown_content += f"### {paragraph[:50]}...\n\n{paragraph}\n\n"
+            else:
+                markdown_content += f"- **{paragraph}**\n\n"
+
+        # Generar nombre con timestamp si no se proporciona
+        if not filename:
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"scraped_{timestamp}.md"
+
+        # Guardar en un archivo Markdown
+        with open(filename, "w", encoding="utf-8") as file:
+            file.write(markdown_content)
+
+        return f"El contenido scrapeado se ha guardado en {filename}"
+
+    except Exception as e:
+        return f"Error al generar el archivo Markdown: {str(e)}"
+
+
 @tool
 def scrape_webpage(url: str, tag: str = "p", class_name: str = None) -> dict:
     """Extrae contenido de una página web según una etiqueta HTML y clase opcional.
-    
+
     Args:
         url: URL de la página a scrapear.
         tag: Etiqueta HTML a extraer (por defecto <p>).
@@ -22,12 +97,12 @@ def scrape_webpage(url: str, tag: str = "p", class_name: str = None) -> dict:
         Un diccionario con el contenido extraído.
     """
     try:
-        headers = {'User-Agent': 'Mozilla/5.0'}
+        headers = {"User-Agent": "Mozilla/5.0"}
         response = requests.get(url, headers=headers)
         response.raise_for_status()
 
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
+        soup = BeautifulSoup(response.text, "html.parser")
+
         if class_name:
             elements = soup.find_all(tag, class_=class_name)
         else:
@@ -35,7 +110,7 @@ def scrape_webpage(url: str, tag: str = "p", class_name: str = None) -> dict:
 
         extracted_data = [element.get_text(strip=True) for element in elements]
 
-        return {"url": url, "scraped_data": extracted_data[:20]}  # Limita a 10 resultados
+        return {"url": url, "scraped_data": extracted_data[:20]}  # Limita a 20 resultados
 
     except requests.exceptions.RequestException as e:
         return {"error": f"Error al acceder a la URL: {str(e)}"}
@@ -46,7 +121,7 @@ def scrape_webpage(url: str, tag: str = "p", class_name: str = None) -> dict:
 @tool
 def extract_metadata_from_url(url: str) -> dict:
     """Extrae todos los metadatos de una página web.
-    
+
     Args:
         url: La URL de la página web a analizar.
 
@@ -54,73 +129,66 @@ def extract_metadata_from_url(url: str) -> dict:
         Un diccionario con los metadatos encontrados.
     """
     try:
-        # Obtener el contenido de la página
-        headers = {'User-Agent': 'Mozilla/5.0'}
+        headers = {"User-Agent": "Mozilla/5.0"}
         response = requests.get(url, headers=headers)
-        response.raise_for_status()  # Lanza un error si el request falla
+        response.raise_for_status()
 
-        # Parsear el contenido HTML con BeautifulSoup
-        soup = BeautifulSoup(response.text, 'html.parser')
+        soup = BeautifulSoup(response.text, "html.parser")
 
-        # Extraer los metadatos de la página
         metadata = {}
-        for meta in soup.find_all('meta'):
-            if 'name' in meta.attrs and 'content' in meta.attrs:
-                metadata[meta['name']] = meta['content']
-            elif 'property' in meta.attrs and 'content' in meta.attrs:
-                metadata[meta['property']] = meta['content']
+        for meta in soup.find_all("meta"):
+            if "name" in meta.attrs and "content" in meta.attrs:
+                metadata[meta["name"]] = meta["content"]
+            elif "property" in meta.attrs and "content" in meta.attrs:
+                metadata[meta["property"]] = meta["content"]
 
         return metadata if metadata else {"error": "No se encontraron metadatos en la página."}
 
     except requests.exceptions.RequestException as e:
         return {"error": f"Error al acceder a la URL: {str(e)}"}
 
+
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """A tool that fetches the current local time in a specified timezone.
+    """Devuelve la hora actual en una zona horaria específica.
+
     Args:
-        timezone: A string representing a valid timezone (e.g., 'America/New_York').
+        timezone: Una cadena que representa una zona horaria válida (ej. 'America/New_York').
+
+    Returns:
+        La hora local actual en la zona horaria especificada.
     """
     try:
-        # Create timezone object
         tz = pytz.timezone(timezone)
-        # Get current time in that timezone
         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
-        return f"The current local time in {timezone} is: {local_time}"
+        return f"La hora local actual en {timezone} es: {local_time}"
     except Exception as e:
-        return f"Error fetching time for timezone '{timezone}': {str(e)}"
+        return f"Error obteniendo la hora para la zona horaria '{timezone}': {str(e)}"
 
 
 final_answer = FinalAnswerTool()
 
-# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
-# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 
-
-model = HfApiModel(
-max_tokens=2096,
-temperature=0.5,
-model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
-custom_role_conversions=None,
-)
-
-
 # Import tool from Hub
 image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
-with open("prompts.yaml", 'r') as stream:
+with open("prompts.yaml", "r") as stream:
     prompt_templates = yaml.safe_load(stream)
-    
+
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, extract_metadata_from_url, scrape_webpage], ## add your tools here (don't remove final answer)
+    tools=[
+        final_answer,
+        extract_metadata_from_url,
+        scrape_webpage,
+        save_scraped_data_as_markdown,  # Se añade la nueva herramienta al agente
+    ],
     max_steps=6,
     verbosity_level=1,
     grammar=None,
     planning_interval=None,
     name=None,
     description=None,
-    prompt_templates=prompt_templates
+    prompt_templates=prompt_templates,
 )
 
-
-GradioUI(agent).launch()
+GradioUI(agent).launch()