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 esencialmente 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 de las tools

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 agente 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, permitiendo que el LLM comprenda cuándo y cómo usar cada herramienta disponible.

from langchain_core.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)}"

Ejemplo de creación de tool (todavía no la estamos usando en LLM, eso después, primero hay que definirla):

Clasificación de tools por complejidad

Las tools se pueden clasificar en diferentes categorías según su complejidad y alcance funcional:

Tools simples son aquellas que realizan operaciones básicas y autocontenidas. Ejemplos típicos incluyen calculadoras matemáticas, conversores de unidades, generadores de fechas o validadores de formato. Estas tools suelen tener 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,
        # ... más conversiones
    }
    
    if (desde, hacia) in conversiones:
        resultado = conversiones[(desde, hacia)](valor)
        return f"{valor}°{desde} = {resultado:.2f}°{hacia}"
    else:
        return "Conversión no soportada"

Tools complejas involucran interacciones con sistemas externos, APIs de terceros o bases de datos. Estas herramientas pueden requerir autenticación, manejo de errores sofisticado y procesamiento de respuestas estructuradas. Ejemplos incluyen consultas a APIs meteorológicas, búsquedas en bases de datos empresariales o integración con servicios web.

import requests
from typing import Dict, Any

@tool
def consultar_clima(ciudad: str, pais: str = "ES") -> str:
    """
    Obtiene información meteorológica actual de una ciudad.
    
    Args:
        ciudad: Nombre de la ciudad
        pais: Código del país (por defecto ES para España)
    """
    api_key = "tu_api_key_aqui"
    url = f"http://api.openweathermap.org/data/2.5/weather"
    
    params = {
        "q": f"{ciudad},{pais}",
        "appid": api_key,
        "units": "metric",
        "lang": "es"
    }
    
    try:
        response = requests.get(url, params=params)
        data = response.json()
        
        if response.status_code == 200:
            temp = data["main"]["temp"]
            descripcion = data["weather"][0]["description"]
            return f"En {ciudad}: {temp}°C, {descripcion}"
        else:
            return f"No se pudo obtener el clima para {ciudad}"
    except Exception as e:
        return f"Error al consultar el clima: {str(e)}"

Casos de uso principales

Las tools encuentran aplicación en múltiples dominios donde los LLMs necesitan acceder a información actualizada o realizar acciones específicas:

Automatización de tareas empresariales representa uno de los casos más comunes. Las tools pueden integrarse con sistemas CRM, ERP o herramientas de gestión de proyectos, permitiendo que los asistentes de IA consulten estados de pedidos, actualicen registros de clientes o generen reportes automáticamente.

Análisis de datos en tiempo real es otro caso fundamental. Las tools pueden conectarse a bases de datos, APIs de analytics o servicios de monitorización para proporcionar insights actualizados sobre métricas de negocio, rendimiento de aplicaciones o tendencias de mercado.

@tool
def consultar_ventas_mes(mes: int, año: int) -> str:
    """
    Consulta las ventas totales de un mes específico.
    
    Args:
        mes: Número del mes (1-12)
        año: Año de consulta
    """
    # Simulación de consulta a base de datos
    query = f"""
    SELECT SUM(total) as ventas_totales 
    FROM ventas 
    WHERE MONTH(fecha) = {mes} AND YEAR(fecha) = {año}
    """
    
    # En un caso real, aquí iría la conexión a la base de datos
    ventas_simuladas = 45000.50
    
    return f"Las ventas de {mes}/{año} fueron: €{ventas_simuladas:,.2f}"

Integración con servicios externos permite que los LLMs accedan a APIs públicas o servicios especializados. Esto incluye consultas a servicios de traducción, APIs de redes sociales, plataformas de e-commerce o servicios de geolocalización.

Procesamiento de documentos y archivos es especialmente relevante en entornos empresariales. Las tools pueden leer, procesar y generar documentos en diferentes formatos, extraer información de PDFs, manipular hojas de cálculo o generar reportes estructurados.

Ventajas de usar tools en aplicaciones de IA

La implementación de tools aporta flexibilidad y escalabilidad a las aplicaciones basadas en LLMs. Los modelos pueden adaptar su comportamiento según las herramientas disponibles, creando experiencias más dinámicas y contextualmente relevantes.

Las tools también mejoran la precisión de las respuestas al permitir que los modelos accedan a información actualizada en lugar de depender únicamente de su conocimiento de entrenamiento. Esto es especialmente valioso para consultas que requieren datos en tiempo real o información específica de dominio.

Desde una perspectiva de mantenimiento, las tools permiten actualizar funcionalidades sin necesidad de reentrenar modelos. Los desarrolladores pueden agregar, modificar o eliminar herramientas según evolucionen los requisitos del negocio, manteniendo la aplicación actualizada y relevante.

La modularidad que proporcionan las tools facilita el desarrollo colaborativo y la reutilización de código. Una tool bien diseñada puede utilizarse en múltiples contextos y aplicaciones, reduciendo el tiempo de desarrollo y mejorando la consistencia entre proyectos.

Integración de tools con modelos que soportan tool calling

Los modelos modernos de lenguaje han evolucionado para incluir 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. Esta integración representa un salto cualitativo respecto a los enfoques tradicionales, donde la invocación de herramientas requería lógica adicional de orquestación.

