Padrões de Design
Fluxo de TrabalhoIntermediário

Encadeamento de Prompts

Divida tarefas complexas em uma sequência de prompts mais simples, onde a saída de cada etapa alimenta a próxima, melhorando a confiabilidade e a facilidade de depuração.

Visão Geral

O encadeamento de prompts decompõe uma tarefa complexa de IA em uma série de prompts menores e focados. Cada prompt na cadeia utiliza a saída do anterior como entrada, criando um pipeline que é mais fácil de depurar, testar e iterar do que um único prompt monolítico.

Este padrão é fundamental para construir fluxos de trabalho assistidos por IA confiáveis. Em vez de pedir que um LLM faça tudo de uma vez — onde uma falha em qualquer parte corrompe todo o resultado — você isola cada preocupação em sua própria etapa.

Problema

Prompts grandes e complexos que tentam realizar múltiplos objetivos simultaneamente sofrem de vários problemas:

  • Saídas não confiáveis — o modelo pode se destacar em uma sub-tarefa, mas falhar em outra, resultando em um resultado de qualidade mista
  • Depuração difícil — quando a saída está incorreta, é difícil identificar qual parte do raciocínio saiu do trilho
  • Sem reutilização parcial — você não pode reutilizar as partes boas de uma geração que falhou
  • Sobrecarga de contexto — amontoar instruções demais em um único prompt degrada o desempenho em cada instrução individual

Solução

Divida a tarefa em etapas discretas, cada uma com seu próprio prompt. Passe a saída de uma etapa como contexto para a próxima. Isso proporciona:

  • Responsabilidade clara por etapa
  • Capacidade de inspecionar e validar saídas intermediárias
  • Substituição fácil de etapas individuais (diferentes modelos, temperaturas ou até mesmo lógica não baseada em IA)
  • Pontos de verificação naturais para revisão humana

Uma cadeia típica pode ser: Analisar → Planejar → Executar → Revisar.

Implementação

1

2

3

4

5

Exemplos 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;
}

Considerações

Benefícios
  • • **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
Desafios
  • • **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