Introducción a herramientas

Qué son las tools en LangChain y casos de uso

Las tools en LangChain representan una abstracción fundamental que permite a los modelos de lenguaje interactuar con el mundo exterior más allá de su conocimiento interno. Una tool es una función Python encapsulada con un esquema estructurado que describe sus parámetros, tipos de datos y propósito, permitiendo que los LLMs puedan invocarla de manera autónoma cuando necesiten realizar acciones específicas.

Concepto fundamental

A diferencia de las consultas tradicionales donde el modelo solo puede generar texto basado en su entrenamiento, las tools amplían las capacidades del LLM permitiéndole ejecutar código, consultar APIs externas, acceder a bases de datos o realizar cálculos complejos en tiempo real. Esta funcionalidad transforma al modelo de un generador de texto estático a un componente capaz de interactuar dinámicamente con sistemas externos.

El esquema de una tool define claramente qué información necesita recibir y qué tipo de resultado producirá. Este esquema actúa como un contrato entre el modelo y la función:

from langchain.tools import tool

@tool
def calculadora_basica(operacion: str) -> str:
    """
    Realiza operaciones matemáticas básicas.
    
    Args:
        operacion: Expresión matemática como string (ej: "2 + 3 * 4")
    
    Returns:
        Resultado de la operación como string
    """
    try:
        resultado = eval(operacion)
        return f"El resultado de {operacion} es {resultado}"
    except Exception as e:
        return f"Error en la operación: {str(e)}"

Clasificación de tools por complejidad

Las tools se clasifican según su complejidad y alcance funcional:

Tools simples realizan operaciones básicas y autocontenidas. Ejemplos típicos incluyen calculadoras, conversores de unidades o validadores de formato. Tienen pocos parámetros y producen resultados inmediatos sin dependencias externas:

@tool
def convertir_temperatura(valor: float, desde: str, hacia: str) -> str:
    """
    Convierte temperaturas entre diferentes escalas.
    
    Args:
        valor: Temperatura a convertir
        desde: Escala origen ('C', 'F', 'K')
        hacia: Escala destino ('C', 'F', 'K')
    """
    conversiones = {
        ('C', 'F'): lambda c: c * 9/5 + 32,
        ('C', 'K'): lambda c: c + 273.15,
        ('F', 'C'): lambda f: (f - 32) * 5/9,
    }
    
    if (desde, hacia) in conversiones:
        resultado = conversiones[(desde, hacia)](valor)
        return f"{valor}°{desde} = {resultado:.2f}°{hacia}"
    return "Conversión no soportada"

Tools complejas involucran interacciones con sistemas externos, APIs de terceros o bases de datos. Requieren autenticación, manejo de errores sofisticado y procesamiento de respuestas estructuradas.

Casos de uso principales

Las tools encuentran aplicación en múltiples dominios:

• Automatización empresarial: Integración con sistemas CRM, ERP o herramientas de gestión de proyectos
• Análisis de datos en tiempo real: Conexión a bases de datos, APIs de analytics o servicios de monitorización
• Integración con servicios externos: Consultas a APIs públicas, plataformas de e-commerce o servicios de geolocalización
• Procesamiento de documentos: Lectura, procesamiento y generación de documentos en diferentes formatos

Integración de tools con modelos que soportan tool calling

Los modelos modernos incluyen capacidades nativas de tool calling, una funcionalidad que permite al modelo decidir automáticamente cuándo y cómo invocar herramientas externas durante una conversación.

Modelos compatibles con tool calling

Los modelos de OpenAI, Anthropic, Google y otros proveedores incluyen soporte nativo para tool calling. Han sido entrenados para comprender esquemas de herramientas y generar llamadas estructuradas cuando detectan que necesitan información externa.

from langchain_openai import ChatOpenAI
from langchain.tools import tool
from langchain.messages import HumanMessage

@tool
def obtener_precio_accion(simbolo: str) -> str:
    """
    Obtiene el precio actual de una acción.
    
    Args:
        simbolo: Símbolo bursátil (ej: AAPL, GOOGL)
    """
    precios = {"AAPL": 175.50, "GOOGL": 2800.25, "MSFT": 380.75}
    precio = precios.get(simbolo.upper(), "No disponible")
    return f"El precio actual de {simbolo} es ${precio}"

llm = ChatOpenAI(model="gpt-4o", temperature=0)

Vinculación de tools con bind_tools()

El método bind_tools() establece la conexión entre el modelo y las herramientas disponibles:

# Vincular la herramienta al modelo
llm_with_tools = llm.bind_tools([obtener_precio_accion])

# El modelo ahora conoce la herramienta disponible
response = llm_with_tools.invoke([
    HumanMessage(content="¿Cuál es el precio actual de Apple?")
])

print(response.content)
print("Tool calls:", response.tool_calls)

La vinculación es declarativa y no ejecuta automáticamente las herramientas. El modelo genera tool calls que contienen la información necesaria para invocar la herramienta.

Procesamiento de tool calls

Cuando un modelo genera tool calls, estos aparecen como metadatos estructurados en la respuesta:

from langchain.messages import ToolMessage

if response.tool_calls:
    for tool_call in response.tool_calls:
        tool_name = tool_call["name"]
        tool_args = tool_call["args"]
        tool_id = tool_call["id"]
        
        # Ejecutar la herramienta
        if tool_name == "obtener_precio_accion":
            result = obtener_precio_accion.invoke(tool_args)
            
            # Crear mensaje con el resultado
            tool_message = ToolMessage(
                content=result,
                tool_call_id=tool_id
            )
            print(f"Resultado: {result}")

Manejo de múltiples herramientas

Los modelos pueden trabajar con múltiples herramientas simultáneamente, seleccionando la más apropiada según el contexto:

@tool
def convertir_moneda(cantidad: float, desde: str, hacia: str) -> str:
    """
    Convierte entre diferentes monedas.
    
    Args:
        cantidad: Cantidad a convertir
        desde: Moneda origen (USD, EUR, GBP)
        hacia: Moneda destino (USD, EUR, GBP)
    """
    tasas = {("USD", "EUR"): 0.85, ("EUR", "USD"): 1.18}
    tasa = tasas.get((desde, hacia), 1.0)
    resultado = cantidad * tasa
    return f"{cantidad} {desde} = {resultado:.2f} {hacia}"

# Vincular múltiples herramientas
llm_multi_tools = llm.bind_tools([obtener_precio_accion, convertir_moneda])

# El modelo elegirá la herramienta apropiada
response = llm_multi_tools.invoke([
    HumanMessage(content="Convierte 100 dólares a euros")
])

El tool calling nativo ofrece ventajas significativas sobre los enfoques tradicionales de parsing y routing manual. Los modelos pueden interpretar consultas ambiguas y determinar automáticamente qué herramientas son relevantes. La escalabilidad también mejora, ya que agregar nuevas herramientas no requiere modificar la lógica de routing.

Este proceso se simplificará en el módulo de LangGraph con agentes, donde el bucle de ejecución de herramientas se maneja automáticamente.