Qué te ofrece realmente LangChain más allá de la simple llamada a herramientas
Los bucles de herramientas elaborados a mano enseñan a la maquinaria; LangChain traslada los esquemas, el historial y la orquestación de agentes detrás de abstracciones para que la lógica del producto siga siendo el foco.
Las aplicaciones de IA pueden llamar directamente a una API LLM y controlar cada detalle. Ese enfoque tiene una ventaja real: el flujo de control es visible. Pero también conlleva costos. Tan pronto como el producto supera un solo intercambio de mensajes, aparece mucho código que en realidad no corresponde a la lógica del producto.
Los componentes típicos incluyen:
- Definir herramientas y esquemas
- Enviar las herramientas al modelo
- Gestionar las respuestas de las llamadas a herramientas
- Ejecutar las funciones solicitadas
- Devolver los resultados de las herramientas
- Mantener el historial de la conversación
- Coordinar múltiples llamadas a herramientas
- Dirigir el ciclo modelo↔herramienta
Esos pasos son excelentes para aprender. En una aplicación de envíos, repetirlos manualmente se convierte en la tarea principal.
Existen frameworks como LangChain para absorber esa repetición.
El costo de hacer todo a mano
Imagínese una pequeña herramienta de calculadora. Sin un marco de trabajo, el camino a seguir sería más o menos así:
User
↓
LLM API
↓
LLM requests calculator
↓
Our code detects the request
↓
Our code executes calculator()
↓
Our code sends the result back
↓
LLM generates the final answer
Con una sola herramienta se mantiene todo bajo control. Veinte herramientas, varios modelos, estado de chat duradero, intentos repetidos y flujos de trabajo de agentes ramificados convierten la “lógica simple del producto” en un proyecto de orquestación.
Existen abstracciones porque esa maquinaria crece más rápido que la lista de funcionalidades.
Qué aporta LangChain
LangChain proporciona estructuras comunes para modelos, herramientas, mensajes y entornos de ejecución de agentes. En lugar de conectar cada paso manualmente, basta describir las capacidades y dejar que el marco de trabajo se encargue de gran parte del código genérico.
Crear una herramienta
Una función normal de Python se convierte en una herramienta:
from langchain.tools import tool
def calculator(a: float, b: float, operation: str):
"""Perform a mathematical calculation."""
if operation == "add":
return a + b
elif operation == "subtract":
return a - b
elif operation == "multiply":
return a * b
elif operation == "divide":
if b == 0:
return "Cannot divide by zero."
return a / b
return "Unknown operation."
El cuerpo de la calculadora sigue siendo la lógica de la aplicación. LangChain solo lo envuelve para que un LLM pueda solicitarlo.
Conectar la herramienta a un modelo
from langchain_google_genai import ChatGoogleGenerativeAI
model = ChatGoogleGenerativeAI(
model="gemini-3.5-flash-lite"
)
model_with_tools = model.bind_tools([calculator])
Luego se invoca:
response = model_with_tools.invoke(
"What is 2 + 6?"
)
El modelo puede responder con una solicitud estructurada de herramienta, como por ejemplo:
calculator(
a=2,
b=6,
operation="add"
)
bind_tools() no ejecuta la calculadora. Solo indica su disponibilidad: el modelo puede solicitarla cuando sea necesario.
Dónde aparece la abstracción
De forma manual, el ingeniero gestiona un proceso largo:
Create function
↓
Create tool schema
↓
Send schema to LLM
↓
Receive tool call
↓
Extract arguments
↓
Execute function
↓
Create tool result
↓
Send result back to LLM
↓
Check if another tool call is needed
↓
Repeat
Con LangChain, gran parte de ese proceso se lleva a cabo durante la ejecución del agente. La atención se desplaza hacia:
What capability does my application need?
↓
Define the tool
↓
Give it to the model
↓
Build the application
La complejidad no desapareció; simplemente pasó a estar detrás de un límite.
Qué se logra realmente
LangChain no inventa el mecanismo de llamada a herramientas; las APIs en bruto ya lo soportan. La ventaja radica en no tener que reinventar esquemas, bucles y manejo de historial para cada funcionalidad. El tiempo se destina entonces a cuestiones relacionadas con el producto:
- ¿Qué debería poder hacer el asistente?
- ¿Qué herramientas deben formar parte del alcance?
- ¿Qué ocurre cuando una herramienta falla?
¿Debería cada proyecto usar un framework?
No siempre. Llamar a herramientas desarrolladas manualmente sigue siendo la mejor forma de aprender. Recorrer el proceso una vez:
LLM
↓
Tool call
↓
Application
↓
Tool execution
↓
Tool result
↓
LLM
hace que el comportamiento posterior del framework sea menos misterioso. Utilizar una abstracción sin conocer el problema que resuelve hace que la depuración sea difícil.
Un hábito útil: primero aprender los mecanismos subyacentes y luego adoptar abstracciones para que no sea necesario reescribirlos en cada tarea. Los equipos que omiten este primer paso suelen tratar a LangChain como algo mágico y se detienen cuando el esquema de una herramienta o la política de reintentos funciona mal. Los equipos que dominan ambos aspectos avanzan más rápido sin perder la capacidad de recurrir a los mecanismos básicos cuando lo exigen los incidentes en producción.
Lecturas relacionadas
- Tu primera herramienta: usando un agente de IA con LangChain — Crea un pequeño agente matemático de LangChain en Python: inicializa un modelo de chat, registra herramientas, permite que el LLM elija qué función llamar y observa el uso de herramientas en múltiples pasos.
- LangChain vs LangGraph: qué muestran realmente las dependencias del paquete — Un desglose a nivel de dependencias revela que LangGraph es una parte necesaria de LangChain, lo que reconfigura la elección del framework como tres paquetes en lugar de dos.
- Bloques de construcción de LangChain para aplicaciones reales de IA — Modelos, prompts, cadenas, herramientas, agentes y RAG: cómo LangChain organiza las aplicaciones basadas en LLM más allá de una sola llamada a la API del proveedor.