Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Tree-of-Thought: Exploração Estruturada

Aula 7 de 16 Atualizada a 3 de novembro de 2026 Programador
Nesta página
  1. Tree-of-Thought: Exploração Estruturada
  2. Diferença em relação ao Chain-of-Thought
  3. Implementação com Prompt Único
  4. Implementação com Múltiplas Chamadas
  5. Exemplo Prático: Arquitetura de Software
  6. Onde o ToT Vence e Onde Perde o Seu Tempo
  7. Combinação com Configurações de Raciocínio
  8. Pontos-chave

Lição atualizada em 3 de novembro de 2026 com base na documentação da OpenAI: temperature e top_p só são aceites com um esforço de raciocínio de none, enquanto os modelos GPT-5.6 raciocinam por predefinição (medium). As chamadas que definem estes parâmetros devem, portanto, especificar reasoning={"effort": "none"} (API de Respostas) ou reasoning_effort="none" (Chat Completions). Fontes: Utilizar o GPT-6 · GPT-5.6 Terra.

Tree-of-Thought: Exploração Estruturada

O Tree-of-Thought (ToT) é uma técnica de prompting que estrutura o raciocínio do modelo como uma árvore de decisão. Em vez de seguir um único caminho de pensamento linear, o modelo explora múltiplos ramos, avalia cada um e mantém apenas os mais promissores. A semelhança com um algoritmo de pesquisa é direta: gera candidatos, atribui-lhes uma pontuação e poda o restante. Isto torna-o altamente eficaz para problemas que exigem planeamento ou retrocesso.

Diferença em relação ao Chain-of-Thought

O Chain-of-Thought (CoT) segue um raciocínio linear: passo 1, passo 2, passo 3. A sua fraqueza é estrutural. Se o modelo enveredar pelo caminho errado no passo 2, tudo o que se segue herda esse erro, não havendo mecanismo para recuar. O raciocínio pode estar perfeitamente articulado, mas parte de uma premissa falsa. O Tree-of-Thought explora múltiplas direções em cada passo e descarta os becos sem saída antes de investir mais desenvolvimento neles.

# Chain-of-Thought (linear)
# Passo 1 → Passo 2 → Passo 3 → Resposta

# Tree-of-Thought (baseado em árvore)
#            Passo 1
#          /    |    \
#     Opção A  Opção B  Opção C    ← avaliação
#       |      |      ✗      ← poda
#    Opção A1  Opção B1
#      |       |
#   Resposta  Resposta            ← seleção final

Implementação com Prompt Único

A versão mais simples cabe numa única chamada: o prompt força o modelo a seguir uma estrutura de exploração — gerar três abordagens, avaliá-las, escolher uma e desenvolvê-la. Isto é pouco dispendioso e muitas vezes suficiente para abordar uma questão em aberto. Tenha consciência de uma limitação antes de depender disto: o modelo propõe e avalia no mesmo fôlego, tornando-se indulgente com as suas próprias ideias, o que resulta numa poda menos severa do que o necessário.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT num único prompt."""
    prompt = f"""Resolva este problema utilizando a abordagem Tree-of-Thought.

Problema: {problem}

Passo 1 - Gere 3 abordagens diferentes:
- Abordagem A: ...
- Abordagem B: ...
- Abordagem C: ...

Passo 2 - Avalie cada abordagem (pontos fortes e fracos):
- Abordagem A: ...
- Abordagem B: ...
- Abordagem C: ...

Passo 3 - Selecione a melhor abordagem e desenvolva-a:
Abordagem selecionada: ...
Desenvolvimento detalhado: ...

Passo 4 - Resposta final:
..."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requer effort none
        input=prompt,
        temperature=0.7
    )
    return response.output_text

Implementação com Múltiplas Chamadas

