LangChain para Agentes de IA: Tutorial Completo
Los agentes de IA son entidades de software autónomas que pueden percibir su entorno, tomar decisiones y realizar acciones para lograr objetivos específicos. Representan un gran avance en la forma en que interactuamos y construimos sistemas inteligentes. Si estás buscando entender los componentes básicos y la implementación práctica de los agentes de IA, comienza con La Guía Completa de Agentes de IA en 2026. LangChain se destaca como un potente marco para construir estos agentes, proporcionando las abstracciones y herramientas necesarias para integrar modelos de lenguaje grande (LLMs) con fuentes de datos externas y capacidades computacionales. Este tutorial te guiará en la construcción de agentes de IA utilizando LangChain, centrándose en los aspectos prácticos y los mecanismos subyacentes.
Entendiendo los Fundamentos del Agente LangChain
En su núcleo, un agente LangChain orquesta la interacción entre un LLM y un conjunto de herramientas. El LLM actúa como el “cerebro” del agente, decidiendo qué herramienta utilizar y con qué entrada, según el objetivo actual y el estado observado. Las herramientas son funciones que realizan tareas específicas, como buscar en la web, consultar una base de datos o ejecutar código.
Los principales componentes de un agente LangChain son:
- LLM: El modelo de lenguaje responsable del razonamiento y la toma de decisiones.
- Herramientas: Funciones que el agente puede llamar para interactuar con el mundo exterior.
- Instrucción: Instrucciones dadas al LLM, guiando su comportamiento y uso de herramientas.
- Ejecutor de Agente: El entorno de ejecución que gestiona el bucle del agente, pasando observaciones y acciones entre el LLM y las herramientas.
Considera un agente diseñado para responder preguntas sobre eventos actuales. Puede tener una herramienta para realizar búsquedas en la web y otra para consultar artículos. El LLM, dado una consulta, decidiría si buscar en la web, ejecutar la búsqueda, observar los resultados y luego, potencialmente, resumirlos antes de formular una respuesta final.
Configurando Tu Entorno LangChain
Antes de construir un agente, asegúrate de tener LangChain instalado y acceso a un LLM. Usaremos los modelos de OpenAI para este tutorial, pero LangChain es compatible con muchos otros.
pip install langchain langchain-openai
Necesitarás establecer tu clave de API de OpenAI como una variable de entorno:
import os
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
Para ejemplos más simples, puedes instanciar el LLM directamente:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(temperature=0)
El parámetro `temperature` controla la aleatoriedad de la salida del LLM. Un valor de 0 hace que la salida sea más determinista y fáctica, adecuada para la toma de decisiones del agente.
Construyendo Tu Primer Agente LangChain: Un Agente de Búsqueda Simple
Construyamos un agente que pueda responder preguntas utilizando búsqueda en la web. Esto requiere una herramienta de búsqueda web. LangChain proporciona integraciones para varios proveedores de búsqueda. Usaremos la herramienta `TavilySearchResults`, que a menudo es un buen estándar.
Primero, instala el paquete necesario y configura tu clave de API de Tavily:
pip install langchain-community tavily-python
import os
os.environ["TAVILY_API_KEY"] = "YOUR_TAVILY_API_KEY"
Ahora, definamos las herramientas e instanciemos el agente.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_community.tools.tavily_search import TavilySearchResults
# 1. Inicializa LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Define Herramientas
search_tool = TavilySearchResults(max_results=3) # Limitar a 3 resultados de búsqueda
tools = [search_tool]
# 3. Extrae el Prompt de Agente ReAct del LangChain Hub
# El patrón ReAct (Razonamiento y Acción) es un enfoque común para los agentes.
# Induce al LLM a generar un proceso de pensamiento antes de tomar una acción.
prompt = hub.pull("hwchase17/react")
# 4. Crea el Agente
# create_react_agent construye un agente que utiliza el prompt ReAct.
agent = create_react_agent(llm, tools, prompt)
# 5. Crea el Ejecutor de Agente
# El AgentExecutor es responsable de ejecutar el bucle de decisiones del agente.
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Ejecuta el Agente
response = agent_executor.invoke({"input": "¿Cuál es la capital de Francia y cuál es su población actual?"})
print(response["output"])
En este ejemplo:
- Inicializamos `ChatOpenAI` como nuestro LLM.
- Creamos una herramienta `TavilySearchResults`.
- Extraemos un prompt estándar de ReAct de `langchain_hub`. Este prompt guía al LLM a pensar paso a paso (Pensamiento) y luego decidir sobre una Acción y Entrada de Acción.
- `create_react_agent` combina el LLM, herramientas y prompt en un agente.
- `AgentExecutor` ejecuta el agente, manejando la secuencia de observaciones y acciones. La bandera `verbose=True` es crucial para la depuración, ya que muestra el proceso de pensamiento interno del agente.
La salida con `verbose=True` mostrará el “Pensamiento,” “Acción,” “Entrada de Acción,” y “Observación” del agente en cada paso, demostrando su razonamiento.
Agregando Herramientas y Capacidades Más Complejas
Los agentes se vuelven realmente poderosos cuando pueden interactuar con varios sistemas. Amplifiquemos nuestro agente con una herramienta para realizar cálculos.
from langchain.agents import AgentExecutor, create_react_agent
from langchain import hub
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.tools import tool # Decorador para creación simple de herramientas
# 1. Inicializa LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Define Herramientas
search_tool = TavilySearchResults(max_results=3)
@tool
def calculator(expression: str) -> str:
"""Evalúa una expresión matemática y devuelve el resultado."""
try:
return str(eval(expression))
except Exception as e:
return f"Error al evaluar la expresión: {e}"
tools = [search_tool, calculator]
# 3. Extrae el Prompt del Agente ReAct
prompt = hub.pull("hwchase17/react")
# 4. Crea el Agente
agent = create_react_agent(llm, tools, prompt)
# 5. Crea el Ejecutor de Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Ejecuta el Agente con una nueva consulta
response = agent_executor.invoke({"input": "¿Cuánto es 12345 por 67890? Además, averigua quién ganó la última Copa del Mundo."})
print(response["output"])
Aquí, utilizamos el decorador `@tool` para definir rápidamente una herramienta `calculator`. Este decorador infiere automáticamente la descripción de la herramienta y el esquema de argumentos, que el LLM utiliza para entender cómo llamarla. El agente ahora decidirá si usar el `calculator` o `TavilySearchResults` según la consulta de entrada. Esta modularidad es clave para construir agentes de IA sofisticados. Para una coordinación multi-agente más avanzada, marcos como CrewAI Multi-Agent Systems Guide ofrecen potentes abstracciones.
Tipos de Agentes y Sus Casos de Uso
LangChain ofrece varios tipos de agentes, cada uno con diferentes fortalezas y mecanismos de toma de decisiones subyacentes:
- `create_react_agent` (Agente ReAct): Utiliza el patrón ReAct (Razonamiento y Acción). El LLM genera un “Pensamiento” (monólogo interno) y luego una “Acción” (llamada a la herramienta) y “Entrada de Acción.” Este es un enfoque altamente efectivo y ampliamente utilizado para agentes de propósito general.
- `create_json_agent`: Diseñado para agentes que interactúan con APIs que esperan entradas y salidas en JSON. Se le indica al LLM que genere llamadas a herramientas formateadas en JSON.
- `create_openai_functions_agent`: Aprovecha las capacidades de llamados a funciones de OpenAI. El LLM produce directamente un objeto estructurado que indica la herramienta a llamar y sus argumentos, lo que puede ser más confiable que analizar texto. Esta suele ser la opción preferida al usar modelos de OpenAI.
Elegir el tipo correcto de agente depende de tu caso de uso específico y del LLM que estés empleando. Para la mayoría de las tareas generales con modelos de OpenAI, `create_openai_functions_agent` es un excelente punto de partida debido a su eficacia. Veamos un ejemplo utilizándolo.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.messages import SystemMessage, HumanMessage
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
# 1. Inicializar LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Definir Herramientas
search_tool = TavilySearchResults(max_results=3)
@tool
def current_time(format_str: str = "%Y-%m-%d %H:%M:%S") -> str:
"""Devuelve la fecha y hora actual en el formato especificado."""
import datetime
return datetime.datetime.now().strftime(format_str)
tools = [search_tool, current_time]
# 3. Definir el Mensaje del Agente (utilizando mensajes específicos del agente de funciones de OpenAI)
system_message = SystemMessage(
content="Eres un asistente de IA útil. Usa las herramientas disponibles para responder preguntas."
)
prompt = [system_message, HumanMessage(content="{input}"), MessagesPlaceholder(variable_name="agent_scratchpad")]
# 4. Crear el Agente utilizando create_openai_functions_agent
agent = create_openai_functions_agent(llm, tools, prompt)
# 5. Crear el Ejecutador del Agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. Ejecutar el Agente
response = agent_executor.invoke({"input": "¿Cuál es la hora actual y cuáles fueron los principales titulares de noticias ayer?"})
print(response["output"])
Nota el `MessagesPlaceholder(variable_name=”agent_scratchpad”)` en el prompt. Aquí es donde se inyectan los pensamientos, acciones y observaciones intermedias del agente en el historial de la conversación, permitiendo que el LLM mantenga el contexto.
Manejo del Estado y Memoria del Agente
Para que los agentes realicen interacciones complejas y de múltiples turnos, necesitan memoria. LangChain proporciona varios componentes de memoria para almacenar y recuperar el historial conversacional. El `AgentExecutor` puede configurarse con memoria.
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.messages import SystemMessage, HumanMessage, MessagesPlaceholder
from langchain.tools import tool
from langchain_community.tools.tavily_search import TavilySearchResults
from langchain.memory import ConversationBufferWindowMemory # Importar memoria
# 1. Inicializar LLM
llm = ChatOpenAI(temperature=0, model="gpt-4o")
# 2. Definir Herramientas
search_tool = TavilySearchResults(max_results=3)
tools = [search_tool]
# 3. Definir el Mensaje del Agente
system_message = SystemMessage(
content="Eres un asistente de IA útil. Usa las herramientas disponibles para responder preguntas. Mantén tus respuestas concisas."
)
prompt = [
system_message,
MessagesPlaceholder(variable_name="chat_history"), # Marcador de posición para el historial de chat
HumanMessage(content="{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
]
# 4. Crear Memoria
# ConversationBufferWindowMemory mantiene una ventana de las últimas 'k' interacciones.
memory = ConversationBufferWindowMemory(memory_key="chat_history", return_messages=True, k=3)
# 5. Crear el Agente
agent = create_openai_functions_agent(llm, tools, prompt)
# 6. Crear el Ejecutador del Agente con memoria
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True,
memory=memory # Añadir memoria aquí
)
# 7. Ejecutar Conversación de Múltiples Turnos
print("--- Primer Turno ---")
response1 = agent_executor.invoke({"input": "¿Cuál es la capital de Japón?"})
print(response1["output"])
print("\n--- Segundo Turno ---")
response2 = agent_executor.invoke({"input": "¿Cuál es su población?"}) # Refiriéndose a "su" (la capital de Japón)
print(response2["output"])
print("\n--- Tercer Turno ---")
response3 = agent_executor.invoke({"input": "¿Y qué hay de la capital de Brasil?"})
print(response3["output"])
Al introducir `ConversationBufferWindowMemory` e incluir `MessagesPlaceholder(variable_name=”chat_history”)` en el prompt, el agente puede ahora mantener el contexto a lo largo de múltiples turnos. El LLM ve los mensajes anteriores, permitiéndole entender referencias como “su población” en el segundo turno. Esto es crucial para construir agentes de IA atractivos y funcionales, especialmente para casos de uso como Construir un Agente de IA para Servicio al Cliente.
Personalización Avanzada del Agente y Desarrollo de Herramientas
Aunque LangChain proporciona muchas herramientas integradas, a menudo necesitarás crear herramientas personalizadas para interactuar con tus aplicaciones, bases de datos o API internas específicas.
Las herramientas personalizadas pueden ser funciones simples decoradas con `@tool`, como se muestra con `calculator` y `current_time`. Para escenarios más complejos, podrías definir una clase que herede de `BaseTool` o usar `StructuredTool` para una definición precisa de argumentos.
from langchain.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type
# Definir esquema de entrada para la herramienta personalizada
class GetDatabaseRecordInput(BaseModel):
table_name: str = Field(description="Nombre de la tabla de la base de datos")
record_id: int = Field(description="ID del registro a recuperar")
class GetDatabaseRecordTool(BaseTool):
name = "get_database_record"
description = "Útil para recuperar un registro específico de una tabla de base de datos por su ID."
args_schema: Type[BaseModel] = GetDatabaseRecordInput
def _run(self, table_name: str, record_id: int) -> str:
"""Simula la recuperación de un registro de una base de datos."""
print(f"DEBUG: Recuperando el registro {record_id} de la tabla {table_name}")
if table_name == "users" and record_id == 1:
return "Registro de usuario: {'id': 1, 'name': 'Alice', 'email': '[email protected]'}"
elif table_name == "products" and record_id == 101:
return "Registro de producto: {'id': 101, 'name': 'Laptop', 'price': 1200}"
return f"Registro no encontrado para la tabla '{table_name}' con ID '{record_id}'"
async def _arun(self, table_name: str, record_id: int) -> str:
"""Versión asíncrona de la herramienta (opcional)."""
# Implementar lógica asíncrona aquí
raise NotImplementedError("Llamada asíncrona no implementada para esta herramienta.")
# Añade esta herramienta a la lista de herramientas de tu agente
# tools.append(GetDatabaseRecordTool())
Esta `GetDatabaseRecordTool` demuestra cómo definir una herramienta con un esquema de entrada específico utilizando Pydantic, proporcionando al LLM instrucciones claras sobre cómo usarla. Este nivel de control es esencial para integrar agentes en sistemas empresariales. Al comparar marcos, considera cómo cada uno maneja estas integraciones de herramientas personalizadas; consulta Comparando los 5 Mejores Marcos de Agentes de IA 2026 para más contexto.
Conclusiones Clave
- Los agentes de LangChain utilizan un LLM para orquestar el uso de herramientas, permitiéndoles interactuar con el mundo exterior más allá de sus datos de entrenamiento.
- Los componentes clave son el LLM, las Herramientas, un Prompt y el Ejecutador de Agente.
- El patrón ReAct (Razonar y Actuar) es un enfoque eficiente, a menudo facilitado por prompts de LangChain Hub.
- `create_openai_functions_agent` es generalmente recomendado para modelos de OpenAI debido a su salida estructurada confiable.
- Los componentes de memoria (por ejemplo, `ConversationBufferWindowMemory`) son cruciales para conversaciones de múltiples turnos y conciencia contextual.
- Las herramientas personalizadas son fáciles de crear usando el decorador `@tool` o heredando de `BaseTool` para interacciones más complejas, permitiendo a los agentes integrarse con sistemas propietarios.
- Siempre usa `verbose=True` durante el desarrollo para inspeccionar el proceso de pensamiento interno del agente y depurar de manera efectiva.
Conclusión
LangChain proporciona un marco completo y flexible para construir agentes de IA. Al entender sus componentes clave—LLMs, herramientas, prompts y ejecutores—puedes construir agentes capaces de razonamiento y interacción complejos. Desde agentes de búsqueda simples hasta sistemas sofisticados con memoria e integraciones personalizadas, LangChain ofrece los elementos necesarios para hacer realidad tus ideas de agentes de IA. A medida que el campo de los agentes de IA continúa evolucionando, dominar marcos como LangChain será cada vez más valioso para desarrollar aplicaciones inteligentes y autónomas.
🕒 Published: