Guía de IA de autoacción: comience su camino hacia la creación de agentes de IA

Aprenda los conceptos básicos sobre cómo crear agentes de IA. Descubra las herramientas y técnicas necesarias para diseñar e implementar estos sistemas inteligentes.

La industria de la inteligencia artificial está experimentando rápidos avances. Es impresionante y a menudo confuso.

He estado estudiando, aprendiendo y construyendo mi base en esta área de la ciencia de datos porque creo que el futuro de la ciencia de datos está estrechamente vinculado al desarrollo de la IA generativa.

Parece que fue ayer cuando construí mi primer Agente de IAY dos semanas después, había muchos paquetes de Python para elegir, sin mencionar opciones sin código que funcionaron muy bien, como n8n.

Desde simples modelos que pueden chatear con nosotros hasta un tsunami de agentes de IA que están en todas partes, buscando en Internet, manejando archivos y ejecutando proyectos. Ciencia de datos Todo el proceso (desde la exploración inicial de datos hasta el modelado y la evaluación) ocurrió en apenas unos años.

preciosidad

Al ver todo esto, mis pensamientos fueron: “Necesito unirme lo antes posible.”. Al final, es mejor surfear la ola que dejarse tragar por ella.

Por este motivo, decidí iniciar esta serie de posts donde planeo pasar de lo básico a construir nuestro primer agente de IA, hasta llegar a conceptos más complejos.

Ya basta de hablar, vamos a seguir adelante.

Conceptos básicos del agente de IA

Un agente de IA se crea cuando le damos a un modelo de lenguaje grande (LLM) la capacidad de interactuar con herramientas y realizar acciones que nos resultan útiles. En lugar de ser simplemente un chatbot, ahora puede programar citas, administrar nuestro calendario, buscar en Internet, escribir publicaciones en redes sociales, y la lista continúa... Esta transformación lo convierte en un asistente digital completo.

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

Pero ¿cómo podemos darle este poder a un modelo de lenguaje grande (LLM)?

La respuesta simple es utilizar una API para interactuar con el modelo de lenguaje grande. Hoy en día existen muchos paquetes de Python para esto. Si sigues mi blog, verás que ya he experimentado con un par de paquetes para crear agentes: Langchain, Agno (antes Phidata) y CrewAI, por ejemplo. Para esta serie me quedaré con Agno[1].

Primero, configure un entorno virtual utilizando uv O Anaconda o tu procesador de entorno favorito. 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

Una nota rápida antes de continuar. No olvides obtener tu clave API de Google Gemini [2].

Crear un proxy simple es muy fácil. 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 modelo de lenguaje más grande de nuestra elección. Estos son los componentes principales de esta categoría:

model:Conéctese al modelo de lenguaje grande. Aquí elegiremos entre OpenAI, Gemini, Llama, Deepseek, etc.
descriptionEste parámetro nos permite describir el comportamiento del agente. Esto se añade a system_message, que es un medio similar.
instructionsMe gusta pensar en un agente como un empleado o asistente que gestionamos. Para realizar una tarea, debemos dar instrucciones sobre qué hacer. Aquí puedes hacerlo.
expected_outputAquí podemos proporcionar instrucciones sobre el resultado esperado.
toolsEsto es lo que hace que un modelo de lenguaje grande sea un agente, permitiéndole interactuar con el mundo real utilizando estas herramientas.

Ahora, vamos a crear un agente simple que no tiene herramientas, pero que servirá para construir nuestra intuición sobre 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)

## ...

Se esperan temperaturas moderadas en Nueva York durante mayo, que generalmente oscilan entre los 50 y los 70 grados Fahrenheit. Existe posibilidad de lluvia, por lo que es recomendable llevar capas de ropa y paraguas.

Esto es genial. Utilizamos el modelo Gemini 1.5. Observe cómo responde en función de los datos con los que fue entrenado. Si le pedimos que nos diga el tiempo que hará hoy, veremos una respuesta diciendo que no puede acceder a Internet.

