Usar Tools en LongChain 1.0 para crear Agentes IA

Tiempo de lectura: 3 minutos

Hoy vamos a aprender cómo usar Tools en LongChain para crear Agentes IA. Para ejecutar bien este tutorial, recomiendo visitar el de cómo instalar LangChain.

Primero: ¿Qué son las Tools en LangChain?

En el contexto de un Agente de LangChain, una Tool es cualquier función o recurso externo que el Modelo de Lenguaje Grande (LLM) puede invocar para obtener información o realizar una acción que está más allá de su propio conocimiento o capacidad de cálculo.

Piensa en el Agente como un CEO: puede pensar y razonar, pero necesita a sus «empleados» (las Tools) para hacer el trabajo real (buscar datos, calcular, enviar correos, etc.).

1. Funciones Internas de Python (Las más Comunes)

La forma más sencilla y común de crear una Tool en LangChain es envolver una función de Python normal para que el LLM pueda entender su propósito y cómo invocarla.

Ejemplo 1: Una función simple de cálculo

Si quieres que tu Agente pueda sumar números, el LLM no puede hacer el cálculo perfectamente, pero puede usar una Tool:

from langchain_core.tools import tool

# @tool: Este decorador convierte la función Python en una Tool de LangChain.
@tool
def sumar_dos_numeros(a: int, b: int) -> int:
    """Suma dos números enteros y retorna el resultado."""
    return a + b

# El Agente leerá:
# - El nombre de la función: sumar_dos_numeros
# - La docstring: "Suma dos números enteros y retorna el resultado." (¡Esta es la clave para que sepa cuándo usarla!)
# - Los parámetros: a y b (que el LLM debe proporcionar)

2. Recursos Externos (Tools Preconstruidas)

Las Tools también pueden ser wrappers (envoltorios) de servicios complejos o API. LangChain ya tiene muchas herramientas preconstruidas listas para usar:

Tipo de Tool	Ejemplo y Propósito
Búsqueda en Internet	TavilySearch o Google Search. El Agente las usa si la pregunta requiere información actualizada (ej: «¿Quién ganó el último partido de la NBA?»).
Ejecución de Código	PythonREPLTool. Permite al Agente ejecutar código Python para tareas complejas o validación.
Bases de Datos	Herramientas para interactuar con SQL o bases de datos vectoriales (como en RAG).

Ejemplo de Agente con Tools (Con tu Ollama Remoto)

Para que tu Agente (que usa tu modelo Ollama remoto) pueda usar estas Tools, debes proporcionárselas.

Pasos para un Agente Simple:

1. Define las Tools: Crea dos funciones Python usando el decorador @tool.
2. Configura el LLM: Usa tu ChatOllama remoto.
3. Vincular: «Bindear» las herramientas al LLM para decirle al modelo que estas funciones están disponibles.
4. Crear el Agente: Usar el modelo (con las herramientas) y un Prompt de sistema para crear la Cadena de Agente.

Instalamos las librerias necesarias:

pip install langchain langchain_community

Ahora se crea un objeto de conexión ChatOllama

# 2. Importa la clase desde el nuevo paquete
from langchain_community.chat_models import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
# ... otras importaciones ...

# ⚠️ TU CONFIGURACIÓN REMOTA
OLLAMA_SERVER_URL = "URL OLLAMA"
MODEL_NAME = "llama3.2:3b"

# 3. Inicializar el LLM (el resto del código es igual)
try:
    llm = ChatOllama(
        model=MODEL_NAME,
        base_url=OLLAMA_SERVER_URL,
        temperature=0.7
    )
    print(f"✅ Conectado a ChatOllama en: {OLLAMA_SERVER_URL}")

    # ... continuar con bind_tools(mis_tools) y la creación del agente.

except Exception as e:
    print(f"❌ Error al inicializar o vincular: {e}")

Ejemplo de Tools:

from langchain_core.tools import tool

@tool
def conseguir_temperatura_actual(ciudad: str) -> str:
    """
    Retorna la temperatura actual en una ciudad específica.
    Útil para preguntas sobre el clima.
    """
    if "madrid" in ciudad.lower():
        return "25°C, soleado"
    elif "londres" in ciudad.lower():
        return "12°C, nublado y llovizna"
    else:
        return f"No tengo datos climáticos para {ciudad}."

@tool
def conseguir_precio_stock(simbolo: str) -> str:
    """
    Retorna el precio actual de una acción de la bolsa usando su símbolo (ej: 'GOOG').
    Útil para preguntas financieras.
    """
    simbolo = simbolo.upper()
    if simbolo == "GOOG":
        return "Precio: $175.40 USD"
    elif simbolo == "AAPL":
        return "Precio: $190.15 USD"
    else:
        return f"No se encontró el símbolo bursátil: {simbolo}"

mis_tools = [conseguir_temperatura_actual, conseguir_precio_stock]

Luego, en LangChain, usarías una técnica llamada «Function Calling» o «Tool Calling» para que el LLM decida cuál usar en su cadena de razonamiento.

Creación y Prueba del Agente

Ahora creamos la Cadena de Agente (Chain) que gestionará el razonamiento y la ejecución de las herramientas.

from langchain.agents import initialize_agent, AgentType
  # Inicializar agente
agent = initialize_agent(
    tools=mis_tools,
    llm=llm,
    agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

#Ejecutar
pregunta1 = "¿Cuál es la temperatura actual en Madrid?"
respuesta1 = agent.invoke(pregunta1)

pregunta2 = "¿Cuál es el precio de GOOG?"
respuesta2 = agent.invoke(pregunta2)

print("💬 Temperatura:", respuesta1)
print("💬 Precio GOOG:", respuesta2)