Herramientas en LangChain

Las herramientas (tools) representan uno de los conceptos más transformadores en el desarrollo de aplicaciones con LangChain. Mientras que los modelos de lenguaje por sí solos están limitados a generar texto basado en su entrenamiento, las tools les permiten interactuar con el mundo exterior, ejecutar código, realizar búsquedas web y acceder a APIs externas.

En LangChain 0.3, el sistema de herramientas ha evolucionado hacia un enfoque más moderno y eficiente. Las tools actuales se integran perfectamente con LCEL (LangChain Expression Language) y proporcionan una interfaz consistente para extender las capacidades de los modelos de lenguaje.

Fundamentos de las herramientas modernas

Una tool en LangChain es esencialmente una función que puede ser invocada por un modelo de lenguaje para realizar una tarea específica. El modelo recibe una descripción de la herramienta y puede decidir cuándo y cómo utilizarla basándose en el contexto de la conversación.

El patrón moderno utiliza el decorador @tool para convertir funciones Python estándar en herramientas compatibles con LangChain:

from langchain_core.tools import tool

@tool
def calcular_area_circulo(radio: float) -> float:
    """Calcula el área de un círculo dado su radio."""
    import math
    return math.pi * radio ** 2

Esta aproximación ofrece varias ventajas sobre los patrones legacy. La definición declarativa permite que el modelo comprenda automáticamente qué hace la herramienta, qué parámetros necesita y qué tipo de resultado devuelve.

Integración con modelos de chat

Las herramientas se integran con los chat models mediante el método bind_tools(), que permite al modelo conocer qué herramientas tiene disponibles:

from langchain_openai import ChatOpenAI

# Configurar el modelo con herramientas
llm = ChatOpenAI(model="gpt-4")
llm_with_tools = llm.bind_tools([calcular_area_circulo])

# El modelo puede ahora usar la herramienta
response = llm_with_tools.invoke("¿Cuál es el área de un círculo con radio 5?")

Cuando el modelo determina que necesita usar una herramienta, genera una tool call que contiene el nombre de la herramienta y los argumentos necesarios. Este mecanismo permite una interacción fluida entre el razonamiento del modelo y la ejecución de código específico.

Herramientas para búsquedas web

Una de las aplicaciones más comunes de las tools es permitir que los modelos accedan a información actualizada mediante búsquedas web. LangChain proporciona herramientas integradas para varios motores de búsqueda:

from langchain_community.tools import DuckDuckGoSearchRun

# Crear herramienta de búsqueda
search_tool = DuckDuckGoSearchRun()

# Integrar con el modelo
llm_with_search = llm.bind_tools([search_tool])

Esta capacidad transforma un modelo estático en un sistema que puede acceder a información en tiempo real, respondiendo preguntas sobre eventos actuales o datos que no estaban en su entrenamiento original.

Ejecución de código Python

Las herramientas de ejecución de código permiten que los modelos realicen cálculos complejos, generen gráficos o procesen datos:

@tool
def ejecutar_python(codigo: str) -> str:
    """Ejecuta código Python y devuelve el resultado."""
    try:
        # Configurar un entorno seguro para la ejecución
        namespace = {"__builtins__": {}}
        result = eval(codigo, namespace)
        return str(result)
    except Exception as e:
        return f"Error: {str(e)}"

Esta funcionalidad es especialmente útil para aplicaciones que requieren análisis de datos, cálculos matemáticos complejos o generación de visualizaciones.

Herramientas HTTP personalizadas

Para integrar con APIs externas, puedes crear herramientas que realicen peticiones HTTP:

import requests

@tool
def consultar_api_clima(ciudad: str) -> str:
    """Obtiene información meteorológica de una ciudad."""
    try:
        # Ejemplo con una API ficticia
        url = f"https://api.clima.com/v1/weather?city={ciudad}"
        response = requests.get(url)
        data = response.json()
        return f"Temperatura en {ciudad}: {data['temperature']}°C"
    except Exception as e:
        return f"Error al consultar el clima: {str(e)}"

Creación de herramientas con BaseTool

Para casos más complejos, puedes heredar de BaseTool para crear herramientas con mayor control sobre su comportamiento:

from langchain_core.tools import BaseTool
from typing import Type
from pydantic import BaseModel, Field

class CalculadoraInput(BaseModel):
    operacion: str = Field(description="Operación matemática a realizar")

class CalculadoraAvanzada(BaseTool):
    name = "calculadora_avanzada"
    description = "Realiza cálculos matemáticos complejos"
    args_schema: Type[BaseModel] = CalculadoraInput
    
    def _run(self, operacion: str) -> str:
        try:
            # Implementar lógica de cálculo segura
            result = eval(operacion)
            return f"Resultado: {result}"
        except Exception as e:
            return f"Error en el cálculo: {str(e)}"

Gestión de errores y validación

Las herramientas modernas incluyen validación automática de parámetros mediante Pydantic. Esto garantiza que los datos recibidos cumplan con los tipos y restricciones esperados:

@tool
def procesar_datos(numeros: list[float], operacion: str) -> float:
    """Procesa una lista de números con la operación especificada."""
    if not numeros:
        raise ValueError("La lista no puede estar vacía")
    
    if operacion == "suma":
        return sum(numeros)
    elif operacion == "promedio":
        return sum(numeros) / len(numeros)
    else:
        raise ValueError(f"Operación '{operacion}' no soportada")

Composición con LCEL

Las herramientas se integran perfectamente con LCEL para crear flujos de procesamiento complejos:

from langchain_core.output_parsers import StrOutputParser

# Crear una cadena que use herramientas
chain = llm_with_tools | StrOutputParser()

# Procesar múltiples consultas
consultas = [
    "Busca información sobre Python 3.13",
    "Calcula el área de un círculo con radio 10"
]

for consulta in consultas:
    resultado = chain.invoke(consulta)
    print(f"Consulta: {consulta}")
    print(f"Resultado: {resultado}\n")

Esta integración permite crear aplicaciones robustas que combinan el razonamiento de los modelos de lenguaje con la capacidad de ejecutar acciones concretas en el mundo real.