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.

Síguenos y añádenos como fuente favorita en Google.

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 creé mi primer agente de IA , y dos semanas después había muchísimos paquetes de Python para elegir, por no hablar de las opciones sin código que dan muy buenos resultados, como n8n.

Desde simples modelos que pueden conversar con nosotros hasta un tsunami de agentes de IA que están por todas partes, buscando en internet, manejando archivos y ejecutando proyectos completos de ciencia de datos (desde la exploración inicial de datos hasta el modelado y la evaluación), todo esto ha sucedido en tan solo unos pocos años.

preciosidad

Al ver todo esto, pensé: "Tengo que unirme cuanto antes ". Al fin y al cabo, es mejor aprovechar la oportunidad que ser arrastrado 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 breve nota antes de continuar: No olvide obtener la 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)

## ...

En Nueva York, durante mayo, se esperan temperaturas suaves, generalmente entre los 10 y los 24 grados Celsius. Es posible que llueva, por lo que se recomienda vestirse por capas y llevar 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 sirva de puente hacia la automatización, la productividad y el conocimiento. Por lo tanto, estas herramientas añadirán capacidades a nuestros agentes de IA, creando así un vínculo con el mundo real. Algunos ejemplos comunes de herramientas para agentes incluyen: búsqueda web, ejecución de SQL, envío de correos electrónicos o llamadas 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.

Las 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. Prioriza los alimentos integrales: Consume abundantes frutas, verduras, proteínas magras y cereales integrales. Son ricos en nutrientes y te mantendrán saciado y con energía.

2. Come con atención plena: Presta atención a las señales de hambre y saciedad de tu cuerpo. Evita las distracciones mientras comes.

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

4. No te prives: Permítete algún dulce de vez en cuando. La privación puede llevar a comer en exceso más tarde. ¡ 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 característica del paquete Agno es la capacidad de crear agentes que pueden analizar una situación antes de responder una pregunta. Se trata de una herramienta de inferencia. Consulta los 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 concluye nuestro primer artículo sobre agentes de inteligencia artificial . Esperamos que haya proporcionado una útil visión general 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!