AI Workflow (flujo de trabajo de IA)

AI Workflow (flujo de trabajo de IA) es un sistema que combina de forma ordenada múltiples llamadas a modelos de IA, uso de herramientas y pasos de procesamiento de datos en una línea de producción automatizada.

Una sola llamada a un LLM puede responder preguntas, pero las tareas reales suelen requerir: buscar en la web → extraer información → analizar → escribir un informe → enviar un correo. AI Workflow conecta estos pasos para que la IA complete automáticamente la tarea completa, no solo responda una frase.

Una analogía intuitiva

Imagina una línea de ensamblaje:

Patrón	Analogía	Descripción
Llamada única a LLM	Como un artesano	Le das un trozo de hierro y te devuelve una espada
AI Workflow	Como una línea de producción completa	Entra la materia prima y pasa automáticamente por fundición → forja → temple → pulido → embalaje, y sale el producto terminado

Cada paso puede ser un modelo de IA, una función de código, una API externa o un nodo de revisión humana.

De responder preguntas a realizar tareas: la evolución

¿Por qué se necesita AI Workflow?

Limitaciones de una sola llamada

Una sola llamada a un LLM puede hacer muy poco:

Ventana de contexto limitada: no puede leer un libro completo de una vez
No puede acceder a información en tiempo real: los datos de entrenamiento tienen una fecha límite
No puede ejecutar acciones: no puede enviar correos, escribir código y ejecutarlo de verdad
No puede verificarse a sí mismo: no puede darse cuenta de un error generado y corregirlo
Las tareas complejas son propensas a errores: hacer demasiado en un solo paso reduce la calidad

Los cinco problemas clave que resuelve AI Workflow

Componentes principales

Un AI Workflow completo se compone de los siguientes elementos principales.

Explicación detallada de cada elemento

LLM (grandes modelos de lenguaje)- Es el “cerebro” del Workflow, responsable del razonamiento, la generación y la toma de decisiones. Comunes: GPT-4o, Claude 3.5, Gemini 1.5, Llama 3 local.

Herramientas (Tools)- Interfaces que permiten a la IA interactuar con el mundo exterior, incluyendo: motores de búsqueda (Tavily, Serper, Bing), ejecutores de código (Python REPL, entornos sandbox), consultas a bases de datos (SQL, bases vectoriales), API externas (clima, acciones, correo, calendario), operaciones con archivos (leer/escribir, parsear PDF/Excel).

Memoria (Memory)- La memoria a corto plazo almacena el historial de la conversación actual (en el prompt); la memoria a largo plazo logra persistencia entre sesiones mediante base de datos vectorial + RAG; la memoria de trabajo mantiene el estado intermedio durante la ejecución de la tarea.

Estado (State)- Portador de información que se transmite entre los pasos de una tarea, como un testigo de relevos: cada paso puede leer el resultado anterior y escribir un nuevo resultado.

Enrutador / Condición (Router)- Decide dinámicamente el siguiente paso según la salida del paso anterior, implementando control de flujo complejo como ramificaciones, bucles y saltos.

Intervención humana (Human in the Loop)- Se pausa en puntos críticos para esperar confirmación humana; apto para operaciones de alto riesgo (como eliminar datos, enviar correos, operaciones financieras).

Seis patrones comunes de Workflow

A continuación se presentan los seis patrones de diseño más utilizados en AI Workflow, de simples a complejos, adecuados para diferentes escenarios.

Patrón 1: Cadena secuencial (Sequential Chain)

El patrón más básico: los pasos A → B → C se ejecutan linealmente; la salida de un paso es la entrada del siguiente.

Dimensión	Descripción
Escenarios aplicables	Procesamiento de documentos en pipeline, generación de contenido, transformación de datos
Ventajas	Simple, predecible
Desventajas	Rígido, no se puede ajustar dinámicamente según el contenido

Patrón 2: Enrutamiento condicional (Conditional Routing)

Selecciona dinámicamente diferentes rutas posteriores según el contenido de salida de un paso.

Dimensión	Descripción
Escenarios aplicables	Atención al cliente inteligente, asistentes multifunción, clasificación y procesamiento de preguntas
Ventajas	Flexible, alta utilización de recursos
Desventajas	La lógica de enrutamiento requiere diseño cuidadoso; un error de clasificación afecta a todo el flujo

Patrón 3: Ejecución paralela (Parallel Execution)

Varias subtareas se ejecutan simultáneamente y los resultados se consolidan al final.

Dimensión	Descripción
Escenarios aplicables	Análisis multidimensional, procesamiento por lotes, subtareas independientes
Ventajas	Gran mejora de velocidad
Desventajas	Requiere manejar control de concurrencia y lógica de combinación de resultados

Patrón 4: Bucle ReAct (Reason + Act)

La IA primero razona para decidir qué hacer, luego actúa llamando herramientas, continúa razonando según los resultados y repite el ciclo hasta completar la tarea. Es el patrón central de AI Agent.

Dimensión	Descripción
Escenarios aplicables	AI Agent, ejecución de tareas complejas, resolución de problemas abiertos
Ventajas	Dinámico y flexible, puede manejar situaciones desconocidas
Desventajas	El número de iteraciones no es controlable; se debe establecer un número máximo de pasos para evitar bucles infinitos

Patrón 5: Plan & Execute (planificar y luego ejecutar)

Primero se pide al LLM que elabore un plan completo y luego se ejecuta paso a paso según el plan. La diferencia con ReAct es "pensar primero, actuar después".

Patrón 6: Colaboración multiagente (Multi-Agent)

Varios Agentes especializados cooperan con división del trabajo; cada Agente tiene su propio rol y conjunto de herramientas.

Dimensión	Descripción
Escenarios aplicables	Desarrollo de software complejo, asistencia en investigación, automatización empresarial
Ventajas	Especialización dedicada, mayor calidad, fácil de escalar
Desventajas	Alta complejidad del sistema; la comunicación entre Agentes requiere diseño cuidadoso

Comparación de frameworks y herramientas principales

A continuación se muestra una comparación panorámica de los frameworks de AI Workflow más populares, para ayudarte a elegir según tu situación.

Árbol de decisión para la selección de framework

Según tu situación específica, elige el framework adecuado siguiendo el siguiente árbol de decisión:

你的情况是什么？
│
├─── 没有编程基础，想用可视化工具搭建
│    ├─── 主要是 AI 应用（问答、生成）→ Dify（首选）
│    └─── 需要连接 Slack/邮件等 SaaS 系统 → n8n
│
├─── 有 Python 基础，代码优先
│    ├─── 做知识库 / RAG 系统 → LlamaIndex
│    ├─── 做多 Agent 协作，想快速上手 → CrewAI
│    ├─── 需要复杂有状态流程控制 → LangGraph
│    └─── 通用场景，想要最大生态 → LangChain
│
└─── 已有明确场景，生产级要求
     ├─── 高并发、精细控制 → LangGraph + LangSmith
     └─── 企业部署、私有化 → Dify 自托管

Inicio rápido: ejemplos de código Python

Los siguientes ejemplos, desde la cadena secuencial más simple hasta la colaboración multi-agente compleja, demuestran paso a paso cómo implementar Workflows de IA.

Cadena secuencial con LangChain

El patrón de Workflow más básico, que utiliza el operador de tubería | para encadenar varios pasos de llamadas a LLM.

Instala los paquetes de dependencias:

pip install langchain langchain-openai

Ejemplo

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o-mini", api_key="your-api-key")

# ─── Definir tres pasos ────────────────────────────────────────────
# Paso 1: Traducir el artículo al chino
translate_prompt = ChatPromptTemplate.from_template(
"Traduce el siguiente artículo en inglés al chino, manteniendo el significado original:\n\n{article}"
)

