Agentes en producción: herramientas, estado y controlVista previa gratuita
Ver planesEntrar

Código del módulo

Los scripts completos de este módulo están pensados para correrse en tu máquina. Si estás probando la muestra gratis, descarga los scripts de este módulo inicial (.zip) (con un plan activo también bajas el curso completo en .zip).

01_workflow_vs_agente.py

Compara un workflow fijo de 3 pasos en código frente a un bucle de agente con tool calling sobre el ATS.

"""Compara un workflow fijo de 3 pasos en código frente a un bucle de agente con tool calling sobre el ATS."""
from __future__ import annotations

import json
import sys
import time
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
from comun.ag_comun import (
    CANDIDATOS,
    PresupuestoAgente,
    VACANTES,
    ejecutar_herramienta_ats,
    herramientas_ats,
    imprimir,
    motivos_bloqueo,
    terna_correcta,
)
from comun.ag_modelo import Modelo, crear_modelo


def workflow_fijo(vacante_id: str) -> dict:
    """Flujo determinista en código: 1) leer vacante, 2) evaluar cada candidato con motivos_bloqueo, 3) entregar terna."""
    t0 = time.perf_counter()
    vac = VACANTES[vacante_id]
    elegibles = sorted(cid for cid, c in CANDIDATOS.items() if not motivos_bloqueo(vac, c))
    ms = round((time.perf_counter() - t0) * 1000, 3)
    return {
        "modo": "workflow_fijo",
        "vacante_id": vacante_id,
        "llamadas_llm": 0,
        "pasos": 1,
        "costo_usd": 0.0,
        "latencia_ms": ms,
        "terna": elegibles,
        "exacta": elegibles == terna_correcta(vacante_id),
    }


def bucle_agente(modelo: Modelo, vacante_id: str, max_pasos: int = 16) -> dict:
    """Bucle ReAct controlado: el modelo decide qué herramienta llamar en cada turno hasta entregar la terna."""
    presupuesto = PresupuestoAgente(max_pasos=max_pasos)
    esquemas = herramientas_ats()
    mensajes: list[dict] = [
        {
            "role": "system",
            "content": (
                "Eres el agente de preselección técnica del ATS. "
                "Obtén la vacante, busca candidatos que cumplan las habilidades y el presupuesto, "
                "consulta su ficha, verifica su elegibilidad con verificar_elegibilidad y cierra con entregar_terna."
            ),
        },
        {"role": "user", "content": f"Preselecciona la terna de candidatos elegibles para la vacante {vacante_id}."},
    ]
    herramientas_usadas: list[str] = []
    terna_entregada: list[str] = []

    while True:
        presupuesto.abrir_paso()
        resp = modelo.responder(mensajes, esquemas)
        presupuesto.registrar(resp.tokens_entrada, resp.tokens_salida)

        if not resp.llamadas:
            break

        mensajes.append(
            {
                "role": "assistant",
                "content": resp.texto,
                "tool_calls": [
                    {
                        "id": tc.id,
                        "type": "function",
                        "function": {"name": tc.nombre, "arguments": json.dumps(tc.argumentos, ensure_ascii=False)},
                    }
                    for tc in resp.llamadas
                ],
            }
        )

        cerro = False
        for tc in resp.llamadas:
            herramientas_usadas.append(tc.nombre)
            resultado = ejecutar_herramienta_ats(tc.nombre, tc.argumentos)
            mensajes.append(
                {
                    "role": "tool",
                    "tool_call_id": tc.id,
                    "content": json.dumps(resultado, ensure_ascii=False),
                }
            )
            if tc.nombre == "entregar_terna":
                terna_entregada = sorted(resultado.get("candidatos") or [])
                cerro = True
        if cerro:
            break

    return {
        "modo": f"agente ({modelo.nombre})",
        "vacante_id": vacante_id,
        **presupuesto.resumen(),
        "herramientas": herramientas_usadas,
        "terna": terna_entregada,
        "exacta": terna_entregada == terna_correcta(vacante_id),
    }


