Saltar al contenido

Lección 18 de 20 · Lectura y práctica

Desarrollo de lógica condicional para tareas complejas

Tipo de lección: VideoConcepto claveLa lógica condicional en agentes de IA con LangGraph es el mecanismo que permite que tu agente tome decisiones dinámicas basadas en el contexto actual, su memoria y los resultados de.

Del concepto a la práctica

Taller de esta lección

Las tareas complejas se vuelven controlables cuando cada etapa declara qué condición permite avanzar y cuál obliga a detenerse. Para un informe local, no generes el resultado si faltan registros: conserva el diagnóstico y solicita corrección de entrada.

Ejemplo resuelto

python
def ruta(s):
    if s["registros"] == 0:
        return "pedir_datos"
    if s["anomalias"] > 0:
        return "revisar"
    return "generar"

print(ruta({"registros": 3, "anomalias": 1}))
# revisar

Valida también anomalías como entero no negativo y menor o igual al número de registros cuando cuentas registros anómalos. Registros negativos, bool o una anomalía en cero registros son error_entrada, no una cuarta forma de generar informe. Define máximo2 revisiones y una ruta derivar cuando no hay corrección, porque el límite de recursión técnico no sustituye una salida de negocio comprensible.

Pruébalo

  1. Valida que registros sea un entero no negativo.

  2. Comprueba ausencia de datos antes de calcular.

  3. Separa anomalías de datos faltantes.

  4. Añade un límite de ciclos para cualquier revisión repetida.

Un error frecuente es usar cero registros como si significara “informe vacío válido”. Corrígelo distinguiendo pedir_datos de un conjunto válido cuyo resultado sea cero.

Comprueba tu resultado

0 registros produce pedir_datos; 3 registros y 1 anomalía produce revisar; 3 y 0 produce generar. Las tres rutas deben ser diferentes.

Bucle de estado, herramienta y resultado, con revisión humana antes de una acción de alto impacto.
CursaloMapa de práctica
Un agente necesita límites

Un agente mantiene un estado y utiliza herramientas dentro de límites definidos. El resultado de cada herramienta actualiza ese estado para decidir el siguiente paso. Las acciones de alto impacto deben pasar por una revisión humana antes de ejecutarse.

Ver la infografía en tamaño completo ↗

Tipo de lección: Video

Concepto clave

La lógica condicional en agentes de IA con LangGraph es el mecanismo que permite que tu agente tome decisiones dinámicas basadas en el contexto actual, su memoria y los resultados de herramientas externas. Piensa en ello como el cerebro ejecutivo de tu agente: no solo sigue un flujo lineal, sino que evalúa condiciones en tiempo real para determinar qué acción tomar a continuación.

En el mundo real, esto se asemeja a un gerente de proyecto experimentado. No sigue un checklist ciegamente; en cambio, revisa el progreso (memoria), consulta con expertos (herramientas) y decide si continuar con la siguiente tarea, repetir una fallida o cambiar de estrategia completamente. En LangGraph, esto se implementa mediante nodos condicionales que enrutan el grafo basándose en estados específicos, permitiendo bucles, bifurcaciones y decisiones complejas que simulan razonamiento humano.

Cómo funciona en la práctica

Imagina que estás construyendo un agente para automatizar reportes financieros. El flujo básico podría ser: 1) Recopilar datos, 2) Analizar tendencias, 3) Generar informe. Pero, ¿qué pasa si los datos están incompletos o el análisis detecta una anomalía? Aquí entra la lógica condicional.

Paso a paso, en código:

from langgraph.graph import StateGraph, END
from typing import TypedDict

class AgentState(TypedDict):
    task: str
    data: dict
    memory: list
    decision: str

def recopilar_datos(state):
    # Simula herramienta de recopilación
    if state['data'].get('completo'):
        return {'decision': 'analizar'}
    else:
        return {'decision': 'reintentar'}

def analizar_tendencias(state):
    # Lógica condicional basada en datos
    if state['data'].get('anomalia'):
        return {'decision': 'alertar'}
    return {'decision': 'generar_informe'}

# Construcción del grafo
graph = StateGraph(AgentState)
graph.add_node('recopilar', recopilar_datos)
graph.add_node('analizar', analizar_tendencias)
graph.add_conditional_edges('recopilar', lambda state: state['decision'], {
    'analizar': 'analizar',
    'reintentar': 'recopilar'
})
graph.add_edge('analizar', END)
app = graph.compile()