# Paso 2: Extraer el resumen
summarize_prompt = ChatPromptTemplate.from_template(
"Extrae 3 puntos clave del siguiente artículo, cada punto en una frase:\n\n{translated}"
)

# Paso 3: Generar el título
title_prompt = ChatPromptTemplate.from_template(
"Basándote en el siguiente resumen, genera un título atractivo en chino (dentro de 15 caracteres):\n\n{summary}"
)

parser = StrOutputParser()

# ─── Encadenar con el operador | como una tubería ─────────────────────────────────
chain = (
{"translated": translate_prompt | llm | parser}
| {"summary": summarize_prompt | llm | parser,
"translated": lambda x: x["translated"]}
| title_prompt | llm | parser
)

# ─── Ejecutar ────────────────────────────────────────────────────
article = """
Artificial intelligence is transforming how we work and live.
From automating repetitive tasks to assisting in creative work,
AI tools are becoming indispensable in modern workflows...
"""

result = chain.invoke({"article": article})
print(result)

AI 正在重塑现代工作流：从自动化到创意辅助

Agente con llamada a herramientas (modo ReAct)

ReAct es el patrón central de los agentes de IA, que hace que la IA alterne entre pensamiento y acción hasta completar la tarea.

Ejemplo

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_react_agent
from langchain_core.tools import tool
from langchain import hub
import requests, datetime

# ─── Definir herramientas ────────────────────────────────────────────────
@tool
def get_weather(city: str) -> str:
"""Obtiene la información meteorológica actual de la ciudad especificada"""
# En un proyecto real, reemplazar por una API meteorológica real
mock_data = {
"Pekín": "Despejado, 22°C, brisa suave",
"Shanghái": "Nublado, 26°C, humedad 75%",
"Guangzhou": "Lluvia ligera, 30°C, se recomienda llevar paraguas",
}
return mock_data.get(city, f"No hay datos meteorológicos disponibles para {city}")

@tool
def search_web(query: str) -> str:
"""Busca información en la web y devuelve un resumen del contenido relacionado"""
# En un proyecto real, integra la API de Tavily / Serper
return f"Resultado de la búsqueda de '{query}': este es un resultado de búsqueda simulado..."

@tool
def calculate(expression: str) -> str:
"""Calcula expresiones matemáticas, por ejemplo '2 + 3 * 4'"""
try:
result = eval(expression, {"__builtins__": {}}, {})
return str(result)
except Exception as e:
return f"Error de cálculo: {e}"

@tool
def get_date() -> str:
"""Obtiene la fecha de hoy"""
return datetime.date.today().strftime(%d/%m/%Y)

# ─── Crear el agente ───────────────────────────────────────────────
tools = [get_weather, search_web, calculate, get_date]
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# Usar el prompt estándar de ReAct de LangChain Hub
prompt = hub.pull("hwchase17/react")

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True, # Imprimir el proceso de pensamiento de cada paso, para facilitar la depuración
max_iterations=8, # Evitar bucles infinitos
handle_parsing_errors=True
)

# ─── Ejecutar ────────────────────────────────────────────────────
result = agent_executor.invoke({
"input": "¿Qué día es hoy? ¿Cómo está el tiempo en Pekín? Si caminas 5 km quemas unas 300 calorías,"
"correr la misma distancia quema aproximadamente 1.6 veces más que caminar, calcula las calorías quemadas al correr."
})

print(result["output"])
# El agente decidirá automáticamente: primero llama a get_date → get_weather("Pekín") → calculate("300*1.6")
# Finalmente combina toda la información y da una respuesta completa

Workflow con estado en LangGraph

LangGraph define procesos complejos mediante grafos, cada nodo es una función y las aristas definen la lógica de salto.

Ejemplo

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, Annotated
import operator

# ─── Definir la estructura de estado (datos transmitidos entre nodos) ────────────────────────
class ResearchState(TypedDict):
topic: str # Tema de investigación
research_notes: str # Notas de investigación
draft: str # Borrador
review_feedback: str # Comentarios de revisión
final_report: str # Informe final
revision_count: Annotated[int, operator.add] # Número de revisiones (acumulativo)

