from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, load_tool, tool import datetime import requests import pytz import yaml 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 # 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 summarize_text(text: str) -> str: """ Resumir texto utilizando la API de Hugging Face. Args: text (str): El texto que se desea resumir. Returns: str: El resumen generado o un mensaje de error en caso de fallo. """ API_URL = "https://api-inference.huggingface.co/models/facebook/bart-large-cnn" headers = {"Authorization": f"Bearer TU_HUGGINGFACE_API_KEY"} payload = { "inputs": text, "parameters": {"max_length": 150, "min_length": 50, "do_sample": False}, } response = requests.post(API_URL, headers=headers, json=payload) if response.status_code == 200: return response.json()[0]["summary_text"] else: return "Error en el resumen" @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 (str): URL de la página a scrapear. tag (str): Etiqueta HTML a extraer (por defecto "p"). class_name (str, optional): Clase CSS opcional para filtrar resultados. Returns: dict: Diccionario con el contenido extraído. Contiene las claves: - "url": La URL consultada. - "scraped_data": Lista de fragmentos de texto extraídos (máximo 20). En caso de error, devuelve una clave "error" con el mensaje correspondiente. """ try: headers = {"User-Agent": "Mozilla/5.0"} response = requests.get(url, headers=headers) response.raise_for_status() soup = BeautifulSoup(response.text, "html.parser") if class_name: elements = soup.find_all(tag, class_=class_name) else: elements = soup.find_all(tag) extracted_data = [element.get_text(strip=True) for element in elements] 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)}"} except Exception as e: return {"error": f"Error inesperado: {str(e)}"} @tool def extract_metadata_from_url(url: str) -> dict: """ Extrae todos los metadatos de una página web. Args: url (str): La URL de la página web a analizar. Returns: dict: Diccionario con los metadatos encontrados. Si no se encuentran metadatos, devuelve un diccionario con la clave "error" y el mensaje correspondiente. """ try: headers = {"User-Agent": "Mozilla/5.0"} response = requests.get(url, headers=headers) response.raise_for_status() soup = BeautifulSoup(response.text, "html.parser") 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"] 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 save_scraped_data_as_markdown(scraped_data: dict, filename: str = None) -> str: """ Guarda el contenido scrapeado en un archivo Markdown bien formateado. Args: scraped_data (dict): Diccionario que contiene: - "url" (str): La URL de la página de la cual se extrajo el contenido. - "scraped_data" (list[str]): Lista de fragmentos de texto extraídos. filename (str, optional): Nombre del archivo Markdown de salida. Si no se proporciona, se genera uno usando la fecha y hora actual. Returns: str: Mensaje indicando si el archivo se guardó correctamente o si ocurrió algún error. """ try: url = scraped_data.get("url", "Unknown") content_list = scraped_data.get("scraped_data", []) if not content_list: return "No data available to save in Markdown." formatted_content = "\n\n".join(content_list) # Construir el contenido Markdown markdown_content = f"# Content extracted from {url}\n\n" markdown_content += "## Full Content\n\n" markdown_content += formatted_content # Generar un nombre de archivo 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" with open(filename, "w", encoding="utf-8") as file: file.write(markdown_content) return f"Scraped content has been saved in {filename}" except Exception as e: return f"Error generating Markdown file: {str(e)}" @tool def get_current_time_in_timezone(timezone: str) -> str: """ Devuelve la hora actual en una zona horaria específica. Args: timezone (str): Una cadena que representa una zona horaria válida (ej. "America/New_York"). Returns: str: La hora local actual en la zona horaria especificada o un mensaje de error si falla. """ try: tz = pytz.timezone(timezone) local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S") return f"La hora local actual en {timezone} es: {local_time}" except Exception as e: return f"Error obteniendo la hora para la zona horaria '{timezone}': {str(e)}" final_answer = FinalAnswerTool() # Importar herramienta desde Hub image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True) 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, save_scraped_data_as_markdown, # Se añade la nueva herramienta al agente # Puedes añadir también otras herramientas como summarize_text si lo deseas ], max_steps=6, verbosity_level=1, grammar=None, planning_interval=None, name=None, description=None, prompt_templates=prompt_templates, ) GradioUI(agent).launch()