Prompt templates

PromptTemplates y ChatPromptTemplates

Los prompt templates en LangChain proporcionan una forma estructurada y reutilizable de crear prompts dinámicos. En lugar de construir prompts manualmente concatenando strings, estos templates permiten definir plantillas con variables que se pueden rellenar posteriormente con valores específicos.

PromptTemplate para modelos de texto

La clase PromptTemplate está diseñada para trabajar con modelos de texto tradicionales que esperan una única cadena como entrada. Esta clase permite crear plantillas con variables que se sustituyen dinámicamente:

from langchain_core.prompts import PromptTemplate

# Crear un template básico
template = PromptTemplate(
    input_variables=["producto", "caracteristicas"],
    template="Escribe una descripción comercial para {producto} destacando estas características: {caracteristicas}"
)

# Formatear el prompt con valores específicos
prompt_formateado = template.format(
    producto="smartphone",
    caracteristicas="cámara de 108MP, batería de larga duración, pantalla OLED"
)

print(prompt_formateado)

El método format() sustituye las variables del template por los valores proporcionados, generando el prompt final que se puede enviar al modelo.

ChatPromptTemplate para modelos conversacionales

Para modelos de chat como GPT-4, la clase ChatPromptTemplate es más apropiada ya que trabaja con mensajes estructurados en lugar de texto plano. Esta clase permite crear templates que generan listas de mensajes con diferentes roles:

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# Crear un template de chat con múltiples mensajes
chat_template = ChatPromptTemplate.from_messages([
    ("system", "Eres un experto en {dominio}. Responde de forma profesional y precisa."),
    ("human", "Explícame {concepto} de manera sencilla con un ejemplo práctico.")
])

# Formatear el template
messages = chat_template.format_messages(
    dominio="programación Python",
    concepto="decoradores"
)

# Usar con un modelo de chat
llm = ChatOpenAI(model="gpt-4")
response = llm.invoke(messages)
print(response.content)

Ejemplo de formateo:

Métodos de construcción alternativos

ChatPromptTemplate ofrece varios métodos de construcción que simplifican la creación de templates según diferentes patrones comunes:

Método from_template() para prompts simples:

# Template simple con un solo mensaje humano
simple_template = ChatPromptTemplate.from_template(
    "Traduce el siguiente texto al {idioma}: {texto}"
)

messages = simple_template.format_messages(
    idioma="francés",
    texto="Hola, ¿cómo estás?"
)

Método from_messages() para conversaciones estructuradas:

# Template con múltiples roles y contexto
conversation_template = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente de cocina especializado en {tipo_cocina}."),
    ("human", "¿Qué ingredientes necesito para {plato}?"),
    ("ai", "Para preparar {plato} necesitarás..."),
    ("human", "{pregunta_seguimiento}")
])

Integración con modelos de chat

Los ChatPromptTemplate se integran perfectamente con los modelos de chat de LangChain, creando un flujo de trabajo limpio y mantenible:

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

# Definir el template
template = ChatPromptTemplate.from_messages([
    ("system", "Eres un analista de datos experto. Analiza la información proporcionada y proporciona insights claros."),
    ("human", "Analiza estos datos de ventas: {datos_ventas}. Enfócate en {aspecto_analisis}.")
])

# Configurar el modelo
llm = ChatOpenAI(model="gpt-4")

# Crear el prompt y obtener respuesta
messages = template.format_messages(
    datos_ventas="Enero: 15000€, Febrero: 18000€, Marzo: 12000€",
    aspecto_analisis="tendencias mensuales y recomendaciones"
)

response = llm.invoke(messages)
print(response.content)

Validación y manejo de variables

Los prompt templates incluyen validación automática de variables, asegurando que todas las variables requeridas estén presentes al formatear:

# Template con variables específicas
template = ChatPromptTemplate.from_messages([
    ("system", "Contexto: {contexto}"),
    ("human", "Pregunta sobre {tema}: {pregunta}")
])

# Esto generará un error si falta alguna variable
try:
    messages = template.format_messages(
        contexto="Desarrollo web",
        tema="JavaScript"
        # Falta la variable 'pregunta'
    )
except KeyError as e:
    print(f"Variable faltante: {e}")

La reutilización de templates es una de las principales ventajas de este enfoque, permitiendo mantener prompts consistentes a través de diferentes partes de una aplicación mientras se adaptan a contextos específicos mediante variables dinámicas.

MessagesPlaceholder

El MessagesPlaceholder es un componente especializado de LangChain que permite insertar dinámicamente listas de mensajes dentro de un ChatPromptTemplate. A diferencia de las variables tradicionales que sustituyen texto, este placeholder está diseñado específicamente para manejar secuencias de mensajes completas, lo que resulta especialmente útil para conversaciones con historial o contextos complejos.

Concepto y propósito

Un MessagesPlaceholder actúa como un contenedor que puede albergar múltiples mensajes de diferentes tipos (system, human, ai) en una posición específica del template. Esto permite crear prompts que incorporen conversaciones previas, ejemplos de interacciones o cualquier secuencia de mensajes que necesite ser insertada dinámicamente:

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

# Template con placeholder para historial de conversación
template = ChatPromptTemplate.from_messages([
    ("system", "Eres un asistente útil que mantiene el contexto de la conversación."),
    MessagesPlaceholder(variable_name="historial"),
    ("human", "{pregunta_actual}")
])

# Crear historial de mensajes
historial_conversacion = [
    HumanMessage(content="¿Cuál es la capital de Francia?"),
    AIMessage(content="La capital de Francia es París."),
    HumanMessage(content="¿Y cuántos habitantes tiene?")
]

# Formatear el template incluyendo el historial
messages = template.format_messages(
    historial=historial_conversacion,
    pregunta_actual="¿Qué monumentos famosos hay allí?"
)

Ejemplo de uso:

Casos de uso prácticos

El MessagesPlaceholder resulta especialmente valioso en aplicaciones que requieren mantener contexto conversacional. Por ejemplo, en un chatbot que debe recordar interacciones previas:

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

# Configurar el modelo y template
llm = ChatOpenAI(model="gpt-4")

conversation_template = ChatPromptTemplate.from_messages([
    ("system", "Eres un tutor de programación. Usa el historial para dar respuestas coherentes."),
    MessagesPlaceholder(variable_name="conversacion_previa"),
    ("human", "{nueva_pregunta}")
])

# Simular una conversación en curso
historial = [
    HumanMessage(content="Estoy aprendiendo Python. ¿Qué son las listas?"),
    AIMessage(content="Las listas en Python son estructuras de datos ordenadas y mutables que pueden contener elementos de diferentes tipos."),
    HumanMessage(content="¿Puedes darme un ejemplo?"),
    AIMessage(content="Claro: mi_lista = [1, 'texto', 3.14, True]. Puedes acceder a elementos con índices: mi_lista[0] devuelve 1.")
]

# Continuar la conversación
messages = conversation_template.format_messages(
    conversacion_previa=historial,
    nueva_pregunta="¿Cómo puedo añadir elementos a esa lista?"
)

response = llm.invoke(messages)
print(response.content)

Múltiples placeholders en un template

Un ChatPromptTemplate puede contener varios MessagesPlaceholder, cada uno con un propósito específico. Esto permite crear estructuras de prompt más sofisticadas:

# Template con múltiples placeholders
advanced_template = ChatPromptTemplate.from_messages([
    ("system", "Eres un analista que debe considerar tanto ejemplos como historial."),
    MessagesPlaceholder(variable_name="ejemplos"),
    ("human", "Contexto actual: {contexto}"),
    MessagesPlaceholder(variable_name="historial_reciente"),
    ("human", "Pregunta específica: {pregunta}")
])

# Preparar diferentes tipos de mensajes
ejemplos_referencia = [
    HumanMessage(content="Ejemplo: ¿Cómo analizar datos de ventas?"),
    AIMessage(content="Para analizar datos de ventas, primero identifica patrones temporales, luego segmenta por categorías...")
]

conversacion_reciente = [
    HumanMessage(content="Tengo datos del último trimestre"),
    AIMessage(content="Perfecto, podemos hacer un análisis trimestral detallado")
]

# Formatear con múltiples placeholders
messages = advanced_template.format_messages(
    ejemplos=ejemplos_referencia,
    contexto="Análisis de rendimiento de productos tecnológicos",
    historial_reciente=conversacion_reciente,
    pregunta="¿Qué métricas son más relevantes para este análisis?"
)

Placeholder opcional

Los MessagesPlaceholder pueden configurarse como opcionales, lo que permite crear templates flexibles que funcionen tanto con historial como sin él:

# Placeholder opcional para mayor flexibilidad
flexible_template = ChatPromptTemplate.from_messages([
    ("system", "Responde de forma útil y concisa."),
    MessagesPlaceholder(variable_name="contexto_opcional", optional=True),
    ("human", "{consulta}")
])

# Usar sin contexto adicional
messages_sin_contexto = flexible_template.format_messages(
    consulta="¿Qué es la programación funcional?"
)

# Usar con contexto adicional
contexto_adicional = [
    HumanMessage(content="Estoy comparando paradigmas de programación"),
    AIMessage(content="Excelente tema. Los paradigmas definen diferentes enfoques para resolver problemas.")
]

messages_con_contexto = flexible_template.format_messages(
    contexto_opcional=contexto_adicional,
    consulta="¿Qué es la programación funcional?"
)

Integración con aplicaciones reales

En aplicaciones prácticas, el MessagesPlaceholder se combina frecuentemente con sistemas de almacenamiento de conversaciones para crear experiencias de chat coherentes:

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_openai import ChatOpenAI

class ChatBot:
    def __init__(self):
        self.llm = ChatOpenAI(model="gpt-4")
        self.template = ChatPromptTemplate.from_messages([
            ("system", "Eres un asistente especializado en {dominio}. Mantén coherencia con la conversación previa."),
            MessagesPlaceholder(variable_name="historial"),
            ("human", "{mensaje_usuario}")
        ])
        self.historial_conversacion = []
    
    def responder(self, mensaje_usuario, dominio="asistencia general"):
        # Formatear prompt con historial actual
        messages = self.template.format_messages(
            dominio=dominio,
            historial=self.historial_conversacion,
            mensaje_usuario=mensaje_usuario
        )
        
        # Obtener respuesta del modelo
        response = self.llm.invoke(messages)
        
        # Actualizar historial para futuras interacciones
        self.historial_conversacion.extend([
            HumanMessage(content=mensaje_usuario),
            AIMessage(content=response.content)
        ])
        
        return response.content

# Ejemplo de uso
bot = ChatBot()
print(bot.responder("Hola, necesito ayuda con Python", "programación"))
print(bot.responder("¿Qué son las funciones lambda?", "programación"))

El MessagesPlaceholder transforma la manera en que se construyen prompts complejos, permitiendo que las aplicaciones mantengan contexto conversacional de forma natural y eficiente, sin necesidad de manipular manualmente strings o concatenar mensajes.