llm = ChatOpenAI(model="gpt-4o")

# ─── Definir funciones de nodo ─────────────────────────────────────────────
def research_node(state: ResearchState) -> dict:
"""Nodo 1: fase de investigación"""
response = llm.invoke(
f"Investiga brevemente el siguiente tema y enumera 5 puntos clave: {state['topic']}"
)
return {"research_notes": response.content}

def write_node(state: ResearchState) -> dict:
"""Nodo 2: redactar el borrador"""
prompt = f"""
Tema: {state['topic']}
Notas de investigación: {state['research_notes']}
{'Comentarios de la revisión anterior: ' + state.get('review_feedback', '') if state.get('review_feedback') else ''}

Redacta un borrador de informe de análisis de 300 palabras según el contenido anterior.
"""
response = llm.invoke(prompt)
return {"draft": response.content, "revision_count": 1}

def review_node(state: ResearchState) -> dict:
"""Nodo 3: revisar el borrador"""
response = llm.invoke(
f"Revisa el siguiente informe. Si la calidad es suficiente, responde 'APPROVED'; de lo contrario, da sugerencias específicas de modificación:\n\n{state['draft']}"
)
return {"review_feedback": response.content}

def finalize_node(state: ResearchState) -> dict:
"""Nodo 4: versión final"""
return {"final_report": state["draft"]}

# ─── Función de enrutamiento: decide qué camino seguir después de la revisión ─────────────────────────────
def should_revise(state: ResearchState) -> str:
if "APPROVED" in state["review_feedback"]:
return "finalize" # → Versión final
elif state["revision_count"] >= 3:
return "finalize" # → Si se exceden 3 revisiones, forzar la finalización
else:
return "revise" # → Volver al nodo de redacción para modificar

# ─── Construir el grafo del flujo de trabajo ─────────────────────────────────────────────
workflow = StateGraph(ResearchState)

# Añadir nodos
workflow.add_node("research", research_node)
workflow.add_node("write", write_node)
workflow.add_node("review", review_node)
workflow.add_node("finalize", finalize_node)

# Establecer el punto de entrada
workflow.set_entry_point("research")

# Añadir aristas (definir la lógica de transición)
workflow.add_edge("research", "write") # Investigación → Redacción
workflow.add_edge("write", "review") # Redacción → Revisión

# Arista condicional: tras la revisión, elegir la ruta según el resultado
workflow.add_conditional_edges(
"review",
should_revise,
{
"revise": "write", # Necesita modificación → Volver a redacción
"finalize": "finalize" # Aprobado → Versión final
}
)

workflow.add_edge("finalize", END)

# Compilar y ejecutar
app = workflow.compile()

result = app.invoke({"topic": "El impacto de la IA generativa en la industria del desarrollo de software", "revision_count": 0})
print(result["final_report"])

Colaboración multiagente con CrewAI

CrewAI define roles y tareas para que múltiples agentes colaboren como un equipo.

Ejemplo

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

# ─── Definir agentes (roles) ────────────────────────────────────────
researcher = Agent(
role=Investigador de mercado,
goal=Recopilar y organizar información de mercado completa y precisa sobre el tema objetivo,
backstory=Eres un analista de mercado experimentado, experto en extraer conocimientos clave de grandes volúmenes de información,
llm=llm,
verbose=True
)

analyst = Agent(
role=Analista de datos,
goal=Basándote en la información proporcionada por el investigador, realiza un análisis profundo y llega a conclusiones valiosas,
backstory=Eres experto en hablar con datos y puedes descubrir tendencias y oportunidades ocultas detrás de la información,
llm=llm,
verbose=True
)

writer = Agent(
role=Experto en redacción de informes,
goal=Redacta las conclusiones del análisis en un informe claro, profesional y convincente,
backstory=Tienes amplia experiencia en redacción empresarial y puedes hacer que análisis complejos sean fáciles de entender,
llm=llm,
verbose=True
)

