Prompt Engineering Avanzado: Dominando Chain-of-Thought, ReAct y Tree-of-Thoughts

Introducción: por qué el prompt engineering avanzado ya no es opcional

En los últimos dos años hemos pasado de preguntarnos qué pueden hacer los LLMs a cómo sacarle todo el partido a lo que ya hacen. La diferencia entre una aplicación平庸平庸 y una sobresaliente rara vez está en el modelo base: está en cómo le hablamos. Y aquí es donde el prompt engineering avanzado se convierte en una disciplina de ingeniería seria.

Según un estudio de Stanford (CRFM) de 2023, el uso de técnicas como Chain-of-Thought puede incrementar la precisión en tareas de razonamiento matemático del 18% al 78% en modelos como PaLM. No es magia: es estructura cognitiva aplicada a los prompts.

En este artículo vamos a desgranar tres de las técnicas más potentes del momento:

• Chain-of-Thought (CoT): razonamiento paso a paso.
• ReAct: razonamiento + ejecución de acciones.
• Tree-of-Thoughts (ToT): exploración ramificada de ideas.

Y lo haremos con ejemplos de código reales, comparativas y guías de cuándo usar cada una.

¿Qué es Prompt Engineering y por qué importa?

El prompt engineering es el proceso de diseñar instrucciones para que un modelo de lenguaje produzca el output deseado. La versión básica usa instrucciones directas ("Resume este texto"), pero las técnicas avanzadas incorporan estrategias cognitivas que imitan cómo los humanos resolvemos problemas: descomponer, reflexionar, probar, retroceder.

A medida que los LLMs se usan en flujos críticos — desde generación de código hasta soporte médico o análisis financiero — la diferencia entre un prompt mediocre y uno bien diseñado puede significar el éxito o el fracaso de un producto.

Chain-of-Thought (CoT): el poder de pensar en voz alta

Origen y concepto

La técnica Chain-of-Thought (CoT) fue popularizada por Jason Wei y colaboradores de Google Brain en su paper de 2022 "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models". La idea central es sorprendentemente simple: en lugar de pedirle al modelo la respuesta final, le pedimos que muestre su razonamiento paso a paso, como si fuera un alumno resolviendo un problema en un examen.

Ejemplo básico:

Prompt ingenuo:

Pregunta: Si tengo 3 manzanas y me dan el doble menos 1, ¿cuántas tengo?
Respuesta:

Prompt CoT:

Pregunta: Si tengo 3 manzanas y me dan el doble menos 1, ¿cuántas tengo?
Razonamiento: Empiezo con 3. El doble de 3 es 6. 6 menos 1 es 5.
Respuesta final: 5

Cuando el modelo "ve" el patrón de razonamiento, lo replica en sus propias respuestas. Es como si le estuvieras enseñando el proceso mental que esperas.

Variantes principales

#### 1. Zero-Shot CoT

La más sencilla. Solo añadimos la frase mágica "Pensemos paso a paso" (o su equivalente: "Let's think step by step"). Kojima et al. (2022) demostraron que esta simple adición multiplica el rendimiento en tareas aritméticas y de lógica.

from openai import OpenAI

client = OpenAI()

prompt = """
Un granjero tiene 15 conejos. Cada conejo tiene 2 orejas. 
¿Cómo afectan las orejas de los conejos al sonido de una tormenta?

Pensemos paso a paso antes de responder.
"""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}]
)
print(response.choices[0].message.content)

#### 2. Few-Shot CoT

Incluimos varios ejemplos completos de razonamiento antes de la pregunta real. Es más potente pero más costoso en tokens.

examples_prompt = """
Pregunta: Roger tiene 5 pelotas de tenis.Compra 2 latas más.
Cada lata tiene 3 pelotas. ¿Cuántas tiene ahora?
Razonamiento: Empieza con 5. Compra 2 latas, 2 × 3 = 6. Total: 5 + 6 = 11.
Respuesta: 11

Pregunta: La cafetería tenía 23 manzanas. Usaron 20 para almorzar y compraron 6 más. ¿Cuántas tienen?
Razonamiento: Empieza con 23. Usaron 20, quedan 3. Compraron 6 más: 3 + 6 = 9.
Respuesta: 9

Pregunta: {tu_pregunta}
Razonamiento:
"""

#### 3. Self-Consistency

Propuesto por Wang et al. (2022). Consiste en generar múltiples cadenas de pensamiento (con temperatura alta) y quedarse con la respuesta más votada. Es sorprendentemente efectivo: en tareas GSM8K, mejora la precisión de CoT simple del 57% al 74%.

