Ir al contenido principal
Español— Elegir un idioma
Menú

Árbol de pensamiento: exploración estructurada

Lección 7 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Árbol de pensamiento: exploración estructurada
  2. Diferencia con la cadena de pensamiento
  3. Implementación con una sola llamada
  4. Implementación con múltiples llamadas
  5. Ejemplo práctico: arquitectura de software
  6. Dónde gana ToT y dónde hace perder el tiempo
  7. Combinación con la configuración de razonamiento
  8. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: temperature y top_p solo se aceptan con un esfuerzo de razonamiento de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API de Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Árbol de pensamiento: exploración estructurada

El árbol de pensamiento (ToT, por sus siglas en inglés) es una técnica de prompting que estructura el razonamiento del modelo como un árbol de decisiones. En lugar de seguir una única trayectoria lineal, el modelo explora varias ramas, evalúa cada una y conserva solo las más prometedoras. La similitud con un algoritmo de búsqueda es directa: generas candidatos, los puntuas y podas el resto. Esto lo hace muy eficaz para problemas que requieren planificación o retroceso.

Diferencia con la cadena de pensamiento

La cadena de pensamiento (CoT) sigue un razonamiento lineal: paso 1, paso 2, paso 3. Su debilidad es estructural. Si el modelo toma un camino erróneo en el paso 2, todo lo posterior hereda ese error y no existe ningún mecanismo para volver atrás. El razonamiento puede estar perfectamente articulado, pero parte de una premisa falsa. El árbol de pensamiento explora múltiples direcciones en cada paso y descarta los callejones sin salida antes de invertir más desarrollo en ellos.

# Cadena de pensamiento (lineal)
# Paso 1 → Paso 2 → Paso 3 → Respuesta

# Árbol de pensamiento (basado en árbol)
#            Paso 1
#          /    |    \
#     Opc A  Opc B  Opc C    ← evaluación
#       |      |      ✗      ← poda
#    Opc A1  Opc B1
#      |       |
#   Respuesta  Respuesta     ← selección final

Implementación con una sola llamada

La versión más sencilla cabe en una única llamada: el prompt obliga al modelo a seguir una estructura de exploración (generar tres enfoques, evaluarlos, elegir uno y desarrollarlo). Es económica y a menudo basta para abordar una pregunta abierta. Ten en cuenta una limitación antes de depender de ella: el modelo propone y evalúa en el mismo aliento, lo que lo hace indulgente con sus propias ideas y da lugar a una poda menos severa de la necesaria.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT en un único prompt."""
    prompt = f"""Resuelve este problema usando el enfoque de Árbol de Pensamiento.

Problema: {problem}

Paso 1 - Genera 3 enfoques diferentes:
- Enfoque A: ...
- Enfoque B: ...
- Enfoque C: ...

Paso 2 - Evalúa cada enfoque (puntos fuertes y débiles):
- Enfoque A: ...
- Enfoque B: ...
- Enfoque C: ...

Paso 3 - Selecciona el mejor enfoque y desarróllalo:
Enfoque seleccionado: ...
Desarrollo detallado: ...

Paso 4 - Respuesta final:
..."""

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

Implementación con múltiples llamadas

Para problemas complejos, separa cada paso en llamadas distintas. Esta división te aporta dos cosas que un único prompt no puede ofrecer. Primero, control de la temperatura paso a paso: 0,8 para la generación, donde la diversidad de propuestas es la razón de ser del método, y luego 0,3 para la evaluación y el desarrollo, donde buscas rigor y reproducibilidad. Segundo, resultados intermedios que puedes inspeccionar, registrar o incluso someter a validación humana antes de dejar que la cadena continúe.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT con exploración multinivel."""
    system = "Eres un experto en resolución estructurada de problemas."

    # Paso 1: Generar ramas iniciales
    gen_prompt = (f"Problema: {problem}\n\n"
                  f"Propón {breadth} enfoques diferentes para resolver "
                  f"este problema. Para cada enfoque, proporciona un título y "
                  f"una descripción de 2 o 3 frases. Numéralos del 1 al {breadth}.")

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

    # Paso 2: Evaluar cada rama
    eval_prompt = (f"Problema: {problem}\n\n"
                   f"Aquí tienes {breadth} enfoques propuestos:\n{branches}\n\n"
                   f"Evalúa cada enfoque según 3 criterios (puntuación /10):\n"
                   f"- Viabilidad\n- Eficiencia\n- Simplicidad\n\n"
                   f"Ordénalos de mejor a peor con justificación.")

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

    # Paso 3: Desarrollar la mejor rama
    dev_prompt = (f"Problema: {problem}\n\n"
                  f"Evaluación de los enfoques:\n{evaluation}\n\n"
                  f"Desarrolla en detalle el enfoque mejor valorado. "
                  f"Proporciona una solución completa y aplicable.")

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

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

