Image for post Agentes y Herramientas en LangChain: Construyendo Aplicaciones IA Autónomas con Python

Agentes y Herramientas en LangChain: Construyendo Aplicaciones IA Autónomas con Python

Escrito por Sergio Márquez

En el vertiginoso mundo de la Inteligencia Artificial, los Large Language Models (LLMs) han demostrado ser increíblemente potentes, capaces de generar texto coherente, traducir idiomas y responder preguntas con una fluidez asombrosa. Sin embargo, por sí solos, los LLMs tienen una limitación fundamental: su conocimiento está encapsulado en los datos con los que fueron entrenados. No pueden interactuar con el mundo exterior, buscar información en tiempo real, ejecutar código o acceder a bases de datos. Aquí es donde entran en juego los Agentes y Herramientas de LangChain, transformando los LLMs de meros generadores de texto en sistemas autónomos capaces de razonar, planificar y actuar.

Este artículo está diseñado para desarrolladores junior-mid con conocimientos básicos de Python e interés en la IA aplicada. Te guiaremos paso a paso para entender qué son los agentes, cómo funcionan las herramientas y cómo puedes construir tu primera aplicación de IA autónoma utilizando el framework LangChain.

Contexto del Problema: Más Allá de la Generación de Texto

Imagina que quieres que un modelo de lenguaje no solo te diga la capital de Francia, sino que también te diga el clima actual en esa ciudad y te sugiera una actividad basada en el pronóstico. Un LLM por sí solo no puede hacer esto. Necesita:

  • Acceder a información en tiempo real: Para el clima actual.
  • Realizar cálculos: Si la tarea implica matemáticas.
  • Interactuar con APIs externas: Para obtener datos específicos o realizar acciones.
  • Tomar decisiones secuenciales: Decidir qué hacer a continuación basándose en los resultados de una acción previa.

Aquí es donde la arquitectura de agentes brilla. Un agente es un sistema que utiliza un LLM como su "cerebro" de razonamiento para determinar qué acciones tomar y en qué orden, utilizando un conjunto de "herramientas" para interactuar con el mundo. Los resultados de estas acciones se retroalimentan al agente, permitiéndole refinar su plan o llegar a una conclusión final. [6, 7, 9]

Conceptos Clave: Agentes, Herramientas y el Ciclo ReAct

¿Qué son los Agentes de IA?

En LangChain, un agente es un sistema que utiliza un LLM para decidir una secuencia de acciones a tomar. Estas acciones pueden ser el uso de una herramienta y/o la observación de su resultado. El LLM actúa como un motor de razonamiento, interpretando la entrada del usuario, el estado actual y las capacidades de las herramientas disponibles para formular un plan. [6, 7]

¿Por qué necesitamos Herramientas?

Las herramientas son funciones o APIs que los agentes pueden invocar para interactuar con el mundo exterior. Son la extensión de las capacidades del LLM. Sin herramientas, un LLM está limitado a su conocimiento interno. Con herramientas, puede:

  • Buscar en la web: Obtener información actualizada.
  • Realizar cálculos: Usar una calculadora.
  • Consultar bases de datos: Acceder a datos estructurados.
  • Interactuar con APIs: Enviar correos electrónicos, gestionar calendarios, etc.
  • Ejecutar código: Para tareas de procesamiento de datos o lógica compleja.

Cada herramienta tiene un nombre y una descripción clara que el LLM utiliza para decidir cuándo y cómo usarla. [11, 15, 24]

El Ciclo ReAct (Reasoning + Acting)

Uno de los patrones más efectivos para construir agentes es el enfoque ReAct (Reasoning + Acting). Este patrón permite a los LLMs imitar el enfoque de resolución de problemas humano, alternando entre el pensamiento (razonamiento) y la acción (uso de herramientas). [1, 8, 18]

El ciclo ReAct se compone de los siguientes pasos, que se repiten hasta que se alcanza una solución:

  1. Thought (Pensamiento): El LLM analiza la entrada actual y el historial de interacciones, y decide qué hacer a continuación. Formula un plan o una hipótesis.
  2. Action (Acción): Basándose en su pensamiento, el LLM selecciona una herramienta de su conjunto de herramientas disponibles y genera los argumentos necesarios para invocarla.
  3. Observation (Observación): La herramienta se ejecuta con los argumentos proporcionados, y su resultado (la observación) se devuelve al LLM.
  4. Estos tres pasos se repiten, permitiendo al agente refinar su razonamiento y tomar nuevas acciones hasta que pueda proporcionar una respuesta final. [8, 18]