Para problemas complexos, separe cada passo em chamadas distintas. Esta decomposição oferece-lhe duas coisas que um único prompt não consegue. Primeiro, controlo da temperatura passo a passo: 0,8 para a geração, onde a diversidade de propostas é o cerne do método, e depois 0,3 para a avaliação e desenvolvimento, onde se deseja rigor e reprodutibilidade. Segundo, resultados intermédios que pode inspecionar, registar ou mesmo submeter para validação humana antes de deixar a cadeia continuar.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT com exploração multinível."""
    system = "Você é um especialista em resolução estruturada de problemas."

    # Passo 1: Gerar ramos iniciais
    gen_prompt = (f"Problema: {problem}\n\n"
                  f"Proponha {breadth} abordagens diferentes para resolver "
                  f"este problema. Para cada abordagem, forneça um título e "
                  f"uma descrição de 2-3 frases. Numere-as de 1 a {breadth}.")

    branches_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requer effort none
        instructions=system,
        input=gen_prompt,
        temperature=0.8
    )
    branches = branches_response.output_text

    # Passo 2: Avaliar cada ramo
    eval_prompt = (f"Problema: {problem}\n\n"
                   f"Aqui estão {breadth} abordagens propostas:\n{branches}\n\n"
                   f"Avalie cada abordagem com base em 3 critérios (pontuação /10):\n"
                   f"- Viabilidade\n- Eficiência\n- Simplicidade\n\n"
                   f"Classifique-as da melhor para a pior com justificação.")

    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requer effort none
        instructions=system,
        input=eval_prompt,
        temperature=0.3
    )
    evaluation = eval_response.output_text

    # Passo 3: Desenvolver o melhor ramo
    dev_prompt = (f"Problema: {problem}\n\n"
                  f"Avaliação das abordagens:\n{evaluation}\n\n"
                  f"Desenvolva a abordagem melhor classificada em detalhe. "
                  f"Forneça uma solução completa e acionável.")

    solution = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requer effort none
        instructions=system,
        input=dev_prompt,
        temperature=0.3
    )

    return {
        "branches": branches,
        "evaluation": evaluation,
        "solution": solution.output_text
    }

Exemplo Prático: Arquitetura de Software

O problema abaixo é exatamente o tipo de situação onde o ToT agrega valor. Várias estratégias são defensáveis — caching, réplicas de leitura, extração do serviço de pesquisa, implantação blue-green — e a escolha depende de restrições que o prompt declara explicitamente, especialmente o tamanho da equipa. Um prompt direto dar-lhe-ia a solução mais citada na literatura técnica, independentemente destas restrições; o ToT coloca-a em confronto com as outras e deve defender a sua classificação com base em critérios de viabilidade.

problem = """
A nossa API REST monolítica (Django, PostgreSQL) está a atingir os seus limites:
- Máximo de 500 pedidos/segundo
- Tempo de resposta > 2s nos endpoints de pesquisa
- Implantação = 30 minutos de inatividade
- 3 programadores na equipa

Como podemos melhorar o desempenho e a disponibilidade
sem reescrever toda a aplicação?
"""

result = tree_of_thought(problem, breadth=4)
print(result["solution"])

Onde o ToT Vence e Onde Perde o Seu Tempo

A técnica brilha em problemas de planeamento — arquitetura, roadmaps, estratégia —, em problemas condicionados como otimização ou alocação de recursos, em depuração complexa onde múltiplas causas permanecem plausíveis simultaneamente e em decisões técnicas como a escolha de um framework ou base de dados. Estas situações partilham duas características: existem múltiplas soluções válidas e existe um critério explícito para as distinguir.

Por outro lado, evite-a para perguntas factuais simples, onde não há nada a explorar e pagaria por três chamadas para obter uma resposta óbvia. Também falha em tarefas criativas em aberto devido à falta de um critério de avaliação defensável: classificar três slogans publicitários numa escala de viabilidade não faz sentido. Finalmente, evite-a quando a latência for crítica, uma vez que a versão de múltiplas chamadas encadeia mecanicamente vários pedidos à API antes de devolver qualquer coisa.

Combinação com Configurações de Raciocínio

Com configurações de raciocínio elevadas, os modelos GPT-5.6 já realizam uma exploração interna estruturada. O ToT explícito torna-se então largamente redundante e cobra-lhe duas vezes pelo mesmo trabalho. Reserve-o para situações onde o raciocínio está desativado ou é baixo, como na comparação abaixo.

# Com raciocínio baixo: ToT explícito é útil
result = tree_of_thought(problem, breadth=3)

# Com raciocínio elevado: o modelo já raciocina profundamente
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

Para decidir no seu próprio contexto, pegue num problema de arquitetura ou design que tenha realmente para resolver esta semana, execute-o através do ToT de múltiplas chamadas com breadth=3 e, em seguida, submeta-o tal como está num prompt direto. Compare as duas soluções e, acima de tudo, o custo em tokens de cada uma. Para uma decisão de alto risco, a diferença de qualidade compensa largamente o custo extra; para uma questão secundária, não compensa, e saber isto impedi-lo-á de aplicar a técnica em todo o lado por hábito.

Pontos-chave

  • O ToT explora múltiplos caminhos de raciocínio e seleciona o melhor
  • Versão simples com prompt único ou versão avançada com múltiplas chamadas
  • Ideal para planeamento, arquitetura e depuração complexa
  • Com configurações de raciocínio elevadas, os modelos GPT-5.6 já possuem ToT implícito
  • O custo extra de tokens justifica-se para decisões de alto impacto