Smolagentes de Cara Abrazada: Una guía con ejemplos

smolagents de Hugging Face es una nueva biblioteca Python que simplifica la creación de agentes de IAhaciéndolos más accesibles a los desarrolladores.

En este blog, te presentaré la biblioteca smolagents, te explicaré por qué es útil y te guiaré a través de un proyecto de demostración para mostrar sus capacidades. 

¿Qué son los Smolagents de Hugging Face?

Como se describe en el de Hugging Facesmolagents es "una biblioteca muy sencilla que desbloquea las capacidades agénticas de los modelos lingüísticos". Pero, ¿por qué necesitamos bibliotecas para construir agentes?

En el fondo, los agentes se basan en LLM para resolver dinámicamente una tarea observando su entorno, haciendo planes y ejecutándolos con las herramientas de que disponen. Construir estos agentes, aunque no es imposible, requiere que escribas desde cero muchos componentes. Estos componentes garantizan que los agentes funcionen correctamente sin consumir tu crédito de API ni tiempo de ejecución. Los marcos agenticos facilitan esto para que no tengas que reinventar las ruedas.

A menudo se critican los marcos de agentes de IA con dos puntos:

1. Construyen demasiadas capas de abstracción, lo que las hace rígidas y difíciles de depurar.
2. Se centran en "flujos de trabajo" en lugar de construir agentes que puedan colaborar dinámicamente por sí mismos.

Por otra parte, los smolagentes tienen cualidades que los hacen muy prometedores para estas aplicaciones agénticas:

• Las abstracciones del marco se mantienen al mínimo.
• Mientras que la mayoría de los marcos hacen que los agentes definan sus acciones en formato JSON/texto, el enfoque principal de smolagents es Agentes de Código en el que las acciones se escriben como fragmentos de código Python (esto es diferente de los agentes que escriben código).
• Al ser un framework de Cara Abrazada, smolagents se integra bien con el Hub y la biblioteca Transformers. Puedes utilizar muchos modelos del hub (algunos de ellos sólo puedes utilizarlos como usuario Pro), y también puedes trabajar con modelos propietarios de OpenAI, Anthropic, etc.
• Puedes utilizar fácilmente las herramientas ya proporcionadas, o definir tus herramientas personalizadas con un esfuerzo mínimo, casi tan sencillo como escribir una función de Python.

Estas cualidades son las que, sobre el papel, hacen que los smolagentes se puedan conectar a los agentes de IA con poco esfuerzo, así que veamos si se mantienen en la práctica.

Construir un proyecto de demostración con Smolagents

En esta sección, construiremos una demostración sencilla con smolagents. Nuestra aplicación hará que un agente consiga el periódico más votado en la Cara Abrazada Documentos diarios página. Construimos nuestras herramientas personalizadas para el agente y vemos cómo funcionan en acción.

Daily Papers, una buena fuente para estar al día de los principales trabajos de investigación diarios.

Configurar smolagents

Para utilizar smolagents, sólo tienes que instalar la biblioteca y proporcionar un token de Cara Abrazada. La facilidad de configuración del marco es un punto positivo.

Para instalar el paquete, ejecuta

pip install smolagents

Construir herramientas personalizadas

Aunque el marco proporciona herramientas integradas que puedes utilizar directamente (por ejemplo, DuckDuckGoSearchTool), crear tus propias herramientas es igual de sencillo. Para nuestro propósito, construimos cuatro herramientas, cada una para un fin concreto:

• Conseguir el título del diario más importante.
• Obtener la identificación del documento utilizando su título.
• Descargar el artículo de arXiv con el ID.
• Leer el archivo PDF descargado.

Una causa común de los errores de los agentes es el uso de herramientas. Para optimizar las herramientas con fines agénticos, es importante asegurarse de que los agentes entienden claramente qué herramienta utilizar y cómo utilizarla. Para conseguirlo, sé lo más explícito posible al definir estas herramientas:

• Elige un nombre informativo para la función.
• Las entradas y salidas de la función deben tener indicaciones de tipo.
• Debe incluirse una descripción de la finalidad de la herramienta. Esto sirve de manual al agente.

Ahora vamos a construir nuestra primera herramienta personalizada para analizar la página de los periódicos del día y obtener el título del periódico principal:

from smolagents import tool 
# import packages that are used in our tools
import requests
from bs4 import BeautifulSoup
import json

@tool
def get_hugging_face_top_daily_paper() -> str:
    """
    This is a tool that returns the most upvoted paper on Hugging Face daily papers.
    It returns the title of the paper
    """
    try:
      url = "<https://huggingface.co/papers>"
      response = requests.get(url)
      response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
      soup = BeautifulSoup(response.content, "html.parser")

      # Extract the title element from the JSON-like data in the "data-props" attribute
      containers = soup.find_all('div', class_='SVELTE_HYDRATER contents')
      top_paper = ""

      for container in containers:
          data_props = container.get('data-props', '')
          if data_props:
              try:
                  # Parse the JSON-like string
                  json_data = json.loads(data_props.replace('&quot;', '"'))
                  if 'dailyPapers' in json_data:
                      top_paper = json_data['dailyPapers'][0]['title']
              except json.JSONDecodeError:
                  continue

      return top_paper
    except requests.exceptions.RequestException as e:
      print(f"Error occurred while fetching the HTML: {e}")
      return None