Exploremos los mediadores. instructionsyexpected_output. Ahora queremos una tabla con el mes, la estación y la temperatura promedio de la ciudad de Nueva York (NYC).

# 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 este es el resultado.

el mes	temporada	Temperatura media (°F)
Enero	Invierno	32
Febrero	Invierno	35
Marzo	Spring	44
Abril	Spring	54
Mayo	Spring	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 por supuesto no queremos usar modelos de lenguaje grandes y potentes (LLM) para jugar con un chatbot o que nos digan noticias viejas, ¿verdad?

Queremos que sea un puente hacia la automatización, la productividad y el conocimiento. Entonces, agregarás Herramientas capacidades a nuestros agentes de IA, construyendo así un puente con el mundo real. Algunos ejemplos comunes de agentes incluyen: buscar en la web, ejecutar SQL, enviar correos electrónicos o llamar a API.

Pero más que eso, podemos crear capacidades personalizadas para nuestros agentes utilizando cualquier función de Python como herramienta, abriendo vastas posibilidades de integración con diferentes sistemas y procesos.

Herramientas Son funciones que un agente puede ejecutar para realizar tareas.

En términos de código, agregar un widget a un agente es simplemente una cuestión de usar el middleware. tools en la categoría Agent.

Imagine una empresa unipersonal en el sector de la salud y el bienestar que desea automatizar la creación de contenidos. Esta persona publica consejos sobre hábitos saludables todos los días. Sé a ciencia cierta que crear contenido no es tan sencillo como parece. Requiere creatividad, investigación y habilidades de redacción. Entonces, si se puede automatizar, o al menos parte de ello, se ahorra tiempo.

Entonces, escribimos este código para crear un agente muy simple que pueda crear una publicación simple de Instagram y guardarla en un archivo Markdown para su revisión. Hemos reducido el proceso de pensar > investigar > escribir > revisar > publicar a revisar > publicar.

# 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.

Libera tu energía positiva comiendo saludable:

1. Priorice los alimentos integrales: coma muchas frutas, verduras, proteínas magras y cereales integrales. Son ricos en nutrientes y te hacen sentir lleno y lleno de energía.

2. Come conscientemente: presta atención a las señales de hambre y saciedad de tu cuerpo. Evite distracciones mientras come.

3. Beba mucha agua: el agua es esencial para la digestión, los niveles de energía y la salud general..

4. No te prives: Permítete algunos dulces de vez en cuando. La privación puede llevarnos a comer en exceso más adelante. ¡Disfruta de todo con moderación!

5. Planifique con anticipación: prepare sus comidas o refrigerios con anticipación para evitar tomar decisiones poco saludables.

#AlimentaciónSaludable #EstiloDeVidaSaludable #Nutrición #AmantesDeLaComida #SaludYBienestar #ConsejosSaludables #AlimentaciónLimpia #PérdidaDePeso #RecetasSaludables #ConsejosDeNutrición #SaludInstantánea #ComidaSaludable #AlimentaciónConsciente #ViajeSaludable #CoachDeSalud

Claro, podríamos hacerlo más complicado creando un equipo con otros agentes para buscar contenido en la lista de sitios web, un verificador y revisor de contenido, y otro para crear una imagen para la publicación. Pero creo que ya tienes la idea general de cómo agregar tool A Agent.

Otro tipo de herramienta que podemos agregar es: una herramienta herramienta de función. Podemos utilizar una función de Python para que actúe como herramienta para un modelo de lenguaje grande (LLM). No olvides añadir sugerencias de tipo como: video_id:str, para que el modelo sepa qué utilizar como entrada a la función. De lo contrario, es posible que aparezca un error.

Veamos brevemente cómo funciona esto.

Ahora queremos que nuestro agente pueda obtener un video específico de YouTube y resumirlo. Para realizar esta tarea, simplemente creamos una función que descarga la transcripción del video de YT y la pasa al modelo para su resumen.

# 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)