from collections import Counter

def self_consistency(question, n=5):
    responses = []
    for _ in range(n):
        r = client.chat.completions.create(
            model="gpt-4o",
            temperature=0.7,  # Más diversidad
            messages=[{"role": "user", "content": f"{question}\nPensemos paso a paso."}]
        )
        responses.append(extract_final_answer(r.choices[0].message.content))
    
    # Voto mayoritario
    return Counter(responses).most_common(1)[0][0]

¿Cuándo usar CoT?

• ✅ Tareas con múltiples pasos lógicos (matemáticas, sentido común).
• ✅ Cuando necesitas explicabilidad del resultado.
• ❌ No abuses: para preguntas factuales simples, puede incrementar la latencia sin mejorar la calidad.

ReAct: razonamiento + acciones = agentes útiles

El problema del CoT puro

CoT es genial, pero piensa dentro de la caja: el modelo solo puede razonar con su conocimiento paramétrico interno. ¿Qué pasa cuando necesita información externa, ejecutar código o consultar una API?

La solución de Yao et al. (2022)

ReAct (Reason + Act) entrelaza tres tipos de pasos:

1. Thought (Pensamiento): el modelo reflexiona qué necesita hacer.
2. Action (Acción): elige una herramienta y la invoca.
3. Observation (Observación): recibe el resultado y continúa.

Ejemplo de un agente ReAct respondiendo a "¿Cuál es la capital del país con más población de Europa?":

Thought 1: Necesito saber qué país de Europa tiene más población.
Action 1: Search["European countries by population"]
Observation 1: Alemania, Francia, Reino Unido, Italia, España...

Thought 2: Alemania parece liderar. Ahora busco su capital.
Action 2: Search["capital de Alemania"]
Observation 2: Berlín

Thought 3: Tengo la respuesta.
Action 3: Finish["La capital del país más poblado de Europa es Berlín."]

Implementación con LangChain

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = load_tools(["serpapi", "llm-math"], llm=llm)

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.REACT_DOCSTORE,
    verbose=True,
    handle_parsing_errors=True
)

agent.run("¿En qué año se duplicó la población de Tokio respecto a 1950?")

LangChain implementa ReAct automáticamente: el LLM genera pensamientos, ejecuta herramientas, observa resultados e itera hasta llegar a la respuesta final.

Buenas prácticas con ReAct

• Define herramientas con descripciones claras: si el modelo no entiende qué hace una herramienta, no la usará bien.
• Limita el número de pasos (max_iterations) para evitar loops infinitos.
• Usa modelos potentes: ReAct requiere razonamiento de alto nivel; GPT-4, Claude 3.5 o Gemini 1.5 Pro funcionan mucho mejor que modelos pequeños.

Tree-of-Thoughts (ToT): la exploración ramificada

¿Por qué un "árbol"?

Hay problemas donde no basta con una línea de razonamiento: necesitas explorar varias hipótesis, compararlas, retroceder y elegir la mejor. Esto es exactamente lo que hacen los humanos cuando juegan al ajedrez o resuelven un acertijo complejo.

Yao et al. extendieron en 2023 el concepto de CoT a una estructura de árbol. En lugar de generar una cadena de pensamiento, el modelo genera múltiples ramas, cada una evaluada y podada según heurísticas.

Componentes clave

1. Generador de pensamientos: produce k candidatos por nodo.
2. Evaluador: puntúa cada pensamiento (a menudo con el propio LLM).
3. Algoritmo de búsqueda: BFS o DFS sobre el árbol.

Ejemplo: resolviendo un acertijo lógico

Prompt:

Acertijo: Hay 4 sospechosos: Ana, Bruno, Carmen, David. 
Solo uno cometió el crimen. Las pistas son:
- Si Ana es culpable, entonces Bruno es inocente.
- Carmen y David no pueden ser ambos culpables.
- O Bruno o Carmen es culpable.

Explora diferentes interpretaciones usando Tree-of-Thoughts:

Salida del modelo (resumida):

Thought 1.1: "Supongamos Ana culpable → Bruno inocente → entonces, o Bruno o Carmen culpable, así que Carmen culpable. Pero Carmen y David no pueden ser ambos: OK, solo Carmen. ¿Y con la pista 2? OK."
Thought 1.2: "Supongamos Bruno culpable → Ana puede ser cualquier cosa. La pista 1 no obliga. La 3 se cumple. La 2 con Bruno solo, OK."

Evaluación: Bruno tiene menos contradicciones posibles. 
Respuesta: Bruno es culpable.

Implementación simplificada