Fíjate en el decorador @tool, la clara denominación de la herramienta, las sugerencias de tipo y el docstring. Del mismo modo, definimos la herramienta get_paper_id_by_title para obtener el ID del artículo por su título, de modo que podamos descargarlo de arXiv. Para esta herramienta, utilizamos la API de Hugging Face.

from huggingface_hub import HfApi

@tool
def get_paper_id_by_title(title: str) -> str:
    """
    This is a tool that returns the arxiv paper id by its title.
    It returns the title of the paper

    Args:
        title: The paper title for which to get the id.
    """
    api = HfApi()
    papers = api.list_papers(query=title)
    if papers:
        paper = next(iter(papers))
        return paper.id
    else:
        return None

La descarga del documento utilizando su ID puede hacerse mediante el paquete Python arxiv. Guardamos el papel localmente con un nombre determinado, que utilizamos después para leerlo:

import arxiv

@tool
def download_paper_by_id(paper_id: str) -> None:
    """
    This tool gets the id of a paper and downloads it from arxiv. It saves the paper locally 
    in the current directory as "paper.pdf".

    Args:
        paper_id: The id of the paper to download.
    """
    paper = next(arxiv.Client().results(arxiv.Search(id_list=[paper_id])))
    paper.download_pdf(filename="paper.pdf")
    return None

Para leer un archivo PDF, puedes utilizar el paquete pypdf. Sólo leeremos las tres primeras páginas del documento para ahorrar en el uso de tokens.

from pypdf import PdfReader

@tool
def read_pdf_file(file_path: str) -> str:
    """
    This function reads the first three pages of a PDF file and returns its content as a string.
    Args:
        file_path: The path to the PDF file.
    Returns:
        A string containing the content of the PDF file.
    """
    content = ""
    reader = PdfReader('paper.pdf')
    print(len(reader.pages))
    pages = reader.pages[:3]
    for page in pages:
        content += page.extract_text()
    return content

Si defines herramientas personalizadas y al agente le cuesta utilizarlas correctamente o pasar los argumentos adecuados, considera la posibilidad de hacer que los nombres de las funciones y variables, así como las descripciones de las herramientas, sean más claros y explícitos.

Ejecutar el Agente

Con nuestras herramientas configuradas, ahora podemos inicializar y ejecutar nuestro agente. Utilizamos el modelo Qwen2.5-Coder-32B-Instruct, que es de uso gratuito. Las herramientas que necesita un agente se pueden pasar al definir el agente. Puedes ver que el proceso de definición y ejecución de un agente requiere un código mínimo:

from smolagents import CodeAgent, HfApiModel

model_id = "Qwen/Qwen2.5-Coder-32B-Instruct"

model = HfApiModel(model_id=model_id, token=<YOUR-API>)
agent = CodeAgent(tools=[get_hugging_face_top_daily_paper,
                         get_paper_id_by_title,
                         download_paper_by_id,
                         read_pdf_file],
                  model=model,
                  add_base_tools=True)

agent.run(
    "Summarize today's top paper on Hugging Face daily papers by reading it.",
)

A medida que el agente actúa, emite su proceso paso a paso. Esto nos permite ver cómo define sus acciones en código mientras utiliza las herramientas personalizadas que le hemos proporcionado:

Salida del agente en el paso 0

El agente puede terminar de leer el documento en el primer paso (Paso 0). En el segundo paso, el modelo enumera los puntos clave del documento, de nuevo, en una lista Python.

Resultado del agente en el paso 1

En el tercer paso (Paso 2), el agente crea un resumen de los puntos clave y lo imprime en el paso final (Paso 3).

Salida del agente en los pasos 2, 3.

El agente fue capaz de identificar qué herramientas utilizar en cada paso y terminó la tarea sin errores. Ten en cuenta que toda la canalización podría optimizarse para utilizar menos herramientas, pero tenía curiosidad por comprobar cómo utiliza el agente las múltiples llamadas a herramientas.

En tareas más exigentes, que requieran un razonamiento más complejo o el uso de herramientas, también puedes utilizar modelos más capaces como columna vertebral de tus agentes, como los que ofrecen OpenAI o Claude.

Conclusión

¿Qué es lo que buscas en un marco agencial? Tu respuesta deja claro cuál utilizar, pero si se trata de un marco sencillo que no esté hinchado por abstracciones, te dé control, tenga buenas integraciones y proporcione lo básico sin coger el timón, entonces smolagents es una buena opción para probar.

Estar bien integrado en el ecosistema de Hugging Face significa tener más modelos y herramientas a mano, además del apoyo de la comunidad de código abierto. El marco funciona bien en lo que promete. Podría beneficiarse de más herramientas integradas, y podemos cruzar los dedos para ver que eso ocurre mientras se desarrolla.

Si tienes curiosidad por leer más sobre los agentes de IA y los smolagentes, no te pierdas estos recursos:

• Introducción a los Agentes de IA: Primeros pasos con Auto-GPT, AgentGPT y BabyAGI
• Comprender a los agentes de IA: El futuro de los sistemas autónomos
• Documentación de Smolagents: 
• Repositorio Smolagents