2. Templates con LangChain.#
Los templates en LangChain, permiten crear plantillas con variables, muy útiles para generar diferentes entornos de AI. Vamos a distinguir don tipos de templates: PromptTemplate y ChatPromptTemplate.
2.1. Usos de PromptTemplate.#
PromptTemplate se utiliza para crear plantillas de prompts simples y lineales en LangChain, permitiendo formatear entradas de texto con variables para generar instrucciones directas para modelos de lenguaje. Es ideal para tareas básicas donde se necesita claridad y facilidad de uso, como generar respuestas basadas en una sola cadena de texto sin contexto conversacional complejo. Por ejemplo, se puede definir una plantilla como “Dime un chiste sobre {tema}” y reemplazar {tema} con un valor específico para invocar un modelo.
2.2. Usos de ChatPromptTemplate.#
ChatPromptTemplate se emplea para construir prompts en formato de chat, manejando listas de mensajes con roles específicos como sistema, humano o AI, lo que facilita interacciones dinámicas y conversacionales. Es útil en aplicaciones que requieren mantener contexto a lo largo de múltiples intercambios, como chatbots o diálogos continuos. Por instancia, permite separar mensajes del sistema (instrucciones generales) de los del usuario, mejorando la estructura para modelos de chat como GPT.
2.3. Diferencia entre PromptTemplate y ChatPromptTemplate.#
La principal diferencia radica en su estructura: PromptTemplate genera una sola cadena de texto formateada, adecuada para prompts lineales y simples, mientras que ChatPromptTemplate crea una lista de mensajes con roles, optimizada para conversaciones multi-turno y modelos de chat. PromptTemplate es más directo y menos flexible para diálogos complejos, pero requiere menos configuración; en cambio, ChatPromptTemplate ofrece mayor capacidad para retener contexto, aunque puede ser más complejo de implementar. En resumen, elige PromptTemplate para tareas no conversacionales y ChatPromptTemplate para flujos interactivos.
2.4. Ejemplo Básico de PromptTemplate.#
Un ejemplo común de uso de PromptTemplate en LangChain es crear una plantilla para generar sugerencias de nombres de empresas basadas en un producto, donde se define una variable de entrada para personalizar el prompt antes de enviarlo a un modelo de lenguaje. Esto permite formatear dinámicamente el texto, reemplazando placeholders como {product} con valores específicos para producir instrucciones claras y reutilizables.
2.4.1. Código de Ejemplo.#
Aquí va un snippet de código en Python que ilustra cómo implementar y formatear un PromptTemplate simple:
from langchain import PromptTemplate
# Definir la plantilla con una variable de entrada
template = """
Actúa como consultor de nombres para nuevas empresas.
¿Qué nombre sería bueno para una empresa que fabrica {producto}?
"""
prompt = PromptTemplate(
input_variables=["producto"],
template=template
)
# Formatear el prompt con un valor específico
prompt_formateado = prompt.format(producto="calcetines coloridos")
print(prompt_formateado)
D:\MisTrabajos\IA_generativa\venv\Lib\site-packages\tqdm\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
from .autonotebook import tqdm as notebook_tqdm
Actúa como consultor de nombres para nuevas empresas.
¿Qué nombre sería bueno para una empresa que fabrica calcetines coloridos?
Otra forma de hacer lo siguiente sería de esta manera:
# Definir la plantilla con una variable de entrada
template = """
Actúa como consultor de nombres para nuevas empresas.
¿Qué nombre sería bueno para una empresa que fabrica {producto}?
"""
prompt = PromptTemplate.from_template(
template=template
)
# Formatear el prompt con un valor específico
prompt_formateado = prompt.format(producto="calcetines coloridos")
print(prompt_formateado)
Actúa como consultor de nombres para nuevas empresas.
¿Qué nombre sería bueno para una empresa que fabrica calcetines coloridos?
Ahora lo utilizariamos de la siguiente manera.
import os
from dotenv import load_dotenv
load_dotenv()
from langchain_openai import OpenAI
llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0.7,api_key=os.getenv("OPENAI_API_KEY") ) # Usa modelo de completación
resumen = llm.invoke(prompt_formateado)
print(resumen)
"RainbowSock Co."
Otra forma utilizando LLMChain
from langchain.chains import LLMChain
llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0.7,api_key=os.getenv("OPENAI_API_KEY") )
chain = LLMChain(llm=llm, prompt=prompt)
respuesta = chain.invoke(input={"producto":"calcetines coloridos"})
print(respuesta)
print("-----------------------")
print(respuesta["text"])
{'producto': 'calcetines coloridos', 'text': '\n"Rainbow Socks Co." o "Vibrant Footwear Inc."'}
-----------------------
"Rainbow Socks Co." o "Vibrant Footwear Inc."
2.5. Ejemplo Básico de ChatPromptTemplate.#
Un ejemplo típico de ChatPromptTemplate en LangChain es construir una plantilla para un tutor que explica conceptos simples, utilizando mensajes con roles como sistema y humano para estructurar una interacción conversacional dinámica. Esto permite formatear una lista de mensajes con variables personalizables, ideal para modelos de chat que manejan contextos multi-turno.
2.5.1. Código de Ejemplo.#
Aquí un snippet en Python que muestra cómo definir y formatear un ChatPromptTemplate:
from langchain_core.prompts import ChatPromptTemplate
# Definir la plantilla con mensajes de sistema y humano
chat_prompt = ChatPromptTemplate.from_messages([
("system", "Eres un tutor paciente que explica las cosas de manera clara."),
("human", "¿Puedes explicar {concepto} como si yo tuviera cinco años?")
])
# Formatear los mensajes con un valor específico
mensajes_formateados = chat_prompt.format_messages(concepto="gravedad")
print(mensajes_formateados)
[SystemMessage(content='Eres un tutor paciente que explica las cosas de manera clara.', additional_kwargs={}, response_metadata={}), HumanMessage(content='¿Puedes explicar gravedad como si yo tuviera cinco años?', additional_kwargs={}, response_metadata={})]
Este código produce una lista de mensajes: el primero como SystemMessage con las instrucciones del sistema, y el segundo como HumanMessage con la pregunta personalizada sobre “gravedad”. Puedes conectar este template a un modelo de chat como GPT para generar respuestas interactivas en una cadena.
Si queremos ejecutar el ejemplo anterior con ChatOpenAI, lo podemos hacer de la siguiente manera
# Instanciar el modelo ChatOpenAI (ajusta el modelo y temperatura según necesites)
llm = ChatOpenAI(
model="gpt-3.5-turbo",
temperature=0.7 # Controla la creatividad; 0 para más determinístico
)
# Invocar el modelo con los mensajes formateados
respuesta = llm.invoke(mensajes_formateados)
# Imprimir los mensajes formateados y la respuesta del modelo
print("Mensajes formateados:")
print(mensajes_formateados)
print("\nRespuesta del modelo:")
print(respuesta.content) # .content extrae el texto de la AIMessage
Mensajes formateados:
[SystemMessage(content='Eres un asistente que resume conversaciones en español.', additional_kwargs={}, response_metadata={}), HumanMessage(content='Hola, ¿qué es la IA?', additional_kwargs={}, response_metadata={}), AIMessage(content='La IA es inteligencia artificial que simula procesos humanos.', additional_kwargs={}, response_metadata={}), HumanMessage(content='Explícame más sobre machine learning.', additional_kwargs={}, response_metadata={}), HumanMessage(content='Resume nuestra conversación en 50 palabras.\nReturn a JSON object.', additional_kwargs={}, response_metadata={})]
Respuesta del modelo:
{
"resumen": "La IA es inteligencia artificial que simula procesos humanos. Machine learning es una rama de la IA que se centra en desarrollar algoritmos que permiten a las máquinas aprender a partir de datos y mejorar con la experiencia."
}
2.5.2. Ejemplo Complejo de ChatPromptTemplate.#
Un ejemplo más complejo de ChatPromptTemplate en LangChain involucra la creación de una plantilla para un asistente de traducción que maneja mensajes de sistema, humano y placeholders para historial de conversación, permitiendo interacciones multi-turno con variables parciales y parsers de salida. Esto es útil para aplicaciones conversacionales avanzadas, como chatbots que mantienen contexto y formatean respuestas en JSON para procesamiento estructurado. La plantilla se puede encadenar con un LLM y un parser para automatizar flujos dinámicos, reduciendo la necesidad de prompts manuales en cada turno
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from langchain_openai import ChatOpenAI # Asumiendo un LLM como OpenAI
# Parser para salida JSON
json_parser = JsonOutputParser()
# Plantilla parcial con instrucciones de formato
prompt_template = ChatPromptTemplate.from_messages([
SystemMessage(content="Eres un asistente que resume conversaciones en español."),
MessagesPlaceholder(variable_name="conversation"), # Placeholder para historial
("human", "Resume nuestra conversación en {word_count} palabras.\n{format_instructions}")
])
# Variables parciales para el parser
prompt_template_partial = prompt_template.partial(
format_instructions=json_parser.get_format_instructions(),
word_count=50
)
# Ejemplo de historial de conversación
conversation = [
HumanMessage(content="Hola, ¿qué es la IA?"),
AIMessage(content="La IA es inteligencia artificial que simula procesos humanos."),
HumanMessage(content="Explícame más sobre machine learning.")
]
# Formatear con el historial
mensajes_formateados = prompt_template_partial.format_messages(conversation=conversation)
# Encadenar con LLM (ejemplo)
llm = ChatOpenAI(model="gpt-3.5-turbo")
chain = prompt_template_partial | llm | json_parser
resumen = chain.invoke({"conversation": conversation})
print(resumen)
{'conversacion': 'Hablamos sobre IA, que es inteligencia artificial que simula procesos humanos. También discutimos sobre machine learning, que es una rama de la IA donde la máquina aprende de datos para tomar decisiones sin ser programada específicamente.', 'palabras': 50}
Este código genera una lista de mensajes que incluye el mensaje de sistema, el historial de conversación insertado en el placeholder, y la consulta humana con variables parciales para el conteo de palabras y formato JSON. Al invocar la cadena, el LLM produce un resumen estructurado en JSON, como {“resumen”: “La conversación introduce IA y machine learning…”} con aproximadamente 50 palabras, facilitando el manejo de contextos complejos en aplicaciones reales.