Componentes de un Agente LangChain

  • LLM: El modelo de lenguaje grande que sirve como el cerebro del agente.
  • Tools: Las funciones que el agente puede invocar.
  • Agent Executor: El runtime que ejecuta el agente, gestionando el ciclo ReAct y la interacción entre el LLM y las herramientas. [10, 14]
  • Prompt: Las instrucciones que guían al LLM sobre cómo comportarse como un agente y cómo usar las herramientas.

Implementación Paso a Paso: Creando tu Primer Agente ReAct

Vamos a construir un agente simple que pueda buscar información en la web y realizar cálculos matemáticos. Para ello, usaremos la API de OpenAI para el LLM y herramientas como DuckDuckGo Search y una calculadora.

1. Configuración del Entorno

Primero, asegúrate de tener Python instalado (versión 3.9 o superior). Luego, instala las bibliotecas necesarias:

pip install langchain langchain-openai duckduckgo-search python-dotenv

Crea un archivo .env en la raíz de tu proyecto para almacenar tu clave de API de OpenAI de forma segura:

OPENAI_API_KEY="tu_clave_api_de_openai_aqui"

¡Importante! Nunca expongas tus claves de API directamente en tu código fuente o en repositorios públicos. Usa variables de entorno.

2. Inicializar el LLM

Cargaremos la clave de API y configuraremos nuestro modelo de lenguaje. Usaremos ChatOpenAI.

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

# Cargar variables de entorno
load_dotenv()

# Inicializar el LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)

3. Definir las Herramientas

Ahora, definiremos las herramientas que nuestro agente podrá utilizar. Usaremos una herramienta de búsqueda web (DuckDuckGo Search) y una herramienta de calculadora.

from langchain_community.tools import DuckDuckGoSearchRun
from langchain.tools import tool

# Herramienta de búsqueda web
search = DuckDuckGoSearchRun()

# Herramienta de calculadora personalizada (ejemplo simple)
@tool
def multiply(a: float, b: float) -> float:
    """Multiplica dos números flotantes y devuelve el resultado."""
    return a * b

@tool
def add(a: float, b: float) -> float:
    """Suma dos números flotantes y devuelve el resultado."""
    return a + b

# Agrupar las herramientas
tools = [search, multiply, add]

Observa el uso del decorador @tool. LangChain lo utiliza para convertir funciones Python regulares en herramientas que el agente puede invocar. La docstring de la función es crucial, ya que se convierte en la descripción que el LLM leerá para decidir cuándo usar la herramienta. [11, 17]

4. Crear el Agente

LangChain proporciona funciones para crear agentes de forma sencilla. Usaremos create_react_agent y AgentExecutor.

from langchain import hub
from langchain.agents import AgentExecutor, create_react_agent

# Obtener el prompt ReAct predefinido de LangChain Hub
# Este prompt es crucial para guiar al LLM en el ciclo Thought/Action/Observation
prompt = hub.pull("hwchase17/react")

# Crear el agente
agent = create_react_agent(llm, tools, prompt)

# Crear el AgentExecutor
# El AgentExecutor es el runtime que ejecuta el agente
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

El parámetro verbose=True es muy útil para ver el "pensamiento" interno del agente (el ciclo ReAct) mientras decide qué acciones tomar. [19]

Mini Proyecto: Un Asistente de Información y Cálculo

Ahora que tenemos nuestro agente configurado, vamos a probarlo con algunas consultas que requieren tanto búsqueda de información como cálculos.

# Ejemplo 1: Pregunta que requiere búsqueda web
print("\n--- Consulta 1 ---")
response1 = agent_executor.invoke({"input": "¿Cuál es la capital de Canadá y qué tiempo hace allí ahora mismo?"})
print(f"Respuesta: {response1['output']}")

# Ejemplo 2: Pregunta que requiere cálculo
print("\n--- Consulta 2 ---")
response2 = agent_executor.invoke({"input": "Si tengo 25.5 manzanas y compro 12.3 más, ¿cuántas manzanas tengo en total?"})
print(f"Respuesta: {response2['output']}")

# Ejemplo 3: Pregunta combinada
print("\n--- Consulta 3 ---")
response3 = agent_executor.invoke({"input": "Busca el precio actual de Bitcoin en USD y luego multiplica ese valor por 0.05 para saber cuánto valdrían 0.05 BTC."})
print(f"Respuesta: {response3['output']}")

Al ejecutar este código, verás cómo el agente utiliza la herramienta de búsqueda para obtener la capital de Canadá y el clima, y cómo usa la herramienta de suma para el cálculo de las manzanas. Para la consulta combinada, primero buscará el precio de Bitcoin y luego usará la herramienta de multiplicación. El output detallado (gracias a verbose=True) te mostrará el proceso de pensamiento del LLM.