# ─── Definir Task (Tarea) ────────────────────────────────────────
research_task = Task(
description=Investigar el estado actual del mercado de vehículos de nueva energía en China, incluidas las principales marcas, cuota de mercado y tendencias de crecimiento,
expected_output=Un informe de investigación de mercado que incluya 5 puntos de datos clave, con cifras y hechos concretos,
agent=researcher
)

analysis_task = Task(
description=Basándote en el informe de investigación, analiza las oportunidades y riesgos para los próximos 3 años y ofrece recomendaciones de calificación de inversión,
expected_output=Tabla de análisis SWOT + Calificación de inversión (Recomendación fuerte / Recomendación / Neutral / Prudente) + Razones,
agent=analyst,
context=[research_task] # Depende de la salida de la tarea de investigación
)

writing_task = Task(
description=Integra la investigación y el análisis en un informe profesional de inversión de 500 palabras, con formato claro,
expected_output=Un informe que incluya cuatro secciones: resumen ejecutivo, situación actual del mercado, oportunidades y riesgos, y recomendaciones de inversión,
agent=writer,
context=[research_task, analysis_task]
)

# ─── Formar el equipo y ejecutar ───────────────────────────────────────────
crew = Crew(
agents=[researcher, analyst, writer],
tasks=[research_task, analysis_task, writing_task],
process=Process.sequential, # Ejecución secuencial (también se puede cambiar a hierarchical)
verbose=True
)

result = crew.kickoff()
print(result)

Human-in-the-Loop (nodo de revisión humana)

LangGraph permite pausar en pasos clave, esperar la confirmación humana y luego continuar la ejecución.

Ejemplo

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from typing import TypedDict

class EmailState(TypedDict):
recipient: str
content: str
approved: bool

def draft_email(state: EmailState) -> dict:
"""Redactar borrador de correo"""
content = fEstimado {state['recipient']},\n\nEste es el contenido del correo redactado por IA...\n\nAtentamente,
return {"content": content}

def send_email(state: EmailState) -> dict:
"""Enviar correo (operación de alto riesgo, requiere revisión humana antes de ejecutarse)"""
print(fCorreo enviado a {state['recipient']})
return {}

# Ruta: decidir si enviar según el resultado de la revisión humana
def check_approval(state: EmailState) -> str:
return "send" if state.get("approved") else END

workflow = StateGraph(EmailState)
workflow.add_node("draft", draft_email)
workflow.add_node("send", send_email)
workflow.set_entry_point("draft")

# Después de completar el borrador, pausar y esperar la revisión humana (interrupt_after)
workflow.add_conditional_edges("draft", check_approval, {"send": "send", END: END})
workflow.add_edge("send", END)

# Usar MemorySaver para soportar interrupción y reanudación
memory = MemorySaver()
app = workflow.compile(
checkpointer=memory,
interrupt_after=["draft"] # Pausar después del nodo draft
)

config = {"configurable": {"thread_id": "email-001"}}

# Primera ejecución: pausa después de llegar a draft
state = app.invoke({"recipient": Cliente A, "approved": False}, config)
print(Borrador generado, en espera de revisión:)
print(state["content"])

