Patrones de Diseño
Flujo de TrabajoIntermedio

Prompt Chaining

Divide tareas complejas en una secuencia de prompts más simples donde la salida de cada paso alimenta al siguiente, mejorando la fiabilidad y la capacidad de depuración.

Resumen

El Prompt Chaining descompone una tarea compleja de IA en una serie de prompts más pequeños y enfocados. Cada prompt en la cadena toma la salida del anterior como entrada, creando un pipeline que es más fácil de depurar, probar e iterar que un único prompt monolítico.

Este patrón es fundamental para construir flujos de trabajo asistidos por IA fiables. En lugar de pedirle a un LLM que lo haga todo a la vez —donde un fallo en cualquier parte corrompe toda la salida— se aísla cada preocupación en su propio paso.

Problema

Los prompts grandes y complejos que intentan lograr múltiples objetivos simultáneamente sufren de varios problemas:

  • Resultados poco fiables — el modelo puede sobresalir en una subtarea pero fallar en otra, y se obtiene un resultado de calidad mixta
  • Depuración difícil — cuando el resultado es incorrecto, es difícil identificar qué parte del razonamiento se desvió
  • Sin reutilización parcial — no se pueden reutilizar las partes buenas de una generación fallida
  • Sobrecarga de contexto — amontonar demasiadas instrucciones en un solo prompt degrada el rendimiento de cada instrucción individual

Solución

Divida la tarea en pasos discretos, cada uno con su propio prompt. Pase la salida de un paso como contexto al siguiente. Esto le proporciona:

  • Responsabilidad clara por paso
  • Capacidad para inspeccionar y validar resultados intermedios
  • Intercambio sencillo de pasos individuales (diferentes modelos, temperaturas o incluso lógica ajena a la IA)
  • Puntos de control naturales para la revisión humana

Una cadena típica podría verse así: Analizar → Planificar → Ejecutar → Revisar.

Implementación

1

2

3

4

5

Ejemplos de Código

Basic Chain in TypeScript
async function promptChain(topic: string) {
  // Step 1: Research
  const research = await llm.generate({
    prompt: `List 5 key points about "${topic}". Output as a JSON array of strings.`,
    temperature: 0.3,
  });

  // Step 2: Outline
  const outline = await llm.generate({
    prompt: `Given these key points:\n${research}\n\nCreate a blog post outline with sections and sub-points. Output as markdown.`,
    temperature: 0.5,
  });

  // Step 3: Write
  const draft = await llm.generate({
    prompt: `Write a blog post following this outline:\n${outline}\n\nWrite in a professional but accessible tone. 800-1200 words.`,
    temperature: 0.7,
  });

  return draft;
}
Chain with Validation
import { z } from 'zod';

const ResearchSchema = z.array(z.string()).min(3).max(10);

async function validatedChain(topic: string) {
  // Step 1 with validation
  const rawResearch = await llm.generate({
    prompt: `List 5 key points about "${topic}". Output as a JSON array.`,
  });

  const research = ResearchSchema.parse(JSON.parse(rawResearch));

  // Only proceed if research is valid
  const outline = await llm.generate({
    prompt: `Create an outline from these points:\n${JSON.stringify(research)}`,
  });

  return outline;
}

Consideraciones

Beneficios
  • • **Debuggability** — inspect each intermediate output to find where things go wrong
  • • **Reliability** — each step is simpler and more likely to succeed
  • • **Reusability** — individual steps can be reused across different workflows
  • • **Testability** — each step can be unit tested independently with fixed inputs
  • • **Flexibility** — swap models, adjust temperatures, or insert non-AI logic at any step
Desafíos
  • • **Latency** — multiple sequential API calls are slower than a single call
  • • **Error propagation** — a bad output from an early step corrupts the entire chain
  • • **Cost** — more API calls means higher token usage and cost; tracking the [[token-budget]] across chain steps is essential
  • • **Complexity** — managing the chain infrastructure requires additional code
  • • **Context loss** — later steps may lack context that was available in earlier steps unless explicitly passed