La inteligencia artificial ha estado en auge últimamente con los agentes de IA. Muchas empresas han comenzado a desarrollar agentes e incorporarlos a sus negocios. La tendencia avanza tan rápido que prácticamente cualquier cosa puede convertirse en un agente. Cualquiera que busque entrar en este campo tiene una pregunta común «¿cómo empezar?«. Esta guía lo explicará en términos sencillos.
Tabla de contenidos
¿Qué es un agente de IA?
Un agente de IA es un programa de software que puede percibir tu entorno, procesar información y realizar acciones para completar tareas. Los agentes de IA están diseñados para operar con cierto grado de autonomía, lo que significa que pueden tomar decisiones y ejecutar acciones sin intervención humana constante. Los agentes de IA se pueden utilizar en diversos ámbitos, como la salud, las finanzas y la robótica.
Una de las principales fortalezas de los agentes de IA es su capacidad para optimizar la toma de decisiones, automatizar tareas repetitivas y personalizar la experiencia del usuario. Por ejemplo, un agente de IA puede gestionar su calendario programando reuniones, enviando recordatorios y priorizando eventos según sus preferencias. De igual manera, en atención al cliente, los agentes de IA pueden gestionar consultas, ofrecer recomendaciones y resolver problemas de forma eficiente.
¿Qué son las herramientas?
Al crear agentes, las herramientas son componentes esenciales que podemos usar para ampliar sus capacidades. Estas herramientas pueden considerarse recursos o funciones externas que permiten al agente resolver problemas y realizar tareas de forma más eficiente. Por ejemplo, existen herramientas como intérpretes de código, motores de búsqueda y bases de datos.
Elige los marcos adecuados
El siguiente paso es seleccionar los marcos adecuados para desarrollar nuestro agente. Los marcos que puedes utilizar se describen a continuación:
i) LangChain: LangChain proporciona herramientas esenciales para desarrollar agentes de IA. Estos agentes están diseñados con la capacidad de razonar, recuperar información e interactuar con entornos externos.
ii) LangGraph: LangGraph es una extensión de LangChain. Permite a los usuarios crear aplicaciones multiactor con estado utilizando grandes modelos de lenguaje.
iii) CrewAI: CrewAI es un potente marco para diseñar sistemas de IA multiagente donde diferentes agentes de IA colaboran para realizar tareas complejas.
iv) Smolagents: SmolAgents es un framework ligero diseñado para crear agentes de IA minimalistas que pueden interactuar con API, bases de datos y herramientas externas. Se centra en la simplicidad y la eficiencia, lo que lo convierte en una excelente opción para tareas de automatización de IA específicas y a pequeña escala.
v) AutoGPT: Diseñado para agentes de IA totalmente autónomos que realizan tareas con mínima intervención humana.
En mi próximo artículo, profundizaré en cada uno de estos frameworks. Estos frameworks son algunos de los mejores que puedes usar para crear tus agentes.
Ahora que entendemos qué es un agente, veamos cómo crear uno con LangGraph.
Construye un Agente ReAct Simple
Un Agente ReAct es un agente de IA que combina Razonamiento (Re) y Acción (Act) en un bucle interactivo para tomar decisiones. Al crear un Agente ReAct, el LLM primero pasa por una fase de razonamiento para determinar qué herramientas usar antes de generar la respuesta final.
En este tutorial, construiremos un Agente ReAct siguiendo los siguientes pasos clave:
- Configuración de la herramienta: Integración de diferentes herramientas, como la creación de una herramienta personalizada y el uso de una herramienta de búsqueda web.
- Creación del agente: Aprender a implementar y utilizar el Agente ReAct en LangChain.
Configuración de la herramienta
i) Obtener credenciales de API
- Crea una cuenta en la plataforma API de Live Score.
- Recupera tu api_key y api_secret de tu perfil.
- Guarda estas credenciales de forma segura en un archivo .env para la autenticación.
- Accede a la plataforma Open AI y configura una clave de API.
- Agrega también esta clave a tu archivo .env.
ii) Integrar la API
Nuestro objetivo es crear una herramienta personalizada que pueda recuperar todos los próximos partidos de fútbol de cualquier país. Para ello, utilizamos la API Live Score y consultamos el punto de acceso de partidos para obtener estos partidos.
El código a continuación muestra cómo consultar la API.
import requests
import os
from langchain.tools import tool
from dotenv import load_dotenv
load_dotenv() # Load API key from .env file
api_key = os.getenv("SPORT_api_key")
api_secret = os.getenv("SPORT_api_secret")
class FootballData:
"""
This is a class for retrieving football upcoming matches based on country name.
"""
def __init__(self):
self.BASE_URL = "https://livescore-api.com/api-client"
self.api_key = api_key
self.api_secret = api_secret
def get_country_id(self, country_name):
"""Fetch country ID by country name."""
url = f"{self.BASE_URL}/countries/list.json?key={self.api_key}&secret={self.api_secret}"
response = requests.get(url).json()
for country in response["data"]["country"]:
if country["name"].lower() == country_name.lower():
return country["id"]
return None
def get_competition_ids(self, country_id):
"""Fetch competition IDs for a given country ID."""
url = f"{self.BASE_URL}/competitions/list.json?key={self.api_key}&secret={self.api_secret}&country_id={country_id}"
response = requests.get(url).json()
return [comp["id"] for comp in response["data"]["competition"]]
def get_upcoming_fixtures(self, competition_ids):
"""Fetch upcoming matches for given competition IDs"""
fixtures = []
for comp_id in competition_ids:
url = f"{self.BASE_URL}/fixtures/matches.json?key={self.api_key}&secret={self.api_secret}&competition_id={comp_id}"
response = requests.get(url).json()
if "fixtures" in response["data"]:
fixtures.extend(response["data"]["fixtures"])
return fixtures
def get_upcoming_matches(self, country_name):
"""Get all upcoming matches and preprocess to take the information needed from result"""
country_id = self.get_country_id(country_name)
if not country_id:
return f"No country found with the name {country_name}"
competition_ids = self.get_competition_ids(country_id)
if not competition_ids:
return f"No competitions found for {country_name}"
fixtures = self.get_upcoming_fixtures(competition_ids)
if not fixtures:
return f"No upcoming fixtures found for {country_name}"
# Format the matches data
formatted_matches = []
for match in fixtures:
formatted_matches.append(
f"{match['home_name']} vs {match['away_name']} at {match['location']} - {match['date']}, {match['time']}"
)
return formatted_matches
iii) Definir la herramienta personalizada
La clase FootballData creada anteriormente se referenciará en el código a continuación. Podemos ver que estamos llamando al método get_upcoming_matches desde nuestra clase, responsable de obtener todos los partidos. Además, en nuestro código, podemos ver el decorador @tool en la función. Así es como creamos una herramienta personalizada: al usar el decorador @tool en cualquier función, esta se convierte en una herramienta de agente de IA que se puede llamar dinámicamente dentro de un framework de IA.
@tool
def get_upcoming_matches(query: str):
"""Use this tool to get upcoming football matches for a given country. Provide the country name as input."""
sport_tool = FootballData()
return sport_tool.get_upcoming_matches(query)
iv) Herramienta de búsqueda Tavily
La siguiente herramienta en el conjunto de herramientas de nuestro agente es la Herramienta de búsqueda Tavily. Esta herramienta es la que nuestro LLM utilizará para realizar búsquedas web en tiempo real.
from langchain_community.tools.tavily_search import TavilySearchResults
web_search = TavilySearchResults()
Luego, combinamos todas las herramientas: la herramienta personalizada “get_upcoming_matches” y la “Tavily Search Tool”.
tools = [get_upcoming_matches, web_search]
Ahora que las herramientas están listas, podemos proceder a la creación del agente, donde se integrarán para facilitar la toma de decisiones.
Creación del agente
Construiremos un agente ReAct, donde integraremos las herramientas en LangChain y permitiremos que nuestro LLM decida qué herramientas usar según la información proporcionada por el usuario.
i) Configuración de memoria y modelo
Inicializaremos el LLM utilizando gpt-4o-mini de ChatOpenAI como modelo y añadiremos un protector de memoria para conservar el historial de interacciones.
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent
# Memory and model configuration
memory = MemorySaver()
model = ChatOpenAI(model_name="gpt-4o-mini")
ii) Crear agente
Creamos el agente con la función «create_react_agent» en langGraph, pasando nuestras herramientas, modelo y memoria. A continuación, se muestra una representación visual del proceso de toma de decisiones del agente en forma de gráfico.
#create ReAct Agent
agent = create_react_agent(model, tools=tools, checkpointer=memory)
from IPython.display import Image, display
display (
Image(agent.get_graph().draw_mermaid_png())
)
Prueba tu agente
Ahora que nuestro agente está listo, lo probaremos enviando una consulta y solicitándole que realice algunas tareas. La configuración que ve a continuación es para el seguimiento de mensajes.
config = {"configurable": {"thread_id": "1"}}
inputs = {
"messages": [
(
"human",
"Search for all upcoming matches in England",
)
]
}
result = agent.stream(inputs, config=config, stream_mode="values")
for result in result:
message = result["messages"][-1]
message.pretty_print()Este es el resultado de la consulta «Buscar todos los próximos partidos en Inglaterra» que le hicimos al agente. En el resultado, podemos ver que el agente usó la herramienta correcta (get_upcoming_matches) para recuperar todos los próximos partidos.
Podemos hacer más pruebas formulando una pregunta diferente, no relacionada con el fútbol: veamos cómo actuaría el agente.
config = {"configurable": {"thread_id": "1"}}
inputs = {
"messages": [
(
"human",
"Search for top 10 italian cuisine",
)
]
}
result = agent.stream(inputs, config=config, stream_mode="values")
for result in result:
message = result["messages"][-1]
message.pretty_print()En el resultado a continuación, le pedimos al agente que buscara las 10 mejores cocinas italianas y completó la tarea con éxito utilizando la herramienta de búsqueda Tavily.
¡Gracias por leer! Nos vemos en la próxima.