Llamadas a herramientas en LangChain: el mecanismo detrás de las aplicaciones agentes
Registre las funciones de Python como herramientas de LangChain y ejecute el bucle de cuatro pasos en el que el modelo selecciona herramientas, estas se ejecutan externamente y los resultados regresan como mensajes.
Fuentes: Agentic AI with LangChain — Part 3: Tool Calling in LangChain
Este es el tercer artículo de la serie sobre IA agente con LangChain. En la Parte 2 se creó un flujo de trabajo RAG agente con LangGraph. El siguiente paso es expandirse a más dominios: cocina, natación, música clásica e incluso el clima en tiempo real de ciudades de todo el mundo, sin saturar el grafo con nuevos nodos.
Siguiendo el patrón de la Parte 2, se podría agregar un nodo de recuperación por cada dominio, cada uno con su propio índice Pinecone, además de un nodo meteorológico que consulte una API pública. A medida que los nodos se multiplican, las conexiones y ramificaciones también lo hacen, lo que hace difícil mantener el grafo.
La llamada a herramientas es la solución. En lugar de tener un nodo por función, regístrelas como herramientas de LangChain y deje que el modelo decida cuándo llamarlas, cómo utilizar los resultados y cómo integrarlos en la respuesta final. Eso simplifica el flujo de trabajo y amplía las capacidades del modelo con cálculos precisos, consultas a bases de datos, búsquedas en la web y APIs en tiempo real.
Lo que sigue aborda las ideas clave y un ciclo de llamada a herramientas en LangChain. Esa base prepara el próximo artículo sobre ReAct. Una vez comprendido ReAct, se puede simplificar el flujo de trabajo de la Parte 2 utilizando las mismas ideas. El código se encuentra en el repositorio de GitHub.
Temas:
- Qué es la llamada a herramientas y por qué es importante.
- Cómo implementar herramientas de LangChain.
- Cómo funciona el ciclo de llamada a herramientas en cuatro pasos.
Vocabulario
- Herramienta LangChain: una función en Python decorada con
@toolque expone su esquema e instrucciones de uso al modelo. - Llamada a la herramienta: el mecanismo mediante el cual el modelo solicita que se ejecute una función externa.
- Mensaje de la herramienta: el tipo de mensaje que lleva los resultados de la herramienta de vuelta al modelo.
- Bucle de llamada a la herramienta: el ciclo en el que el modelo selecciona una herramienta, esta se ejecuta fuera del modelo, los resultados regresan y el modelo los incorpora en la respuesta.
Configuración
Cree un archivo .env con las claves de OpenAI y Tavily.
OPENAI_API_KEY="<Your OpenAI API Key>"
TAVILY_API_KEY=<Your TAVILY API Key>
Cargúelos mediante una clase de configuración de Pydantic.
class BaseConfig(BaseSettings):
OPENAI_API_KEY: Optional[str]
PINECONE_API_KEY: Optional[str]
TAVILY_API_KEY: Optional[str]
model_config = SettingsConfigDict(env_file=".env", extra="ignore")
El proyecto alberga las herramientas en un paquete tools, con ejemplos sencillos como una ayuda para sumar y una herramienta meteorológica.
project/
|
├── tools
│ ├── get_sum.py # a simple LangChain tool example
| └── weather.py # get_weather LangChain tool using open source APIs
|
|── tool_call.py # implement tool-calling loop using LangChain tools
├── config.py # pydantic BaseConfig
├── .env # environment variable definition
├── .gitignore
└── requirements.txt # package requirements
Qué es una herramienta de LangChain
Una herramienta es una función ordinaria de Python con el decorador @tool. El decorador envuelve la función, crea un esquema a partir de la documentación y las indicaciones de tipo, y proporciona al modelo instrucciones para llamarla.
from langchain.tools import tool
@tool
def get_sum(a: int, b: int) -> int:
"""
get the summation of two integers
:param a: int, input integer
:param b: int, input integer
:return: int, the sum of a and b
"""
return a + b
Una herramienta meteorológica
get_weather utiliza la API gratuita Open-Meteo. Busca las coordenadas de una ciudad y luego obtiene la información meteorológica actual. Este patrón, primero resolver y luego obtener datos, es típico de las herramientas en tiempo real.
El ciclo de llamada a las herramientas
Una vez que existen las herramientas, la siguiente pregunta es cómo las utiliza el modelo. La respuesta es un ciclo de cuatro pasos.
- El usuario envía una solicitud.
- El modelo decide qué herramienta o herramientas llamar y emite un mensaje con los nombres y argumentos necesarios.
- Las herramientas se ejecutan fuera del modelo, y sus resultados regresan como mensajes de la herramienta.
- El modelo incorpora esos resultados y genera una respuesta final.
El modelo nunca ejecuta las herramientas por sí mismo. Todo se procesa externamente, y los resultados vuelven como mensajes de la herramienta que el modelo analiza posteriormente.
El modelo también puede solicitar varias herramientas en una sola respuesta, lo que se conoce como llamadas paralelas a herramientas. Si se le pide la temperatura de Boston y la suma de tres y cinco, puede emitir tanto get_weather como get_sum al mismo tiempo; el bucle ejecuta ambas antes de responder.
Implementación del bucle en LangChain
Una clase WeatherAssistant encapsula las capacidades de información meteorológica y búsqueda en la web mediante get_weather y tavily_search.
LLM y herramientas
El constructor configura un modelo de OpenAI, un diccionario de herramientas, un LLM vinculado que puede llamarlas, una lista de mensajes y un prompt de sistema que indica al modelo cuándo utilizar cada herramienta.
class WeatherAssistant:
def __init__(self):
# initialize llm
self.llm = ChatOpenAI(api_key=api_key, model="gpt-4o-mini", temperature=0)
# initialize a tool dictionary
self.tools = {"get_weather": get_weather,
"tavily_search": TavilySearch(max_results=3, tavily_api_key=TAVILY_API_KEY)}
# bind LangChain tools to llm
self.llm_with_tools = self.llm.bind_tools(list(self.tools.values()))
# initialize messages to store message list
self.messages = []
# System prompt
self.system_prompt = f"""You are a helpful assistant for question-answering tasks.
When users ask about weather, use the get_weather tool to get weather. For other questions,
use web_search. If you don't know the answer, just say that you don't know.
Be conversational and helpful in your responses."""
self.messages.append(SystemMessage(content=self.system_prompt))
El método de chat
chat agrega el mensaje del usuario, invoca al modelo y, si hay llamadas a herramientas, ejecuta cada una de ellas en un bucle, agrega cada resultado como ToolMessage y luego invoca nuevamente al modelo para obtener la respuesta final. Ese patrón maneja tanto las llamadas individuales como las paralelas.
async def chat(self, message: str):
# Wrap User message in a HumanMessage and add it to message list
self.messages.append(HumanMessage(content=message))
# Get AI response (it may or may not contain tool calls)
response = await self.llm_with_tools.ainvoke(self.messages)
self.messages.append(response)
# If there is any tool calls in the AI response
if response.tool_calls:
# process tool calls
for tool_call in response.tool_calls:
# retrieve function name from tool_call, then
# retrieve the tool from tool dictionary, and invoke it,
# append resulting tool message to message list
tool = self.tools[tool_call["name"]]
tool_result = await tool.ainvoke(tool_call)
self.messages.append(tool_result)
# Get final response after tool execution
final_response = await self.llm_with_tools.ainvoke(self.messages)
self.messages.append(final_response)
Una prueba rápida
Un main asíncrono pequeño crea al asistente y solicita la temperatura de Tokio.
async def main():
print("hello tool calling!")
assistant = WeatherAssistant()
message = "What is the temperature in Tokyo?"
await assistant.chat(message)
for msg in assistant.messages:
msg.pretty_print()
if __name__ == "__main__":
asyncio.run(main())
La lista de mensajes muestra entonces una secuencia clara: un mensaje humano con la pregunta, un mensaje de IA con una llamada a la herramienta get_weather, un mensaje de la herramienta con los datos del clima y un mensaje final de IA con la respuesta en voz alta.
Una nota sobre errores y reintentos\n\nSi una herramienta genera un error, el bucle debe capturar la excepción, convertirla en un mensaje de herramienta claro y dejar que el modelo decida si intentarlo de nuevo o disculparse. Los reintentos ciegos con los mismos argumentos incorrectos desperdician tiempo; es mejor mostrar el texto del error para que el modelo pueda ajustarse.\n\n## Por qué esto es importante para la serie
La llamada a herramientas es la base fundamental de ReAct y de cualquier agente que decide sus propias acciones. Una vez que el ciclo está establecido, agregar una nueva capacidad implica escribir otra función @tool en lugar de un nuevo nodo del grafo. Esa es la simplificación que el complejo flujo de trabajo de la Parte 2 estaba esperando. Con las herramientas registradas una sola vez, los nuevos dominios dejan de ser nodos del grafo y pasan a ser nuevas funciones que el modelo puede descubrir a partir de sus esquemas y documentación. El siguiente artículo desarrolla este ciclo con el patrón ReAct y luego vuelve al grafo de la Parte 2 para mostrar cuánto se reduce la complejidad una vez que las decisiones son tomadas mediante llamadas a herramientas.
Lecturas relacionadas
- RAG agente en LangGraph: evaluadores, enrutamiento condicional y solución de respaldo mediante búsqueda web — Transferir un pipeline lineal RAG de LangChain a un StateGraph de LangGraph con evaluadores basados en LLM, entradas y bordes condicionales, pruebas y un endpoint FastAPI que indica el origen de los datos.
- Flujo de trabajo multiagente en LangGraph: comparación entre enjambre y supervisor — Dividir un flujo de trabajo de LangGraph en subagentes con sistema de puntos de control, luego crear un asistente financiero tanto como enjambre como supervisor, y observar dónde falla cada modelo.