Errores Comunes y Depuración

Trabajar con agentes puede ser un poco más complejo que con cadenas simples. Aquí hay algunos errores comunes y cómo abordarlos:

  1. Invalid or missing API key: Asegúrate de que tu archivo .env esté correctamente configurado y que la clave de API sea válida. Verifica que load_dotenv() se ejecute al inicio de tu script.

  2. Tool not found o Tool input malformed:

    • Descripción de la herramienta: El LLM se basa en la descripción de la herramienta para decidir cuándo usarla y qué argumentos pasarle. Si la descripción no es clara o es ambigua, el agente puede no usar la herramienta correcta o pasar argumentos incorrectos. Sé explícito en las docstrings de tus funciones @tool. [15]
    • Tipos de argumentos: Asegúrate de que los tipos de los argumentos en la firma de tu función @tool sean claros (ej. a: float, b: float). El LLM intentará generar argumentos que coincidan con estos tipos.
    • handle_parsing_errors=True: En el AgentExecutor, este parámetro puede ayudar a que el agente se recupere de errores de formato en la salida del LLM, intentando volver a generar la respuesta.

  3. Max iterations exceeded: Los agentes tienen un número máximo de pasos (iteraciones) para evitar bucles infinitos. Si tu agente no llega a una respuesta final dentro de este límite, puede ser que:

    • La tarea sea demasiado compleja para las herramientas disponibles.
    • El prompt del agente no sea lo suficientemente bueno para guiarlo.
    • Las descripciones de las herramientas no sean claras, lo que lleva al agente a probar herramientas incorrectas repetidamente.
    • Puedes aumentar max_iterations en el AgentExecutor, pero es mejor optimizar el razonamiento del agente.

  4. Comportamiento inesperado del agente:

    • verbose=True: Es tu mejor amigo. Te permite ver el "pensamiento" del agente (Thought, Action, Observation) y entender por qué tomó ciertas decisiones. [19]
    • Ajusta el prompt: El prompt que se le da al agente es fundamental. Si usas un prompt personalizado, asegúrate de que sea claro, conciso y que le dé al agente las instrucciones necesarias para usar sus herramientas de manera efectiva.

Aprendizaje Futuro: Expandiendo tus Agentes

Este tutorial es solo el comienzo. El mundo de los agentes en LangChain es vasto y ofrece muchas posibilidades para expandir tus aplicaciones de IA:

  • Herramientas Personalizadas Avanzadas: Crea herramientas que interactúen con tus propias APIs internas, bases de datos o sistemas legados. Puedes usar la clase BaseTool para una mayor flexibilidad y control sobre la lógica de tus herramientas. [15]

  • Agentes Conversacionales con Memoria: Integra memoria en tus agentes para que puedan recordar interacciones pasadas y mantener el contexto en conversaciones de varias vueltas. LangChain ofrece varias opciones de memoria, como ConversationBufferMemory. [9]

  • LangGraph para Workflows Complejos: Para un control más granular sobre el flujo de ejecución de tus agentes y para construir sistemas multi-agente, considera explorar LangGraph. LangGraph es una extensión de LangChain que permite definir agentes como grafos de estados, ofreciendo una flexibilidad superior para construir agentes robustos y con estado. Es la dirección recomendada para nuevos desarrollos de agentes complejos. [5, 13, 16, 20]

  • LangSmith para Observabilidad: A medida que tus agentes se vuelven más complejos, depurarlos puede ser un desafío. LangSmith es una plataforma de LangChain para depurar, probar y monitorear tus aplicaciones LLM, proporcionando visibilidad completa del ciclo de vida de tu agente. [6, 20]

  • Integración con Otros Modelos y Servicios: Experimenta con diferentes LLMs (Anthropic Claude, Google Gemini, etc.) y otras herramientas de LangChain para expandir aún más las capacidades de tus agentes.

Conclusión

Los agentes y herramientas de LangChain representan un paso crucial hacia la construcción de aplicaciones de IA verdaderamente inteligentes y autónomas. Al permitir que los LLMs interactúen con el mundo exterior, podemos superar las limitaciones inherentes a su conocimiento estático y crear soluciones que resuelvan problemas complejos en tiempo real. Con los conceptos y el código proporcionados en este tutorial, tienes una base sólida para empezar a experimentar y construir tus propios agentes de IA. ¡El futuro de las aplicaciones inteligentes está en tus manos!

Volver al blog