def tree_of_thoughts(problem, branching=3, depth=3):
    """Implementación básica de ToT usando BFS."""
    root = generate_thoughts(problem, n=branching)
    frontier = [(thought, 1) for thought in root]
    
    for d in range(depth):
        candidates = []
        for thought, current_depth in frontier:
            if current_depth < depth:
                children = generate_thoughts(
                    problem + f"\nEstado actual: {thought}",
                    n=branching
                )
                for child in children:
                    score = evaluate_thought(problem, child)
                    candidates.append((child, score))
        
        # Poda: mantener los mejores
        candidates.sort(key=lambda x: x[1], reverse=True)
        frontier = [(c[0], d+1) for c in candidates[:branching]]
    
    return frontier[0][0]

En producción, conviene apoyarse en frameworks como tree-of-thoughts de Princeton-NLP o integraciones dentro de LangGraph.

¿Cuándo ToT gana a CoT?

Tarea	CoT	ToT
Aritmética simple	✅ Excelente	⚠️ Sobreingeniería
Acertijos lógicos	⚠️ A veces falla	✅ Excelente
Planificación estratégica	❌ Limitado	✅ Brilla
Escritura creativa con restricciones	⚠️ Regular	✅ Muy bueno
Generación de código con varios archivos	❌ Pierde el hilo	✅ Mantiene coherencia

El trade-off es claro: ToT consume muchos más tokens (a veces 10-50x), así que solo vale la pena en problemas donde la búsqueda realmente importa.

Comparativa rápida: elige bien tu técnica

¿Necesitas razonamiento multi-paso interno? → Chain-of-Thought
¿Necesitas consultar datos externos o ejecutar código? → ReAct
¿Necesitas explorar múltiples estrategias antes de decidir? → Tree-of-Thoughts
¿Estás haciendo una pregunta factual simple? → Prompt directo (con o sin few-shot)

En la práctica, los mejores sistemas combinan varias técnicas: por ejemplo, un agente ReAct que internamente usa CoT, o un ToT donde cada nodo se evalúa con un prompt específico.

Mejores prácticas y errores comunes

Buenas prácticas

• Itera con datos: no asumas que tu prompt funciona; monta una pequeña suite de evaluación (como promptfoo o deepeval).
• Separa el prompt de tu código: usa herramientas como PromptLayer, LangSmith o Humanloop para versionar prompts.
• Piensa en el coste: CoT Self-Consistency puede disparar tu factura 5-10x. ¿Vale la pena? Mide el delta de calidad.
• Estructura tus prompts con secciones claras (Contexto, Instrucciones, Ejemplos, Salida esperada).

Errores a evitar

• ❌ Asumir que más razonamiento siempre es mejor: el modelo puede "racionalizar" respuestas incorrectas.
• ❌ Olvidar el control de temperatura: para razonamiento, temperatura = 0 o muy baja.
• ❌ No validar el formato de salida: usa regex o JSON Schema.
• ❌ Ignorar la ventana de contexto: CoT y ToT consumen muchos tokens y pueden dejarte sin espacio para la respuesta.

El futuro del prompt engineering

Las técnicas que hemos cubierto son programmed prompting: tú escribes las instrucciones. La siguiente frontera es el automated prompt engineering, donde otro LLM optimiza tus prompts (DSPy, OPRO, TextGrad), y los modelos nativamente razonadores como o1 de OpenAI o Claude 3.7 con extended thinking, que ya integran CoT a nivel de arquitectura.

Pero entender estos fundamentos seguirá siendo valioso: incluso con modelos que "razonan" por sí mismos, saber formular problemas con estructura es lo que separa a un integrador de un ingeniero.

Conclusión: pasa de usuario a ingeniero de prompts

Si has llegado hasta aquí, ya tienes un mapa claro de las tres técnicas que están definiendo el estado del arte en interacción con LLMs:

• CoT para hacer pensar al modelo en voz alta.
• ReAct para que actúe sobre el mundo.
• ToT para que explore antes de decidir.

La diferencia entre implementar estas técnicas por separado y combinarlas en pipelines robustos es exactamente el tipo de problema que resolvemos cada día en Tanok Tech.

¿Listo para llevar tus aplicaciones de IA al siguiente nivel? Contáctanos y exploremos juntos cómo integrar estas técnicas en tu producto o flujo interno. También puedes leer más sobre nuestros servicios de consultoría en IA o suscribirte a nuestro newsletter para no perderte las próximas entregas.

---

¿Quieres que profundicemos en alguna de estas técnicas o que veamos cómo aplicarlas a tu caso concreto? Escríbenos y preparamos un artículo a medida.