if __name__ == "__main__":
    modelo = crear_modelo()
    imprimir("1. Workflow determinista en código (VAC-101)", workflow_fijo("VAC-101"))
    imprimir("2. Bucle de agente con herramientas (VAC-101)", bucle_agente(modelo, "VAC-101"))
    imprimir("3. Bucle de agente con herramientas (VAC-102)", bucle_agente(crear_modelo(), "VAC-102"))

02_presupuesto_y_frenos.py

Freno presupuestario fuera del modelo: corte determinista por pasos, tokens y dólares.

"""Freno presupuestario fuera del modelo: corte determinista por pasos, tokens y dólares."""
from __future__ import annotations

import json
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
from comun.ag_comun import (
    PresupuestoAgente,
    PresupuestoAgotado,
    ejecutar_herramienta_ats,
    herramientas_ats,
    imprimir,
    terna_correcta,
)
from comun.ag_modelo import Modelo, crear_modelo


def correr_con_presupuesto(modelo: Modelo, vacante_id: str, presupuesto: PresupuestoAgente) -> dict:
    esquemas = herramientas_ats()
    mensajes: list[dict] = [
        {"role": "system", "content": "Preselecciona candidatos elegibles y entrega la terna con entregar_terna."},
        {"role": "user", "content": f"Preselecciona la vacante {vacante_id}."},
    ]
    terna: list[str] = []
    motivo_corte: str | None = None

    try:
        while True:
            presupuesto.abrir_paso()
            r = modelo.responder(mensajes, esquemas)
            presupuesto.registrar(r.tokens_entrada, r.tokens_salida)
            if not r.llamadas:
                break
            mensajes.append(
                {
                    "role": "assistant",
                    "content": r.texto,
                    "tool_calls": [
                        {
                            "id": tc.id,
                            "type": "function",
                            "function": {"name": tc.nombre, "arguments": json.dumps(tc.argumentos, ensure_ascii=False)},
                        }
                        for tc in r.llamadas
                    ],
                }
            )
            fin = False
            for tc in r.llamadas:
                res = ejecutar_herramienta_ats(tc.nombre, tc.argumentos)
                mensajes.append({"role": "tool", "tool_call_id": tc.id, "content": json.dumps(res, ensure_ascii=False)})
                if tc.nombre == "entregar_terna":
                    terna = sorted(res.get("candidatos") or [])
                    fin = True
            if fin:
                break
    except PresupuestoAgotado as exc:
        motivo_corte = str(exc)

    return {
        "estado": "cortado_por_presupuesto" if motivo_corte else "completado",
        "motivo_corte": motivo_corte,
        **presupuesto.resumen(),
        "terna_entregada": terna,
        "exacta": terna == terna_correcta(vacante_id),
    }


if __name__ == "__main__":
    # 1) Ejecución sana dentro del presupuesto (12 pasos, 30k tokens, $0.05)
    sana = correr_con_presupuesto(
        crear_modelo(),
        "VAC-101",
        PresupuestoAgente(max_pasos=16, max_tokens=30_000, max_costo_usd=0.05),
    )
    imprimir("1. Ejecución normal dentro del presupuesto", sana)

    # 2) Agente atascado (terco=True repite la misma búsqueda vacía sin parar): el freno corta en el paso 5
    bucle = correr_con_presupuesto(
        crear_modelo(terco=True),
        "VAC-101",
        PresupuestoAgente(max_pasos=5, max_tokens=30_000, max_costo_usd=0.05),
    )
    imprimir("2. Agente en bucle infinito cortado por max_pasos=5", bucle)

    # 3) Tope estricto de tokens (max_tokens=1500): corta antes de acumular contexto excesivo
    tope_tokens = correr_con_presupuesto(
        crear_modelo(),
        "VAC-101",
        PresupuestoAgente(max_pasos=16, max_tokens=1_500, max_costo_usd=0.05),
    )
    imprimir("3. Corte por presupuesto de tokens (max_tokens=1500)", tope_tokens)
Código del módulo · Módulo 0 · Cuándo usar (y cuándo no usar) un agente · IA en Producción