Ejemplo práctico: arquitectura de software

El problema siguiente es exactamente el tipo de caso en el que ToT aporta valor. Varias estrategias son defendibles (caché, réplicas de lectura, extracción del servicio de búsqueda, despliegue blue-green) y la elección depende de restricciones que el prompt establece explícitamente, especialmente el tamaño del equipo. Un prompt directo te daría la solución más citada en la literatura técnica, independientemente de estas restricciones; ToT la enfrenta a las demás y debe defender su clasificación basándose en criterios de viabilidad.

problem = """
Nuestra API REST monolítica (Django, PostgreSQL) está alcanzando sus límites:
- Máximo 500 solicitudes/segundo
- Tiempo de respuesta > 2 s en endpoints de búsqueda
- Despliegue = 30 minutos de tiempo de inactividad
- 3 desarrolladores en el equipo

¿Cómo podemos mejorar el rendimiento y la disponibilidad
sin reescribir toda la aplicación?
"""

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

Dónde gana ToT y dónde hace perder el tiempo

La técnica destaca en problemas de planificación (arquitectura, hojas de ruta, estrategia), en problemas con restricciones como optimización o asignación de recursos, en depuración compleja donde varias causas siguen siendo plausibles simultáneamente y en decisiones técnicas como elegir un framework o una base de datos. Estas situaciones comparten dos rasgos: existen múltiples soluciones válidas y hay un criterio explícito para distinguirlas.

Por el contrario, omítela para preguntas factuales simples donde no hay nada que explorar y pagarías por tres llamadas para obtener una respuesta obvia. También falla en tareas creativas abiertas por la falta de un criterio de evaluación defendible: clasificar tres eslóganes publicitarios en una escala de viabilidad no tiene sentido. Por último, evítala cuando la latencia sea crítica, ya que la versión de múltiples llamadas encadena mecánicamente varias solicitudes a la API antes de devolver cualquier resultado.

Combinación con la configuración de razonamiento

Con configuraciones de razonamiento altas, los modelos GPT-5.6 ya realizan una exploración interna estructurada. Un ToT explícito se vuelve entonces en gran medida redundante y te cobra dos veces por el mismo trabajo. Resérvalo para situaciones donde el razonamiento esté desactivado o sea bajo, como en la comparación siguiente.

# Con razonamiento bajo: ToT explícito es útil
result = tree_of_thought(problem, breadth=3)

# Con razonamiento alto: el modelo ya razona en profundidad
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

Para decidir en tu propio contexto, toma un problema de arquitectura o diseño que tengas realmente sobre la mesa esta semana, ejecútalo mediante ToT de múltiples llamadas con breadth=3 y luego envíalo tal cual en un prompt directo. Compara las dos soluciones y, sobre todo, el coste en tokens de cada una. Para una decisión de alto impacto, la diferencia de calidad compensa con creces el coste adicional; para una pregunta secundaria, no es así, y saber esto te evitará aplicar la técnica en todas partes por inercia.

Puntos clave

  • ToT explora múltiples trayectorias de razonamiento y selecciona la mejor
  • Versión simple con un único prompt o versión avanzada con múltiples llamadas
  • Ideal para planificación, arquitectura y depuración compleja
  • Con configuraciones de razonamiento altas, los modelos GPT-5.6 ya tienen ToT implícito
  • El coste adicional en tokens está justificado para decisiones de alto impacto