AGENIC AI 101: Comenzando su viaje construyendo agentes de IA

La industria de inteligencia artificial se está moviendo rápidamente. Es impresionante y muchas veces abrumador.

He estado estudiando, aprendiendo y construyendo mis cimientos en esta área de ciencia de datos porque creo que el futuro de la ciencia de los datos está fuertemente correlacionado con el desarrollo de la IA generativa.

Fue solo el otro día cuando construí mi primera Agente de IAy luego un par de semanas después de eso, había varios paquetes de Python para elegir, sin mencionar las opciones de no código que están funcionando muy bien, como n8n.

De modelos “meros” que podrían chatear con nosotros hasta un tsunami de agentes de IA que están en todas partes, buscando en Internet, manejando archivos y haciendo todo Ciencia de datos Proyectos (desde EDA hasta modelado y evaluación), todo eso sucedió en solo un par de años.

¿Qué?

Al ver todo eso, mi pensamiento fue: “Necesito subir a bordo lo antes posible”. Después de todo, es mejor navegar por la ola que ser tragada por ella.

Por esa razón, decidí comenzar esta serie de publicaciones en las que planeo pasar de los fundamentos para construir nuestro primer agente de IA, hasta conceptos más complejos.

Basta de conversación, buceemos.

Los conceptos básicos de los agentes de IA

Se crea un agente de IA cuando damos el LLM El poder de interactuar con las herramientas y realizar acciones útiles para nosotros. Entonces, en lugar de ser solo un chatbot, ahora puede programar citas, cuidar nuestro calendario, buscar en Internet, escribir publicaciones en las redes sociales y la lista continúa …

Los agentes de IA pueden hacer cosas útiles, no solo chatear.

Pero, ¿cómo podemos dar ese poder a un LLM?

La respuesta simple es usar una API para interactuar con el LLM. Hay varios paquetes de Python para eso hoy en día. Si sigues mi blog, verás que ya he probado un par de paquetes para construir agentes: Langchain, Agno (ex phidata) y Crewai, por ejemplo. Para esta serie, me quedaré con Agno [1].

Primero, configure un entorno virtual utilizando uvAnaconda, o el manejador ambiental de su preferencia. A continuación, instale los paquetes.

# Agno AI
pip install agno

# module to interact with Gemini
pip install google-generativeai

# Install these other packages that will be needed throughout the tutorial
 pip install agno groq lancedb sentence-transformers tantivy youtube-transcript-api

Nota rápida antes de continuar. No olvides obtener una llave de API de Google Gemini [2].

Crear un agente simple es muy simple. Todos los paquetes son muy similares. Ellos tienen una clase Agent o algo similar que nos permita seleccionar un modelo y comenzar a interactuar con el LLM de nuestra elección. Aquí están los componentes principales de esta clase:

model: La conexión con el LLM. Aquí elegiremos entre Operai, Gemini, Llama, Deepseek, etc.
description: Este argumento nos permite describir el comportamiento del agente. Esto se agrega al system_messageque es un argumento similar.
instructions: Me gusta pensar en un agente como un empleado o un asistente que estamos administrando. Para realizar una tarea, debemos proporcionar las instrucciones de lo que debe hacerse. Aquí es donde puedes hacer eso.
expected_output: Aquí podemos dar instrucciones sobre la salida esperada.
tools: Esto es lo que hace que el LLM sea un agente, lo que le permite interactuar con el mundo real utilizando estas herramientas.

Ahora, creemos un agente simple que no tenga herramientas, pero servirá para construir nuestra intuición en torno a la estructura del código.

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Answer in a maximum of 2 sentences."],
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC in May?")

# Print response
print(response.content)

########### OUTPUT ###############
Expect mild temperatures in NYC during May, typically ranging from the low 50s 
to the mid-70s Fahrenheit.  
There's a chance of rain, so packing layers and an umbrella is advisable.

Eso es genial. Estamos utilizando el modelo Gemini 1.5. Observe cómo responde en función de los datos en los que fue entrenado. Si le pedimos que nos diga el clima hoy, veremos una respuesta diciendo que no puede acceder a Internet.

