Autor: Priya Sharma – Arquitecta de API y Consultora de Integración de IA
La capacidad de crear sistemas inteligentes que pueden entender instrucciones, razonar y actuar de forma autónoma está transformando nuestra interacción con la tecnología. En el corazón de esta transformación se encuentran los agentes de IA: entidades de software diseñadas para realizar tareas aprovechando el poder de los Modelos de Lenguaje Grande (LLMs) y herramientas externas. Aunque el concepto puede sonar complejo, marcos como LangChain han simplificado significativamente el proceso de desarrollo, haciendo que la creación de agentes sea accesible para un público más amplio.
Como arquitecta de API y consultora de integración de IA, he visto de primera mano el increíble potencial de los agentes de IA bien diseñados. Pueden automatizar flujos de trabajo complejos, proporcionar asistencia personalizada y desbloquear nuevas capacidades tanto para empresas como para individuos. Esta guía práctica te llevará a través del proceso de construcción de agentes de IA utilizando la API de LangChain, desde entender los componentes fundamentales hasta implementar ejemplos prácticos del mundo real. Al final, tendrás una base sólida para diseñar y desplegar tus propios agentes inteligentes, listos para enfrentar una multitud de desafíos.
Entendiendo los Agentes de IA y el Papel de LangChain
Antes de adentrarnos en el código, aclaremos qué es un agente de IA y por qué LangChain es una herramienta indispensable para su construcción. Un agente de IA es un sistema que utiliza un LLM como su “cerebro” para decidir qué acciones tomar. A diferencia de una simple llamada a un LLM que genera una única respuesta, un agente puede participar en un proceso de razonamiento en múltiples pasos:
- Percebir: Entender la entrada del usuario o el estado actual.
- Razonar: Determinar el mejor curso de acción basándose en su comprensión y en las herramientas disponibles.
- Actuar: Ejecutar una o más acciones utilizando herramientas externas.
- Aprender (opcional pero poderoso): Incorporar retroalimentación para mejorar el rendimiento futuro.
LangChain proporciona la estructura necesaria para construir estos agentes sofisticados. Ofrece una manera estructurada de conectar LLMs con diversas fuentes de datos y herramientas computacionales, permitiéndoles ir más allá de la simple generación de texto. Piensa en LangChain como el sistema operativo para tu agente de IA, proporcionando el marco para su inteligencia, memoria y capacidad de interactuar con el mundo.
Componentes Clave de un Agente LangChain
Para construir un agente con LangChain, trabajarás principalmente con estos componentes centrales:
- Modelo de Lenguaje Grande (LLM): El núcleo de inteligencia. Este puede ser los modelos GPT de OpenAI, Claude de Anthropic, o alternativas de código abierto. El LLM procesa las entradas, razona y produce decisiones.
- Herramientas: Funciones que el agente puede llamar para interactuar con sistemas externos o realizar cálculos específicos. Ejemplos incluyen buscar en la web, consultar una base de datos, llamar a una calculadora, o interactuar con una API personalizada.
- Kits de herramientas: Colecciones de herramientas relacionadas diseñadas para casos de uso específicos (por ejemplo, un “kit de herramientas de Wikipedia” o un “kit de herramientas de agente CSV”).
- Ejecutador de agente: El tiempo de ejecución que orquesta las acciones del agente. Toma las decisiones del LLM, ejecuta las herramientas elegidas y retroalimenta los resultados al LLM para un razonamiento adicional.
- Memoria: Permite que el agente retenga información de interacciones anteriores, habilitando conversaciones coherentes en múltiples turnos y toma de decisiones contextualizadas.
- Plantillas de Prompts: Definen cómo se formatea la entrada del usuario y otra información para el LLM, guiando su proceso de razonamiento.
Configurando Tu Entorno y Primeros Pasos
Antes de escribir cualquier código de agente, asegúrate de que tu entorno de Python esté listo. Necesitarás Python 3.8+ y la biblioteca LangChain, junto con cualquier proveedor de LLM que planees usar.
Instalación
Instala LangChain y un proveedor de LLM (por ejemplo, OpenAI):
pip install langchain langchain-openai
pip install python-dotenv # Para gestionar claves API de manera seguraGestiona tus claves API de forma segura. Crea un archivo .env en la raíz de tu proyecto:
OPENAI_API_KEY="tu_clave_api_openai_aqui"Luego, cárgalo en tu script de Python:
import os
from dotenv import load_dotenv
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")Interacción Básica con el LLM
Para confirmar tu configuración, hagamos una simple llamada al LLM:
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Usando un modelo potente con salida determinística
messages = [
HumanMessage(content="¿Cuál es la capital de Francia?")
]
response = llm.invoke(messages)
print(response.content)Esta interacción básica confirma que tu conexión con el LLM está funcionando. Ahora, empoderemos a nuestro LLM con herramientas.
Creando Herramientas para Tu Agente de IA
Las herramientas son las manos y pies del agente, permitiéndole interactuar con el mundo exterior. LangChain facilita la definición de herramientas. Cada herramienta debe tener un nombre claro, una descripción y una función que realice la acción.
Ejemplo: Una Herramienta de Calculadora Simple
Vamos a crear una herramienta que pueda realizar cálculos aritméticos básicos. Aunque los LLMs pueden hacer matemáticas simples, las herramientas externas son más confiables para cálculos complejos.
from langchain.tools import tool
@tool
def calculator(expression: str) -> str:
"""Evalúa una expresión matemática y devuelve el resultado.
La entrada debe ser una cadena que contenga una expresión matemática válida, por ejemplo, '2 + 2' o '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Error al evaluar la expresión: {e}"
# Puedes probar la herramienta directamente
print(calculator.invoke("10 * 5 + 3"))Nota el decorador @tool. Esto convierte automáticamente tu función en una herramienta de LangChain. La docstring es crucial ya que sirve como la descripción de la herramienta, que el LLM utiliza para entender cuándo y cómo usarla.
Ejemplo: Una Herramienta de Búsqueda Web (Usando Tavily)
La mayoría de los agentes potentes necesitan acceso a información actualizada. Una herramienta de búsqueda web es fundamental. Usaremos Tavily, una API de búsqueda específicamente diseñada para RAG (Generación Aumentada por Recuperación) y casos de uso de agentes.
Primero, instala Tavily y configura tu clave API en tu archivo .env:
pip install tavily-pythonTAVILY_API_KEY="tu_clave_api_tavily_aqui"Luego, cárgala:
import os
from dotenv import load_dotenv
from langchain_community.tools.tavily_search import TavilySearchResults
load_dotenv()
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# Crea la herramienta de búsqueda Tavily
search = TavilySearchResults(max_results=3) # Obtener los 3 mejores resultados
# También puedes personalizar el nombre y la descripción si es necesario
# search.name = "búsqueda_web"
# search.description = "Busca en la web información."
# Prueba la herramienta de búsqueda
print(search.invoke("tutorial de agente LangChain"))Al definir estas herramientas, estamos proporcionando a nuestro agente las capacidades que necesita para ampliar su conocimiento más allá de sus datos de entrenamiento y realizar cálculos con precisión.
Construyendo Tu Primer Agente LangChain
Con nuestro LLM y herramientas listos, ahora podemos ensamblar nuestro primer agente LangChain. Usaremos el método “create_openai_functions_agent”, que es una manera conveniente de construir agentes que aprovechan las capacidades de llamada a funciones de OpenAI.
Pasos para la Construcción del Agente
- Define tu LLM: El cerebro de tu agente.
- Define tus Herramientas: Las capacidades que posee tu agente.
- Crea una Plantilla de Prompt: Guia al LLM sobre cómo comportarse.
- Crea el Agente: Combina LLM, herramientas y prompt.
- Crea el Ejecutador de Agente: El tiempo de ejecución que ejecuta las decisiones del agente.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# Cargar variables de entorno
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# 1. Definir LLM
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# 2. Definir Herramientas
@tool
def calculator(expression: str) -> str:
"""Evalúa una expresión matemática y retorna el resultado.
La entrada debe ser una cadena que contenga una expresión matemática válida, por ejemplo, '2 + 2' o '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Error al evaluar la expresión: {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Busca en la web información actual sobre una consulta determinada."
tools = [calculator, search]
# 3. Crear una Plantilla de Prompt
prompt = ChatPromptTemplate.from_messages(
[
("system", "Eres un asistente de IA útil. Responde preguntas lo más precisamente posible."),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# 4. Crear el Agente
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Crear el Ejecutador de Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Ejecutar el agente
# print("--- Ejecución del Agente 1 (Cálculo Simple) ---")
# result1 = agent_executor.invoke({"input": "¿Cuál es 12345 * 6789?", "chat_history": []})
# print(result1["output"])
# print("\n--- Ejecución del Agente 2 (Búsqueda en la Web) ---")
# result2 = agent_executor.invoke({"input": "¿Cuál es la capital de Portugal y cuál es su población actual?", "chat_history": []})
# print(result2["output"])
# print("\n--- Ejecución del Agente 3 (Combinado) ---")
# result3 = agent_executor.invoke({"input": "¿Cuál es la raíz cuadrada de 81 y quién inventó la World Wide Web?", "chat_history": []})
# print(result3["output"])Cuando estableces verbose=True en el AgentExecutor, verás el proceso de pensamiento del agente: qué herramientas considera, cuál selecciona, la entrada que proporciona a la herramienta y la salida de la herramienta. Esto es muy útil para depurar y entender cómo razona tu agente.
Entendiendo la Plantilla de Prompt
system: Establece la persona general y las instrucciones para el agente.MessagesPlaceholder(variable_name="chat_history"): Aquí es donde se insertarán los turnos de conversación anteriores, permitiendo la memoria.human: La entrada actual del usuario.MessagesPlaceholder(variable_name="agent_scratchpad"): Aquí es donde se almacena el proceso de pensamiento interno del agente y las salidas de las herramientas durante una sola invocación, permitiendo que el LLM razone paso a paso.
Agregando Memoria y Estado a tu Agente de IA
Un agente verdaderamente inteligente necesita memoria para mantener el contexto a través de múltiples turnos de una conversación. LangChain proporciona varios tipos de memoria, permitiendo que tu agente recuerde interacciones pasadas.
Por qué la Memoria es Importante
- Coherencia: Los agentes pueden referirse a declaraciones y preguntas anteriores.
- Personalización: Los agentes pueden recordar preferencias del usuario o interacciones pasadas.
- Efiencia: Evita repetir información o preguntar por aclaraciones sobre detalles ya proporcionados.
Implementando ConversationBufferMemory
ConversationBufferMemory es un tipo de memoria simple pero efectiva que almacena todos los mensajes anteriores directamente.
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferMemory # Importar memoria
# Cargar variables de entorno
load_dotenv()
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
os.environ["TAVILY_API_KEY"] = os.getenv("TAVILY_API_KEY")
# LLM y Herramientas (igual que antes)
llm = ChatOpenAI(model="gpt-4o", temperature=0)
@tool
def calculator(expression: str) -> str:
"""Evalúa una expresión matemática y retorna el resultado.
La entrada debe ser una cadena que contenga una expresión matemática válida, por ejemplo, '2 + 2' o '(5 * 3) / 2'.
"""
try:
return str(eval(expression))
except Exception as e:
return f"Error al evaluar la expresión: {e}"
search = TavilySearchResults(max_results=3)
search.name = "web_search"
search.description = "Busca en la web información actual sobre una consulta determinada."
tools = [calculator, search]
# Crear una Plantilla de Prompt (nota el marcador de posición `chat_history`)
prompt = ChatPromptTemplate.from_messages(
[
("system", "Eres un asistente de IA útil. Recuerda interacciones anteriores y responde preguntas lo más precisamente posible."),
MessagesPlaceholder(variable_name="chat_history"), # Aquí es donde se inyectará la memoria
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
]
)
# Inicializar memoria
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Crear el Agente
agent = create_openai_functions_agent(llm, tools, prompt)
# Crear el Ejecutador de Agente, pasando la memoria
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, memory=memory)
# Ejecutar el agente con memoria
print("--- Ejecución del Agente con Memoria ---")
print("\nUsuario: ¿Cuál es la capital de España?")
result1 = agent_executor.invoke({"input": "¿Cuál es la capital de España?"})
print("Agente:", result1["output"])
print("\nUsuario: ¿Cuál es su población?")
result2 = agent_executor.invoke({"input": "¿Cuál es su población?"})
print("Agente:", result2["output"])
print("\nUsuario: ¿Y qué tal la población de la capital de Francia?")
result3 = agent_executor.invoke({"input": "¿Y qué tal la población de la capital de Francia?"})
print("Agente:", result3["output"])En este ejemplo, el agente recuerda “España” del primer turno y “la capital de Francia” del tercero, lo que le permite proporcionar respuestas relevantes sin necesidad de reiteración explícita del país. La memory_key="chat_history" asegura que el contenido de la memoria esté correctamente mapeado al MessagesPlaceholder(variable_name="chat_history") en nuestro prompt.
Otros Tipos de Memoria
Artículos Relacionados
- Llegando al Corazón de Estilos de Diseño de API Efectivos
- APIs de Streaming de Agentes de IA
- Qdrant vs FAISS: ¿Cuál es el Mejor para Startups?
🕒 Published: