Prompt templates

PromptTemplate

La clase PromptTemplate es el punto de partida para trabajar con prompts estructurados en LangChain, permitiendo separar el texto del prompt de los datos concretos de cada llamada. Gracias a esta abstracción evitamos concatenaciones de strings poco legibles y ganamos en claridad, reutilización y facilidad para hacer cambios controlados en cómo hablamos con el modelo.

Una plantilla define un texto con huecos (variables) que se rellenan en tiempo de ejecución; esos huecos se pueden usar con sintaxis tipo "{variable}" o con motores como Jinja2, aunque para la mayoría de casos basta el formato por defecto. Lo importante es que la estructura del prompt queda fija y solo cambiamos los valores, lo que encaja muy bien con el enfoque de cadenas (prompt | modelo | parser) de LangChain.

• Problema: queremos generar descripciones de productos coherentes en castellano, cambiando solo algunos datos (nombre, tipo de público y tono).

• Solución: crear una PromptTemplate reutilizable y pasarle los valores de cada producto cuando la usemos.

from langchain_core.prompts import PromptTemplate

plantilla_producto = PromptTemplate.from_template(
    "Eres un redactor experto en marketing.\n"
    "Redacta una descripción breve y clara en castellano para el producto: {nombre}.\n"
    "Tipo de cliente objetivo: {publico}.\n"
    "Tono deseado: {tono}."
)

prompt_concreto = plantilla_producto.format(
    nombre="Auriculares inalámbricos X25",
    publico="usuarios que teletrabajan a diario",
    tono="profesional y directo"
)

print(prompt_concreto)

En este ejemplo la lógica del mensaje está encapsulada en la plantilla y solo variamos los datos de entrada, lo que facilita versionar el texto, revisarlo con otros equipos y conectarlo con formularios o bases de datos. La misma PromptTemplate se puede encadenar con un modelo de lenguaje para ejecutar la llamada completa.

from langchain_openai import ChatOpenAI

modelo = ChatOpenAI(model="gpt-5-nano", temperature=0.3)
cadena = plantilla_producto | modelo

respuesta = cadena.invoke(
    {
        "nombre": "Auriculares inalámbricos X25",
        "publico": "usuarios que teletrabajan a diario",
        "tono": "profesional y directo",
    }
)

print(respuesta.content)

Esta integración de PromptTemplate en una cadena LCEL permite razonar sobre el flujo completo de datos: primero definimos la plantilla, luego inyectamos parámetros, y finalmente dejamos que el modelo genere el texto siguiendo siempre la misma estructura.

ChatPromptTemplate

Sobre la base de PromptTemplate, la clase ChatPromptTemplate añade la idea de conversación por mensajes, donde cada fragmento tiene un rol explícito como "system", "human" o "ai". Esta representación por mensajes es la que entienden de forma nativa los modelos de chat modernos, y facilita separar instrucciones globales del sistema de las preguntas concretas del usuario.

En lugar de un único string, una ChatPromptTemplate se construye a partir de una lista de mensajes que pueden contener variables, lo que nos permite definir guiones de conversación reutilizables. Esto encaja especialmente bien en asistentes que necesitan un contexto estable, un tono constante y un flujo de diálogo predecible.

• Problema: necesitamos un asistente de soporte que mantenga siempre el mismo rol y estilo, pero responda a preguntas diferentes de los usuarios.

• Solución: definir una ChatPromptTemplate con mensajes de sistema y usuario parametrizados, y luego conectarla con un modelo de chat.

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

chat_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "Eres un asistente de soporte técnico especializado en {producto}. "
                   "Respondes siempre en castellano claro y conciso."),
        ("human", "{pregunta_usuario}"),
    ]
)

modelo = ChatOpenAI(model="gpt-5-nano", temperature=0.2)
cadena = chat_prompt | modelo

respuesta = cadena.invoke(
    {
        "producto": "una plataforma SaaS de facturación",
        "pregunta_usuario": "¿Cómo puedo descargar todas mis facturas en CSV?",
    }
)

print(respuesta.content)

La ChatPromptTemplate se encarga de generar internamente la lista de mensajes que el modelo necesita, pero nosotros seguimos pensando en términos de una plantilla declarativa. Esto hace sencillo añadir nuevos mensajes (por ejemplo, aclaraciones de sistema o ejemplos) sin cambiar el resto de la aplicación.

partial

El método partial permite fijar de antemano algunas variables de una plantilla, creando una nueva PromptTemplate o ChatPromptTemplate con menos parámetros que rellenar en cada uso. Esta técnica de aplicación parcial resulta especialmente útil cuando varias partes del sistema comparten la misma plantilla base, pero difieren en un pequeño conjunto de valores constantes.

Al hacer un partial, la plantilla resultante conserva todo el formato original, pero sustituye las variables fijadas por sus valores definitivos. De esta forma se reduce el riesgo de olvidar argumentos al llamar a la plantilla y se formaliza la configuración de contexto, idioma, tono o cualquier otro parámetro estable.

• Problema: un equipo quiere usar la misma plantilla de análisis de texto en varios servicios, todos en castellano, pero con mensajes diferentes.

• Solución: crear una plantilla genérica y derivar variantes parciales donde el idioma quede fijado.

from langchain_core.prompts import PromptTemplate

base_prompt = PromptTemplate.from_template(
    "Analiza el siguiente texto en {idioma} y resume las ideas clave en viñetas:\n\n{texto}"
)

prompt_es = base_prompt.partial(idioma="castellano")

prompt_concreto = prompt_es.format(
    texto="El objetivo del proyecto es modernizar la arquitectura de datos..."
)

print(prompt_concreto)

También podemos usar partial con funciones que se evalúan en el momento de formatear, por ejemplo para inyectar fechas o identificadores dinámicos. Esto evita tener que pasar siempre esos parámetros desde capas superiores y mantiene la lógica cercana a la plantilla.

from datetime import date
from langchain_core.prompts import PromptTemplate

base_prompt = PromptTemplate.from_template(
    "[Fecha: {hoy}] Resume para un informe ejecutivo el siguiente texto:\n\n{texto}"
)

prompt_con_fecha = base_prompt.partial(hoy=lambda: date.today().isoformat())

prompt_final = prompt_con_fecha.format(
    texto="Las ventas del último trimestre han superado las previsiones..."
)

print(prompt_final)

En este patrón, la plantilla encapsula tanto el formato como ciertos valores calculados, lo que produce prompts más fiables y predecibles en aplicaciones reales.

MessagesPlaceholder

En conversaciones reales suele existir un historial de mensajes que varía en cada llamada, y que no tiene sentido codificar directamente en la plantilla. Para ese caso, el componente MessagesPlaceholder actúa como un hueco dentro de una ChatPromptTemplate donde podemos insertar una lista de mensajes ya existente, típicamente el historial de chat o las interacciones con herramientas.

Este placeholder permite que la plantilla defina el marco general de la conversación (mensaje de sistema, instrucciones finales, última pregunta del usuario), mientras que el historial completo se pasa como un parámetro más. Así separamos la responsabilidad de construir el contexto dinámico de la responsabilidad de dar la forma final al prompt.

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
from langchain_openai import ChatOpenAI

chat_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "Eres un asistente de atención al cliente."),
        MessagesPlaceholder("historial"),
        ("human", "{pregunta_actual}"),
    ]
)

historial = [
    HumanMessage(content="Hola, tengo un problema con mi pedido."),
    AIMessage(content="Claro, ¿me indicas el número de pedido, por favor?"),
]

modelo = ChatOpenAI(model="gpt-5-nano")
cadena = chat_prompt | modelo

respuesta = cadena.invoke(
    {
        "historial": historial,
        "pregunta_actual": "El pedido 1234 ha llegado incompleto.",
    }
)

print(respuesta.content)

Gracias a MessagesPlaceholder la plantilla no necesita conocer cómo se construye el historial ni cuántos mensajes incluye, lo que simplifica la arquitectura del asistente. Esta pieza encaja especialmente bien cuando el contexto se genera desde una base de datos de conversaciones o desde una capa de orquestación más compleja.

Few Shot Template

Las plantillas de few shot permiten incluir ejemplos explícitos dentro del prompt para guiar mejor el comportamiento del modelo, sin necesidad de ajustar pesos ni entrenar modelos nuevos. La idea es mostrar un par de casos de entrada y salida deseada, para que la IA imite ese patrón cuando reciba nuevos datos.

En LangChain, FewShotPromptTemplate se apoya en una PromptTemplate de ejemplo para formatear cada caso, además de un prefijo y un sufijo que envuelven la lista de ejemplos. Esto resulta especialmente útil en tareas como clasificación de texto, extracción estructurada o reformulación siguiendo un estilo concreto.

from langchain_core.prompts import PromptTemplate, FewShotPromptTemplate
from langchain_openai import ChatOpenAI

ejemplos = [
    {"texto": "El producto llegó tarde y en mal estado.", "sentimiento": "negativo"},
    {"texto": "La atención del soporte fue excelente.", "sentimiento": "positivo"},
]

ejemplo_prompt = PromptTemplate.from_template(
    "Texto: {texto}\nSentimiento: {sentimiento}\n"
)

few_shot_prompt = FewShotPromptTemplate(
    examples=ejemplos,
    example_prompt=ejemplo_prompt,
    prefix="Clasifica el sentimiento (positivo, negativo o neutro) de cada texto.",
    suffix="Texto: {texto}\nSentimiento:",
    input_variables=["texto"],
)

modelo = ChatOpenAI(model="gpt-5-nano", temperature=0.0)
cadena = few_shot_prompt | modelo

respuesta = cadena.invoke({"texto": "El proceso de compra fue sencillo y rápido."})
print(respuesta.content.strip())

En este enfoque, la FewShotPromptTemplate se encarga de combinar el prefijo, todos los ejemplos y el caso actual en un único prompt coherente. Al reutilizar la misma plantilla de ejemplo mantenemos una consistencia clara en el formato de entrada y salida, y facilitamos que el modelo aprenda el patrón deseado a partir de muy pocos ejemplos.