Exploremos el instructions y expected_output argumentos. Ahora queremos una mesa con el mes, la temporada y la temperatura promedio para Nueva York.

# Imports
from agno.agent import Agent
from agno.models.google import Gemini
import os

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
    description= "An assistant agent",
    instructions= ["Be sucint. Return a markdown table"],
    expected_output= "A table with month, season and average temperature",	
    markdown= True
    )

# Run agent
response = agent.run("What's the weather like in NYC for each month of the year?")

# Print response
print(response.content)

Y ahí está el resultado.

Mes	Estación	Temperatura promedio (° F)
Enero	Invierno	32
Febrero	Invierno	35
Marzo	Primavera	44
Abril	Primavera	54
Puede	Primavera	63
Junio	Verano	72
Julio	Verano	77
Agosto	Verano	76
Septiembre	Otoño	70
Octubre	Otoño	58
Noviembre	Otoño	48
Diciembre	Invierno	37

Herramientas

Las respuestas anteriores son buenas. Pero, naturalmente, no queremos usar modelos poderosos como LLMS para jugar con un chatbot o contarnos viejas noticias, ¿verdad?

Queremos que sean un puente para la automatización, la productividad y el conocimiento. Entonces, el Herramientas Agregará capacidades a nuestros agentes de IA, construyendo, por lo tanto, el puente con el mundo real. Los ejemplos comunes de herramientas para los agentes son: buscar en la web, ejecutar SQL, enviar un correo electrónico o llamar a las API.

Pero más que eso, podemos crear capacidades personalizadas para nuestros agentes utilizando cualquier función de Python como herramienta.

Herramientas son funciones que un agente puede ejecutar para lograr tareas.

En términos de código, agregar una herramienta al agente es solo una cuestión de usar el argumento. tools en el Agent clase.

Imagine un solopreneur (empresa de una sola persona) en el negocio de la vida saludable que quiere automatizar su generación de contenido. Esta persona publica consejos sobre hábitos saludables todos los días. Sé con certeza que la generación de contenido no es tan sencilla como parece. Exige habilidades de creatividad, investigación y redacción. Entonces, si esto pudiera automatizarse, o al menos parte de él, eso es ahorrado por el tiempo.

Por lo tanto, escribimos este código para crear un agente muy simple que pueda generar una publicación simple de Instagram y guardarlo en un archivo de Markdown para nuestra revisión. Redujimos el proceso de pensar> Investigación> Escritura> Revisión> Publicación a revisión> Publicación.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.tools.file import FileTools

# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are a social media marketer specialized in creating engaging content.",
                  tools=[FileTools(
                      read_files=True, 
                      save_files=True
                      )],
                  show_tool_calls=True)


# Writing and saving a file
agent.print_response("""Write a short post for instagram with tips and tricks
                        that positions me as an authority in healthy eating 
                        and save it to a file named 'post.txt'.""",
                     markdown=True)

Como resultado, tenemos lo siguiente.

Unlock Your Best Self Through Healthy Eating:

1. Prioritize whole foods: Load up on fruits, vegetables, lean proteins, and whole
 grains.  They're packed with nutrients and keep you feeling full and energized.
2. Mindful eating:  Pay attention to your body's hunger and fullness cues. 
Avoid distractions while eating.
3. Hydrate, hydrate, hydrate: Water is crucial for digestion, energy levels, 
and overall health.
4. Don't deprive yourself:  Allow for occasional treats.  
Deprivation can lead to overeating later.  Enjoy everything in moderation!
5. Plan ahead:  Prep your meals or snacks in advance to avoid unhealthy 
impulse decisions.

#healthyeating #healthylifestyle #nutrition #foodie 
#wellbeing #healthytips #eatclean #weightloss #healthyrecipes 
#nutritiontips #instahealth #healthyfood #mindfuleating #wellnessjourney 
#healthcoach