# Después de la revisión humana, actualizar el estado y continuar la ejecución
user_input = input("\n¿Aprobar envío? (y/n):)
if user_input.lower() == "y":
app.update_state(config, {"approved": True})
app.invoke(None, config) # Continuar desde el punto de interrupción
print(Correo enviado)
else:
print(Envío cancelado)

Ingeniería de prompts: técnicas clave en Workflow

En el AI Workflow, la calidad del prompt afecta directamente la calidad de salida de cada nodo.

Ejemplo

# Definición de rol ambigua
# system_prompt = "Eres un asistente de IA, ayúdame a analizar este documento"

# Definición de rol clara (recomendado)
system_prompt = """
Eres un analista financiero profesional, especializado en identificar señales de riesgo en informes financieros.
Tu tarea: extraer del siguiente informe todos los puntos de datos clave relacionados con pasivos, flujo de caja y rentabilidad.
Formato de salida: JSON, que incluya risk_level (high/medium/low) y key_findings (lista).
Nota: genera solo JSON, no agregues ningún texto explicativo.
"""

Ejemplo

# Transmitir texto no estructurado
# state["previous_output"] = "Resultado del análisis: esta empresa parece buena, tiene algunos riesgos..."

# Transmitir datos estructurados (recomendado)
state["analysis_result"] = {
"risk_level": "medium",
"key_findings": [Tasa de endeudamiento 45%, promedio de la industria 38%, Flujo de caja positivo, disminución intertrimestral del 12% en Q3],
"recommendation": Mantener con prudencia
}

Ejemplo

# Exigir salida JSON en el prompt
prompt = """
Analiza la polaridad de sentimiento del siguiente texto.
Genera la salida estrictamente en el siguiente formato JSON, no agregues ningún otro contenido:
{
"sentiment": "positive" | "negative" | "neutral",
"confidence": 0.0-1.0,
"reason": "explicación breve"
}

Texto: {text}
"""

Manejo de errores y reintentos

Ejemplo

from tenacity import retry, stop_after_attempt, wait_exponential
import logging

@retry(
stop=stop_after_attempt(3), # Reintentar como máximo 3 veces
wait=wait_exponential(multiplier=1, min=2, max=10) # Espera con retroceso exponencial
)
def call_llm_with_retry(prompt: str) -> str:
try:
response = llm.invoke(prompt)
return response.content
except Exception as e:
logging.error(fError en la llamada LLM: {e})
raise

def safe_parse_json(text: str) -> dict:
"""Analizar de forma segura el JSON de salida del LLM"""
import json, re
# Extraer la parte JSON (a veces el LLM agrega texto explicativo adicional)
json_match = re.search(r'\{.*\}', text, re.DOTALL)
if json_match:
try:
return json.loads(json_match.group())
except json.JSONDecodeError:
pass
return {"error": Error de análisis, "raw": text}

Control de costos

Ejemplo

# ─── Seleccionar modelo según la importancia de la tarea ────────────────────────────────
def get_llm(task_type: str):
if task_type == "classification": # Tareas de clasificación, un modelo ligero es suficiente
return ChatOpenAI(model="gpt-4o-mini")
elif task_type == "generation": # Tareas de generación, utilizar un modelo mediano
return ChatOpenAI(model="gpt-4o-mini")
elif task_type == "reasoning": # Razonamiento complejo, utilizar un modelo potente
return ChatOpenAI(model="gpt-4o")

# ─── Almacenar en caché solicitudes repetidas ──────────────────────────────────────────
from langchain.globals import set_llm_cache
from langchain_community.cache import InMemoryCache
set_llm_cache(InMemoryCache()) # Para la misma entrada, devolver directamente la caché sin facturar nuevamente

# ─── Dividir el texto para evitar que sea demasiado largo ──────────────────────────────────────
from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
chunk_size=2000, # 2000 caracteres por bloque
chunk_overlap=200 # Superposición de 200 caracteres para garantizar la coherencia contextual
)
chunks = splitter.split_text(long_document)

Escenarios de aplicación típicos

AI Workflow ya se ha implementado ampliamente en múltiples campos; a continuación se presentan los seis escenarios más representativos.

Mejores prácticas y errores comunes

Errores comunes y soluciones

A continuación se presentan los problemas que los principiantes encuentran con mayor facilidad al usar AI Workflow.