Entonces obtendrás un resultado.

Agentes con capacidad de razonar

Otra gran opción que ofrece Agno es la posibilidad de crear agentes que puedan analizar una situación antes de responder una pregunta. Esta es la herramienta de razonamiento. verificar Tipos de agentes de IA y sus usos: una explicación detallada.

Crearemos un agente de razonamiento utilizando el modelo Qwen-qwq-32b de Alibaba. Tenga en cuenta que la única diferencia aquí, además del modelo, es que estamos agregando el widget. ReasoningTools(). Esta herramienta permite al agente pensar lógicamente antes de proporcionar respuestas.

Propiedad significa adding_instructions=True Proporcionar al agente instrucciones detalladas, mejorando la confiabilidad y precisión del uso de la herramienta. Al establecer esta propiedad se obtendrá el siguiente resultado: False Obligar al agente a confiar en su propio razonamiento, que puede ser más propenso a errores. Esto permite evaluar de forma independiente las capacidades del modelo.

# 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)

A continuación se muestran los resultados.

agente proporcionado por conocimiento

Esta herramienta es la forma más sencilla de crear un sistema de recuperación de generación aumentada (RAG). Con esta función, puede dirigir al agente a un sitio web o una lista de sitios web y agregará el contenido a una base de datos vectorial. Después de esto, el contenido se podrá buscar. Cuando se le solicite, el agente puede usar el contenido como parte de la respuesta. Esta tecnología mejora la precisión y confiabilidad de las respuestas de la IA.

En este ejemplo sencillo, agregué una página de mi sitio web y le pregunté al agente qué libros estaban listados allí. Esto explica cómo el agente puede acceder y utilizar la información.

# 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,
    )

Agente habilitado para memoria

El último tipo que cubriremos en este artículo es el agente habilitado con memoria, un concepto fundamental en el campo de los agentes de IA.

Este tipo de agente tiene la capacidad de almacenar y recuperar información sobre los usuarios de interacciones anteriores, lo que le permite comprender las preferencias del usuario y personalizar sus respuestas. Esta memoria hace que el agente sea más efectivo en interacciones posteriores.

Veamos este ejemplo donde le diré algunas cosas al agente y le pediré recomendaciones en función de esa interacción. Esto demuestra cómo un agente con memoria habilitada puede mejorar la experiencia del usuario.

# 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?")

Con esto concluimos este primer artículo sobre Agentes de inteligencia artificial. Esperamos que esto haya proporcionado una descripción general útil de los diferentes tipos de agentes de IA.

Antes de partir

Este artículo contiene mucha información. Hemos dado el primer paso en la escalera del aprendizaje del agente de IA. Sé que puede ser confuso, hay tanta información disponible que puede ser difícil saber por dónde empezar y qué estudiar.

Mi sugerencia es que tomes la misma ruta que yo estoy tomando. Paso a paso, elija solo algunos paquetes como Agno y CrewAI, profundice en ellos y aprenda cómo crear agentes más complejos cada vez. Este enfoque gradual es el mejor para comprender conceptos complejos de IA.

En este artículo, comenzamos desde cero, aprendiendo cómo interactuar de forma sencilla con un modelo de lenguaje grande (LLM), hasta llegar a crear agentes con memoria, o incluso crear un sistema simple de aumento de recuperación (RAG) para un agente de IA. Estas habilidades básicas son esenciales para comprender cómo funcionan los agentes de IA.

Obviamente se pueden hacer muchas cosas con un solo agente. Consulte la referencia [4] para obtener ejemplos avanzados.

Con estas sencillas habilidades, seguramente estarás por delante de muchas personas, y ya hay muchas cosas que puedes hacer. Simplemente usa tu creatividad, ¿por qué no? ¡Pídele ayuda a un gran modelo de lenguaje para construir algo increíble! Utilice herramientas de IA para mejorar su creatividad.

En el próximo artículo, aprenderemos más sobre los agentes de IA y su evaluación. ¡No se lo pierdan!