En este ejemplo, el agente decide entre analizar o reintentar basándose en la completitud de los datos, demostrando cómo la condición state['decision'] dirige el flujo.

Caso de estudio

Considera un agente de automatización de soporte técnico para una empresa de SaaS. Su tarea es procesar tickets de clientes, usando herramientas como una base de conocimiento, un sistema de tickets y un modelo de lenguaje para respuestas.

El grafo implementa lógica condicional para manejar escenarios complejos:

CondiciónAcciónHerramienta usada
Ticket es 'crítico'Derivar a ingeniero humanoSistema de tickets
Respuesta no está en memoriaBuscar en base de conocimientoBase de conocimiento API
Cliente requiere seguimientoProgramar recordatorioCalendario tool
Dato clave: En pruebas reales, este agente redujo el tiempo de respuesta en un 40% al evitar bucles infinitos y tomar decisiones basadas en prioridades condicionales.

El código clave usa una función condicional que evalúa el estado después de cada herramienta:

def decidir_siguiente_paso(state):
    if state['urgencia'] > 8:
        return 'derivar_humano'
    elif state['confianza_respuesta'] < 0.7:
        return 'buscar_knowledge_base'
    else:
        return 'responder_cliente'

Esto permite que el agente adapte su comportamiento dinámicamente, mejorando la eficiencia y precisión.

Errores comunes

  • Condiciones demasiado simples: Usar solo booleanos (True/False) limita la toma de decisiones. En su lugar, usa escalas o múltiples criterios (ej., confianza + urgencia) para enrutamiento más inteligente.
  • Olvidar actualizar la memoria: Las decisiones condicionales deben registrar su razonamiento en la memoria del estado. Sin esto, el agente puede repetir errores o perder contexto.
  • Bucles infinitos por mala condición: Si una condición siempre devuelve el mismo nodo, el grafo entra en loop. Siempre incluye un caso base o límite de iteraciones.
  • No probar casos extremos: Solo probar el flujo feliz lleva a fallos en producción. Valida condiciones con datos inesperados o nulos.
  • Ignorar el costo computacional: Evaluar condiciones complejas en cada nodo puede ralentizar el agente. Optimiza con caché o condiciones simplificadas cuando sea posible.

Checklist de dominio

  1. ¿Puedes diseñar un grafo con al menos tres bifurcaciones condicionales basadas en datos de estado?
  2. ¿Sabes integrar herramientas externas cuyos resultados afecten las condiciones de enrutamiento?
  3. ¿Implementas memoria que persista entre decisiones condicionales para contexto acumulativo?
  4. ¿Evalúas condiciones no solo binarias, sino con umbrales o lógica fuzzy (ej., confianza > 0.8)?
  5. ¿Probaste tu lógica con al menos cinco escenarios diferentes, incluyendo casos de error?
  6. ¿Documentaste las reglas de decisión para mantenimiento y depuración futura?
  7. ¿Optimizaste el rendimiento evitando condiciones redundantes o costosas en nodos críticos?

Construye un agente condicional para gestión de proyectos

Desarrolla un agente con LangGraph que automatice la revisión de tareas en un proyecto, usando lógica condicional para decidir acciones basadas en el estado. Sigue estos pasos:

  1. Define un estado con campos: tareas (lista de dicts con 'nombre', 'completada', 'bloqueante'), progreso (porcentaje), y alertas (lista).
  2. Crea tres nodos: evaluar_tareas (revisa tareas completadas), notificar_bloqueos (envía alertas si hay tareas bloqueantes), y calcular_progreso (actualiza el porcentaje).
  3. Implementa una función condicional que, después de evaluar_tareas, decida el siguiente paso:
    • Si hay tareas bloqueantes, ir a notificar_bloqueos.
    • Si el progreso es menor al 50%, repetir evaluar_tareas para revisar.
    • En otro caso, ir a calcular_progreso y terminar.
  4. Integra una herramienta simulada (ej., función que devuelve datos de tareas desde una API falsa) y usa su resultado en la condición.
  5. Ejecuta el grafo con un estado inicial de ejemplo y valida que las decisiones condicionales funcionen correctamente.

Entrega el código completo y una explicación de cómo la lógica condicional mejora la automatización.

Pistas
  • Usa langgraph.graph.StateGraph para definir el grafo y add_conditional_edges para las bifurcaciones.
  • Asegúrate de que tu función condicional acceda al estado actualizado después de cada nodo.
  • Simula la herramienta con un retraso o datos variables para probar condiciones en tiempo real.

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con LangGraph para Automatización: Memoria, Estado y Decisiones

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.