Trampa	Fenómeno	Solución
Cascada de alucinaciones	El error en la salida de la IA del paso anterior se transmite al siguiente paso como un hecho, amplificando el error.	Agregar pasos de verificación en nodos clave; obtener información numérica mediante herramientas.
Bucle infinito	El agente ReAct llama a las herramientas repetidamente sin saber cuándo detenerse.	Configurar max_iterations; dar al LLM condiciones de terminación claras.
Explosión de contexto	A medida que aumentan los pasos, el texto enviado al LLM se vuelve cada vez más largo y excede la ventana.	Transmitir solo los campos necesarios en cada paso; comprimir el historial con resúmenes.
Abuso de herramientas	El agente podría responder directamente, pero llama a herramientas repetidamente	Optimizar las descripciones de las herramientas; indicar claramente al LLM cuándo no se necesitan herramientas
Error al analizar JSON	El formato de salida del LLM es inestable y el programa se bloquea	Añadir safe_parse_json; usar LangChain OutputParser
Sobrecosto	No se estimó el consumo de tokens y la factura de fin de mes supera lo esperado	Probar primero con gpt-4o-mini; usar LangSmith para monitorear el uso
Conflictos de concurrencia	Varios agentes escriben en el mismo estado al mismo tiempo y causan corrupción de datos	Usar la gestión de estado integrada de LangGraph; evitar estados mutables compartidos

Resumen y ruta de aprendizaje

Repaso de los puntos clave

Ruta de aprendizaje recomendada

Primera fase: comprender los fundamentos (1 semana)

Comprender las llamadas a la API de LLM y poder enviar solicitudes con el SDK de OpenAI
Ejecutar el ejemplo de cadena secuencial de LangChain de este artículo
Comprender los principios básicos de Prompt Engineering

Segunda fase: herramientas y agentes (2 semanas)

Aprender a definir herramientas con el decorador @tool
Ejecutar el ejemplo de agente ReAct y observar los registros verbose para entender la lógica del bucle
Usar Dify o n8n para crear un prototipo visual de Workflow

Tercera fase: Workflows complejos (3 semanas)

Aprender los grafos de estado de LangGraph e implementar flujos de trabajo con ramas condicionales
Usar CrewAI para implementar una tarea de colaboración entre dos agentes
Integrar herramientas reales (búsqueda de Tavily, Python REPL)
Usar LangSmith para observar y depurar tu Workflow

Cuarta fase: listo para producción (continuo)

Implementar reintentos de errores y análisis de salida estructurada
Monitoreo y optimización de costos (uso de modelos por niveles)
Desplegar en producción y configurar alertas de monitoreo

Recursos de referencia

Otras extensiones

Herramientas de agentes

Implementación de agentes inteligentes en Python

AI Workflow (flujo de trabajo de IA)

Una analogía intuitiva

De responder preguntas a realizar tareas: la evolución

¿Por qué se necesita AI Workflow?

Limitaciones de una sola llamada

Los cinco problemas clave que resuelve AI Workflow

Componentes principales

Explicación detallada de cada elemento

Seis patrones comunes de Workflow

Patrón 1: Cadena secuencial (Sequential Chain)

Patrón 2: Enrutamiento condicional (Conditional Routing)

Patrón 3: Ejecución paralela (Parallel Execution)

Patrón 4: Bucle ReAct (Reason + Act)

Patrón 5: Plan & Execute (planificar y luego ejecutar)

Patrón 6: Colaboración multiagente (Multi-Agent)

Comparación de frameworks y herramientas principales

Árbol de decisión para la selección de framework

Inicio rápido: ejemplos de código Python

Cadena secuencial con LangChain

Ejemplo

Agente con llamada a herramientas (modo ReAct)

Ejemplo

Workflow con estado en LangGraph

Ejemplo

Colaboración multiagente con CrewAI

Ejemplo

Human-in-the-Loop (nodo de revisión humana)

Ejemplo

Ingeniería de prompts: técnicas clave en Workflow

Ejemplo

Ejemplo

Ejemplo

Manejo de errores y reintentos

Ejemplo

Control de costos

Ejemplo

Escenarios de aplicación típicos

Mejores prácticas y errores comunes

Errores comunes y soluciones

Resumen y ruta de aprendizaje

Repaso de los puntos clave

Ruta de aprendizaje recomendada

Recursos de referencia