Modelos compatibles con tool calling

Los modelos más recientes de OpenAI, Anthropic, Google y otros proveedores incluyen soporte nativo para tool calling. Estos modelos han sido entrenados específicamente para comprender esquemas de herramientas y generar llamadas estructuradas cuando detectan que necesitan información externa o deben realizar acciones específicas.

En LangChain, el modelo ChatOpenAI con GPT-4 proporciona una implementación robusta de tool calling. El modelo puede analizar el contexto de la conversación, identificar cuándo una herramienta es necesaria y generar la invocación apropiada con los parámetros correctos.

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

# Definir una herramienta simple
@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)
    """
    # Simulación de consulta a API financiera
    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}"

# Inicializar el modelo
llm = ChatOpenAI(model="gpt-4", 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. Esta vinculación informa al modelo sobre las capacidades disponibles y sus esquemas, permitiendo que tome decisiones informadas sobre cuándo invocar cada herramienta.

# 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. En su lugar, el modelo genera tool calls que contienen la información necesaria para invocar la herramienta, incluyendo el nombre de la función y los argumentos estructurados.

Ejemplo:

Procesamiento de tool calls

Cuando un modelo genera tool calls, estos aparecen como metadatos estructurados en la respuesta. Cada tool call incluye un identificador único, el nombre de la herramienta y los argumentos parseados según el esquema definido.

from langchain_core.messages import ToolMessage

# Procesar tool calls manualmente
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 de {tool_name}: {result}")

Ejemplo de procesar tool y agregar el mensaje al historial de mensajes de la conversación:

Este proceso se simplificará más adelante en el curso de LangGraph con ReAct agents.

Flujo completo con LCEL

LangChain Expression Language (LCEL) proporciona una forma elegante de crear cadenas que manejan automáticamente la ejecución de herramientas. El operador | permite componer el flujo de manera declarativa y legible.

from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableLambda

def ejecutar_tools(message):
    """Ejecuta las herramientas invocadas por el modelo."""
    if hasattr(message, 'tool_calls') and message.tool_calls:
        tool_results = []
        
        for tool_call in message.tool_calls:
            if tool_call["name"] == "obtener_precio_accion":
                result = obtener_precio_accion.invoke(tool_call["args"])
                tool_results.append(ToolMessage(
                    content=result,
                    tool_call_id=tool_call["id"]
                ))
        
        return tool_results
    return []

# Crear cadena con LCEL
chain = llm_with_tools | RunnableLambda(ejecutar_tools)

# Usar la cadena
messages = [HumanMessage(content="¿Cuánto vale Microsoft ahora?")]
result = chain.invoke(messages)
print(result)

Manejo de múltiples herramientas

Los modelos con tool calling pueden trabajar con múltiples herramientas simultáneamente, seleccionando la más apropiada según el contexto de la consulta. Esta capacidad permite crear asistentes versátiles que pueden manejar diferentes tipos de solicitudes.

@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 de cambio simuladas
    tasas = {
        ("USD", "EUR"): 0.85,
        ("EUR", "USD"): 1.18,
        ("USD", "GBP"): 0.73,
        ("GBP", "USD"): 1.37
    }
    
    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")
])

Ventajas del tool calling nativo

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, reduciendo la necesidad de lógica condicional compleja.

La precisión en la extracción de parámetros mejora considerablemente, ya que los modelos comprenden el contexto semántico de las solicitudes. Esto reduce errores comunes como tipos de datos incorrectos o parámetros faltantes.

# El modelo maneja automáticamente variaciones en la consulta
consultas_variadas = [
    "¿Precio de Apple?",
    "Dime cuánto vale AAPL ahora",
    "Necesito el valor actual de las acciones de Apple Inc."
]

for consulta in consultas_variadas:
    response = llm_with_tools.invoke([HumanMessage(content=consulta)])
    if response.tool_calls:
        print(f"Consulta: {consulta}")
        print(f"Tool call generado: {response.tool_calls[0]}")
        print("---")

La escalabilidad también mejora, ya que agregar nuevas herramientas no requiere modificar la lógica de routing. El modelo aprende automáticamente a usar nuevas herramientas basándose en sus esquemas y descripciones.

Consideraciones de rendimiento

Los modelos con tool calling pueden generar múltiples llamadas en una sola respuesta cuando detectan que necesitan información de varias fuentes. Esta capacidad permite resolver consultas complejas de manera eficiente.

# Consulta que puede requerir múltiples herramientas
response = llm_multi_tools.invoke([
    HumanMessage(content="¿Cuánto vale Apple en euros?")
])

# El modelo podría generar dos tool calls:
# 1. obtener_precio_accion para AAPL
# 2. convertir_moneda de USD a EUR
if response.tool_calls:
    print(f"Herramientas invocadas: {len(response.tool_calls)}")
    for i, tool_call in enumerate(response.tool_calls):
        print(f"{i+1}. {tool_call['name']} con args: {tool_call['args']}")

El caching de resultados de herramientas puede mejorar significativamente el rendimiento en aplicaciones que realizan consultas repetitivas. LangChain proporciona mecanismos para implementar caching a nivel de herramienta sin modificar la lógica del modelo.