Como encadear chamadas do Claude para construir pipelines de raciocínio em múltiplas etapas

import anthropic

client = anthropic.Anthropic()

# Etapa 1: Analisar o problema
analysis = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": f"Analise esta reclamação de cliente e identifique a causa raiz:\n\n{complaint}"
        }
    ]
)

analysis_text = analysis.content[0].text

# Etapa 2: Gerar uma solução baseada na análise
solution = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": f"Com base nesta análise:\n\n{analysis_text}\n\nGere uma resposta ao cliente que aborde a causa raiz."
        }
    ]
)

solution_text = solution.content[0].text

# Etapa 3: Revisar tom e precisão
final = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": f"Revise esta resposta quanto ao tom profissional e precisão:\n\n{solution_text}\n\nFaça as melhorias necessárias."
        }
    ]
)

print(final.content[0].text)

Este encadeamento de três etapas deixa o Claude focar em um trabalho por chamada. Cada etapa é mais limpa, rápida e confiável do que pedir para ele fazer todos os três de uma vez.

## Lógica de roteamento: tornando as cadeias inteligentes

Cadeias reais precisam de pontos de decisão. Nem todo problema segue o mesmo caminho.

```python
def classify_issue(complaint):
    """Determina o tipo de problema para rotear para o handler apropriado"""
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=100,
        messages=[
            {
                "role": "user",
                "content": f"Classifique este problema como FATURAMENTO, TÉCNICO, ou ATENDIMENTO:\n\n{complaint}"
            }
        ]
    )
    return response.content[0].text.strip().upper()

def handle_billing_issue(complaint, analysis):
    """Handler especializado para problemas de faturamento"""
    return client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Você é um especialista em faturamento. Trate isto:\n\n{analysis}"
            }
        ]
    )

def handle_technical_issue(complaint, analysis):
    """Handler especializado para problemas técnicos"""
    return client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Você é um especialista em suporte técnico. Resolva isto:\n\n{analysis}"
            }
        ]
    )

# Cadeia principal com roteamento
issue_type = classify_issue(complaint)
analysis = analyze_complaint(complaint)

if issue_type == "FATURAMENTO":
    solution = handle_billing_issue(complaint, analysis)
elif issue_type == "TÉCNICO":
    solution = handle_technical_issue(complaint, analysis)
else:
    solution = handle_service_issue(complaint, analysis)
```

Agora sua cadeia se adapta. A primeira chamada determina qual deve ser a segunda chamada. Isso é mais próximo do raciocínio real—decisões informam o próximo passo.

## Exemplo prático: Pipeline de geração de conteúdo

Vamos construir algo real. Um pipeline de qualidade de conteúdo que gera, refina e valida artigos:

```python
def generate_outline(topic, audience):
    """Etapa 1: Criar estrutura"""
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Crie um esboço detalhado para um artigo sobre {topic} para {audience}."
            }
        ]
    )
    return response.content[0].text

def write_sections(outline, topic):
    """Etapa 2: Expandir esboço em seções completas"""
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2048,
        messages=[
            {
                "role": "user",
                "content": f"Escreva seções completas para este esboço sobre {topic}:\n\n{outline}"
            }
        ]
    )
    return response.content[0].text

def check_depth(content, topic):
    """Etapa 3: Identificar profundidade faltante"""
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=512,
        messages=[
            {
                "role": "user",
                "content": f"Quais subtópicos-chave de {topic} estão faltando ou insuficientemente desenvolvidos neste conteúdo?\n\n{content}"
            }
        ]
    )
    return response.content[0].text

def deepen_content(content, gaps):
    """Etapa 4: Expandir áreas faltantes"""
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Expanda este conteúdo para abordar estas lacunas:\n\n{gaps}\n\nConteúdo:\n{content}"
            }
        ]
    )
    return response.content[0].text

# Execute a cadeia
outline = generate_outline("engenharia de prompts", "engenheiros de software")
sections = write_sections(outline, "engenharia de prompts")
gaps = check_depth(sections, "engenharia de prompts")
final_content = deepen_content(sections, gaps)
print(final_content)
```

Cada etapa produz melhor resultado porque está construindo sobre trabalho focado e validado da etapa anterior.

## Padrões-chave que realmente funcionam

**Mantenha o estado mínimo.** Passe apenas o que o próximo passo precisa. Contexto extra cria ruído.

**Use saídas estruturadas ao rotear.** A etapa de classificação deve retornar uma categoria limpa, não prosa. Torna o roteamento à prova de falhas.

**Cache partes agressivas.** Se você está rodando a mesma análise várias vezes, cache o prompt do sistema daquela etapa e ela rodará mais rápido em retentativas.

**Tratamento de erros importa.** Verifique contagens de tokens. Algumas cadeias vão exceder limites se você não estiver observando. Adicione fallbacks para quando uma etapa falhar.

**Registre tudo.** A execução de cadeias é mais difícil de debugar. Armazene a entrada e saída de cada etapa. Você vai precisar.

## Quando NÃO encadear

Alguns problemas genuinamente não precisam de cadeias. Classificação simples, sumarização, ou geração de turno único? Mantenha simples. Cadeias adicionam latência e complexidade. Use-as quando você precisa de:

- Lógica condicional baseada em resultados intermediários
- Especialização (diferentes prompts para diferentes ramificações)
- Portões de qualidade (verificar saída antes de prosseguir)
- Refinamento iterativo (múltiplos passes melhorando resultados)

Sem estes, você está encadeando pelo bem de encadear.

## A vantagem real

Cadeias não são apenas sobre precisão—apesar de serem geralmente mais precisas. São sobre _controlabilidade_. Você pode testar cada etapa independentemente. Pode trocar implementações. Pode adicionar guardrails em pontos específicos. Pode debugar exatamente onde as coisas saíram errado.

Isso é trabalho profissional com IA. Construa suas cadeias deliberadamente, mantenha-as simples, e deixe o Claude fazer seu melhor raciocínio em cada etapa em vez de tentar fazer tudo de uma vez.

```