Ciertamente, podríamos hacer que sea mucho más elegante creando un equipo con otros agentes para buscar una lista de sitios web para contenido, un verificador de contenido y un revisor, y otro para generar una imagen para la publicación. Pero creo que tienes la idea general de cómo agregar un tool a un Agent.

Otro tipo de herramienta que podemos agregar es el función herramienta. Podemos usar una función de Python para servir como herramienta para el LLM. Simplemente no olvides agregar el tipo de pistas como video_id:strpor lo que el modelo sabe qué usar como entrada de la función. De lo contrario, puede ver un error.

Veamos brevemente cómo funciona.

Ahora queremos que nuestro agente pueda obtener un video de YouTube dado y resumirlo. Para realizar una tarea de este tipo, simplemente creamos una función que descarga la transcripción del video de YT y la pasa al modelo para resumir.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from youtube_transcript_api import YouTubeTranscriptApi

# Get YT transcript
def get_yt_transcript(video_id:str) -> str:
      
    """
    Use this function to get the transcript from a YouTube video using the video id.

    Parameters
    ----------
    video_id : str
        The id of the YouTube video.
    Returns
    -------
    str
        The transcript of the video.
    """

    # Instantiate
    ytt_api = YouTubeTranscriptApi()
    # Fetch
    yt = ytt_api.fetch(video_id)
    # Return
    return ''.join([line.text for line in yt])


# Create agent
agent = Agent(
    model= Gemini(id="gemini-1.5-flash",
                  api_key = os.environ.get("GEMINI_API_KEY")),
                  description= "You are an assistant that summarizes YouTube videos.",
                  tools=[get_yt_transcript],
                  expected_output= "A summary of the video with the 5 main points and 2 questions for me to test my understanding.",
                  markdown=True,
                  show_tool_calls=True)


# Run agent
agent.print_response("""Summarize the text of the video with the id 'hrZSfMly_Ck' """,
                     markdown=True)

Y luego tienes un resultado.

Resultado del resumen solicitado. Imagen del autor.

Agentes con razonamiento

Otra opción genial del paquete Agno nos permite crear fácilmente agentes que puedan analizar la situación antes de responder una pregunta. Esa es la herramienta de razonamiento.

Crearemos un agente de razonamiento con el modelo QWEN-QWQ-32B de Alibaba. Observe que la única diferencia aquí, además del modelo, es que estamos agregando la herramienta ReasoningTools().

El adding_instructions=True significa proporcionar instrucciones detalladas al agente, lo que mejora la confiabilidad y precisión del uso de su herramienta, al tiempo que establece esto en False obliga al agente a depender de su propio razonamiento, que puede ser más propenso a los errores.

# Imports
import os
from agno.agent import Agent
from agno.models.groq import Groq
from agno.tools.reasoning import ReasoningTools


# Create agent with reasoning
agent = Agent(
    model= Groq(id="qwen-qwq-32b",
                  api_key = os.environ.get("GROQ_API_KEY")),
                  description= "You are an experienced math teacher.",
                  tools=[ReasoningTools(add_instructions=True)],
                  show_tool_calls=True)


# Writing and saving a file
agent.print_response("""Explain the concept of sin and cosine in simple terms.""",
                     stream=True,
                     show_full_reasoning=True,
                     markdown=True)

Sigue la salida.

Salida del modelo de razonamiento. Imagen del autor.

Agente con conocimiento

Esta herramienta es la forma más fácil de crear una generación aumentada de recuperación (RAG). Con esta función, puede apuntar al agente a un sitio web o una lista de sitios web, y agregará el contenido a una base de datos vectorial. Entonces, se puede buscar. Una vez preguntado, el agente puede usar el contenido como parte de la respuesta.

En este simple ejemplo, agregué una página de mi sitio web y le pregunté al agente qué libros se enumeran allí.

# Imports
import os
from agno.agent import Agent
from agno.models.google import Gemini
from agno.knowledge.url import UrlKnowledge
from agno.vectordb.lancedb import LanceDb, SearchType
from agno.embedder.sentence_transformer import SentenceTransformerEmbedder

