Inicio / Artículos / Tu primer agente de IA que utiliza herramientas con LangChain

ailangchainllmpythonagents

Tu primer agente de IA que utiliza herramientas 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.

1062 palabras

Un breve ejercicio en Python + LangChain permite crear un agente similar a una calculadora que puede invocar funciones de suma, resta, multiplicación, división o raíz cuadrada cuando sea necesario.

La aritmética es secundaria. La lección útil consiste en observar cómo un LLM recibe funciones auxiliares llamables y decide cuál función invocar y en qué paso.

Ejemplos de preguntas que puede resolver el agente finalizado:

Multiplique 25 por 4. Tome la raíz cuadrada de 144 y luego multiplique ese resultado por 5.

En lugar de programar la secuencia exacta de cálculos, se registran varias funciones auxiliares. El modelo elige entre ellas según las palabras del usuario.

1. Inicialice el modelo

Comience por construir el modelo de chat:

from langchain.chat_models import init_chat_model

model = init_chat_model("openai:gpt-4o-mini")

Aún no existe nada similar a un agente; solo hay un modelo de texto que puede leer y escribir.

2. Registre las funciones auxiliares llamables

Los agentes resultan útiles cuando van más allá de la simple generación de texto y pueden invocar funciones de aplicaciones.

Se definen cinco ayudantes mínimos:

from langchain.tools import tool
import math

@tool
def add(a: float, b: float) -> float:
    """Add two numbers."""
    return a + b

@tool
def subtract(a: float, b: float) -> float:
    """Subtract two numbers."""
    return a - b


@tool
def multiply(a: float, b: float) -> float:
    """Multiply two numbers."""
    return a * b


@tool
def divide(a: float, b: float) -> float:
    """Divide two numbers."""
    if b == 0:
        raise ValueError("Cannot divide by zero.")
    return a / b


@tool
def square_root(a: float) -> float:
    """Calculate the square root of a number."""
    if a < 0:
        raise ValueError("Cannot calculate square root of a negative number.")
    return math.sqrt(a)

Al decorar con @tool se expone cada función en un formato que el entorno de ejecución del agente comprende.

Hay dos detalles que guían al modelo:

  1. Los parámetros anotados indican los tipos de argumentos esperados.
a: float
b: float
  1. Las documentaciones proporcionan descripciones en lenguaje sencillo que el modelo lee al decidir la relevancia.

En cuanto a las herramientas para agentes, la descripción narrativa de una función forma parte de la interfaz de control, no de su decoración.

"""Multiply two numbers."""

3. Conectar el agente

Se adjuntan los ayudantes al modelo:

from langchain.agents import create_agent

agent = create_agent(
    model=model,
    tools=[
        add,
        subtract,
        multiply,
        divide,
        square_root
    ],
)

A partir de aquí, el modelo de chat puede funcionar como un agente en lugar de simplemente dar una respuesta única.

Los pasos típicos incluyen:

  1. Analizar la intención del usuario
  • Juzgar si se necesita un asistente
  • Elegir un asistente
  • Proporcionar argumentos
  • Utilizar el valor de retorno del asistente
  • Decidir si se necesita otro paso
  • Emitir la respuesta final

    • A nivel general:

    User
 ↓
Agent
 ↓
Should I use a tool?
 ↓
Choose tool
 ↓
Execute tool
 ↓
Get result
 ↓
Final response

    Las preguntas de múltiples pasos pueden repetir ese bucle.

    4. Ejecutar una ejecución

    Basta con un envoltorio simple para gestionarlo:

    def run_agent(question: str):
    """Run the agent and print the execution trace."""

    print(f"User: {question}")

    result = agent.invoke({
        "message": [("user", question)],
    })

    print("Agent:", result)

    Llamarlo con una pregunta sencilla:

    run_agent("What is 25 multiplied by 4?")

    Obsérvese que no hay instrucción alguna que diga “llamar a multiply”.

    Solo se proporcionó el catálogo de asistentes.

    Basándose en la redacción y en la descripción de cada asistente, el modelo concluye que la multiplicación es adecuada.

    5. Enlazar más de un asistente

    Pruebe una instrucción compuesta:

    run_agent(
    "Calculate the square root of 144 and multiply the result by 5."
)

    Son necesarias dos operaciones.

    El rastro conceptual se ve así:

    User:

Calculate √144 × 5
        ↓
Agent chooses square_root
        ↓
square_root(144)
        ↓
12
        ↓
Agent chooses multiply
        ↓
multiply(12, 5)
        ↓
60
        ↓
Final answer

    Ese ciclo — elegir, llamar, observar, elegir de nuevo — es la esencia de los agentes que utilizan herramientas.

    El código de la aplicación no necesita codificar por adelantado el orden completo de las operaciones.

    El modelo puede deducir el siguiente paso a partir de las herramientas restantes y del estado de la conversación.

    6. Contraste con un LLM simple

    Sin herramientas, un modelo podría inventar “La respuesta es 60” como texto.

    Con herramientas registradas, puede asignar tareas numéricas a funciones reales.

    El cambio en el control

    Ruta solo de texto: Usuario → modelo → cadena de respuesta

    en contraste con:

    Tool-using agent

User
  ↓
LLM
  ↓
Choose tool
  ↓
Execute code
  ↓
Observe result
  ↓
LLM
  ↓
Answer

    El modelo ya no tiene que realizar todas las computaciones por sí mismo.

    Proponga qué acción debe ejecutarse a continuación; la aplicación decide qué acciones existen y cómo se ejecutan.

    7. El límite que merece protección

    La calculadora es un juguete didáctico.

    La idea clave es la separación entre el juicio del modelo y la autoridad para aplicar acciones.

    La comprensión del lenguaje natural y la selección de acciones encajan bien con los LLM.

    La ejecución de esas acciones debe realizarse en Python, bajo su control.

    El modelo puede concluir que es necesario realizar dicha división.

    Su proceso se encarga de implementar esa separación y de sus efectos secundarios.

    Sustituya los auxiliares matemáticos simples por operaciones del dominio, como:

    get_customer()
search_transactions()
create_report()
send_email()
query_database()
get_weather()
create_ticket()

    y el mismo patrón de orquestación comienza a asemejarse a los diseños de agentes en entornos reales.

    Resumen del ejercicio

    Unos pocos módulos crearon un agente capaz de:

    • Interpretar preguntas en formato libre
    • Elegir entre varios auxiliares registrados
    • Vincular los argumentos correctamente
    • Combinar auxiliares dentro de una misma sesión
    • Reutilizar las salidas de los auxiliares en razonamientos posteriores
  • Responde al usuario una vez que se complete la cadena

    • En resumen: un LLM que selecciona y ejecuta acciones, no uno que solo emite texto.

    Lecturas relacionadas

    Todos los artículosEnviar el brief