# Load webpage to the knowledge base
agent_knowledge = UrlKnowledge(
    urls=["https://gustavorsantos.me/?page_id=47"],
    vector_db=LanceDb(
        uri="tmp/lancedb",
        table_name="projects",
        search_type=SearchType.hybrid,
        # Use Sentence Transformer for embeddings
        embedder=SentenceTransformerEmbedder(),
    ),
)

# Create agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    instructions=[
        "Use tables to display data.",
        "Search your knowledge before answering the question.",
        "Only inlcude the content from the agent_knowledge base table 'projects'",
        "Only include the output in your response. No other text.",
    ],
    knowledge=agent_knowledge,
    add_datetime_to_instructions=True,
    markdown=True,
)

if __name__ == "__main__":
    # Load the knowledge base, you can comment out after first run
    # Set recreate to True to recreate the knowledge base if needed
    agent.knowledge.load(recreate=False)
    agent.print_response(
        "What are the two books listed in the 'agent_knowledge'",
        stream=True,
        show_full_reasoning=True,
        stream_intermediate_steps=True,
    )

Respuesta del agente después de buscar en la base de conocimiento. Imagen del autor.

Agente con memoria

El último tipo que pasaremos en esta publicación es el agente con memoria.

Este tipo de agente puede almacenar y recuperar información sobre usuarios de interacciones anteriores, lo que le permite aprender las preferencias del usuario y personalizar sus respuestas.

Veamos este ejemplo en el que le diré un par de cosas al agente y solicitaré recomendaciones basadas en esa interacción.

# imports
import os
from agno.agent import Agent
from agno.memory.v2.db.sqlite import SqliteMemoryDb
from agno.memory.v2.memory import Memory
from agno.models.google import Gemini
from rich.pretty import pprint

# User Name
user_id = "data_scientist"

# Creating a memory database
memory = Memory(
    db=SqliteMemoryDb(table_name="memory", 
                      db_file="tmp/memory.db"),
    model=Gemini(id="gemini-2.0-flash", 
                 api_key=os.environ.get("GEMINI_API_KEY"))
                 )

# Clear the memory before start
memory.clear()

# Create the agent
agent = Agent(
    model=Gemini(id="gemini-2.0-flash", api_key=os.environ.get("GEMINI_API_KEY")),
    user_id=user_id,
    memory=memory,
    # Enable the Agent to dynamically create and manage user memories
    enable_agentic_memory=True,
    add_datetime_to_instructions=True,
    markdown=True,
)


# Run the code
if __name__ == "__main__":
    agent.print_response("My name is Gustavo and I am a Data Scientist learning about AI Agents.")
    memories = memory.get_user_memories(user_id=user_id)
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("What topic should I study about?")
    agent.print_response("I write articles for Towards Data Science.")
    print(f"Memories about {user_id}:")
    pprint(memories)
    agent.print_response("Where should I post my next article?")

Ejemplo de agente de IA con memoria. Imagen del autor.

Y aquí terminamos esta primera publicación sobre los agentes de IA.

Antes de que te vayas

Hay mucho contenido en esta publicación. Subimos el primer paso en esta escalera de aprender sobre los agentes de IA. Lo sé, es abrumador. Hay tanta información por ahí que se vuelve cada vez más difícil saber por dónde empezar y qué estudiar.

Mi sugerencia es tomar el mismo camino que estoy tomando. Un paso a la vez, eligiendo solo un par de paquetes como Agno, Crewai y profundizando en esos, aprendiendo a crear agentes más complejos cada vez.

En esta publicación, comenzamos desde cero, aprendiendo a interactuar simplemente con un LLM para crear agentes con memoria, o incluso crear un trapo simple para un agente de IA.

Obviamente, hay mucho más que puede hacer con un solo agente. Mira la referencia [4].

Con estas simples habilidades, asegúrese de estar por delante de muchas personas, y ya hay muchas cosas que puedes hacer. Solo usa la creatividad y (¿por qué no?) Pida la ayuda de un LLM para construir algo genial!

En la próxima publicación, aprenderemos más sobre agentes y evaluación. ¡Manténganse al tanto!