Creación de Prompts Dinámicos con LangChain

Resumen

¿Qué son los prompt templates y por qué son valiosos?

Los prompt templates juegan un papel crucial en el procesamiento de lenguaje natural al permitir que los modelos como ChatGPT procesen información ajustada a contextos específicos y respondan preguntas de manera dinámica. Estos templates no solo ayudan a formular preguntas y guiar directrices al modelo, sino que también integran cuatro componentes esenciales:

Instrucciones: Directriz sobre cómo debe responder el modelo basado en el contexto dado.
Información externa o contexto: Datos proporcionados al modelo, que pueden ser extraídos de bases de datos u otras fuentes relevantes para recordar conversaciones previas.
Entrada del usuario o consulta: La pregunta o solicitud específica que el usuario quiere resolver.
Indicador de salida: Guía sobre cómo el modelo debe generar su respuesta.

Estos componentes permiten al modelo interactuar de manera coherente con las preguntas del usuario, dándole un carácter flexible y adaptable según necesidades específicas.

¿Cómo se estructuran los prompt templates?

Para comprender mejor la estructura, veamos un ejemplo práctico: el "Prompt Argentino". Este consta de:

Instrucción Inicial: "Responde la pregunta basándote en el contexto de abajo. Si no sabe, responder con 'ni idea, che.'"
Contexto Proporcionado: A menudo, esto incluirá información adicional de bases de datos o resúmenes de conversaciones previas que el modelo debe tener en cuenta.
Consulta del Usuario: Ejemplo de una pregunta como "¿Qué librerías y proveedores de modelos ofrecen MLGES?".
Respuesta Generada: Indicativa, por ejemplo, de escribir como "Argentina informal".

Al seguir este formato, el modelo puede proporcionar respuestas informativas y contextualmente relevantes, alineadas con las expectativas del usuario.

¿Cómo se hacen los prompts más flexibles?

Para hacer un prompt más flexible, podemos introducir variables dentro de sus componentes, como por ejemplo, la consulta del usuario. Aquí es donde usamos herramientas avanzadas como PromptTemplate de LangChain para gestionar estas variables.

Pasos para implementar un prompt dinámico:

Definición de Variables: Identificar qué partes del prompt deben ser variables. Por ejemplo, la pregunta del usuario puede representarse como {query} para indicar que es una variable.
Creación de la Plantilla: Usa PromptTemplate para crear una estructura con variables de input especificadas; por ejemplo:
```
{
    "input_variables": ["query"]
}
```
Integración con un Modelo: Se configura un modelo de lenguaje como GPT-3.5 para que procese estas entradas y genere respuestas en consecuencia.

Esto permite crear prompts adaptativos, capaces de cambiar no solo las preguntas, sino también los contextos o las instrucciones en función de las necesidades del producto o del proyecto.

¿Cómo aplicamos un modelo de lenguaje a nuestros prompts?

Una vez que se ha configurado un PromptTemplate, se utiliza asociado con un modelo de lenguaje, proporcionando un modelo robusto para consultas complejas. Mediante el uso de llmChain de LangChain, el proceso se optimiza aún más:

Creación de una Cadena: Una cadena que toma en cuenta el prompt y el modelo de lenguaje al ser ejecutada:
```
llmGPT3-5_chain = llmChain(prompt=prompt_plantilla_colombiana, model=llmGPT3.5)
```
Ejecución de la Tarea: Aplicación efectiva con el método run(), permitiendo obtener respuestas con base en las directrices del prompt inicial.

Estas implementaciones potencian la capacidad de respuesta del modelo al permitir que se adapte y personalice según requerimientos dinámicos, optimizando así la interacción y el rendimiento del sistema en procesamiento de lenguaje natural.

La creación y gestión de prompts no solo requieren una comprensión técnica del modelo subyacente, sino también un sentido creativo de cómo utilizar las variables para crear interacciones más naturales y humanas. Estas habilidades son esenciales para quienes buscan integrar modelos avanzados de procesamiento de lenguaje en sus proyectos. ¡Continúa explorando y mejorando tus habilidades en este campo fascinante!

Alejandro Cano

student•

Algo interesante que también puedes hacer es pedirle que responda en algún formato especifico, como por ejemplo JSON, muy útil cuando lo que deseas generar es algún insumo para otro proceso (ingesta de datos, o cosas por el estilo)

Ayriel Noriega

student•

Gracias por el aporte

Angelica Maria Vanegas Arrieta

student•

Código utilizando la documentación actual:

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage, SystemMessage

llm_gpt3_5 = ChatOpenAI(
    model='gpt-3.5-turbo',
    n=1,
    temperature=0.3

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "Responde a la pregunta con base en el siguiente contexto:{contexto}, parce. Si la pregunta no puede ser respondida con la información proporcionada, responde con la siguiente frase No tengo ni idea, ome"),
         ("human", "{input}")
    ]
)


chain = prompt | llm_gpt3_5
response = chain.invoke(
    {
        "contexto": "Los Modelos de Lenguaje Grandes (LLMs) son los últimos modelos utilizados en PNL. Su rendimiento superior sobre los modelos más pequeños los ha hecho increíblemente útiles para los desarrolladores que construyen aplicaciones habilitadas para PNL. Estos modelos pueden ser accedidos a través de la biblioteca `transformers` de Hugging Face, a través de OpenAI usando la biblioteca `openai`, y a través de Cohere usando la biblioteca `cohere`.",
        "input": ["¿Que es un LLM?"]
    }
)
response.content

Luis Boivar

student•

Que valioso es este curso, increible!

Emmanuel Rodríguez

student•

📝 Generación de Prompts

Los prompts de los LLM tienen una estructura fija basada en 4 componentes, la totalidad de esta dará información suficiente para retornar una respuesta. .

Instrucción: una tarea o instrucción específica que desea que el modelo realice
Contexto: puede implicar información externa o contexto adicional que pueda dirigir el modelo hacia mejores respuestas
Datos de entrada: es la entrada o pregunta para la que estamos interesados en encontrar una respuesta
Indicador de salida: indica el tipo o el formato de la salida. No todos los componentes son necesarios para un aviso y el formato depende de la tarea en cuestión.

. Para ello, empleamos PromptTemplate desde langchain/prompts:

import { PromptTemplate } from 'langchain/prompts'

const llm = new OpenAI({
	// code ...
})

const prompt = new PromptTemplate({
    template: 'Tell me a {adjective} joke about Disney.',
    inputVariables: ['adjective'],
})

const formattedPrompt = await prompt.format({
    adjective: 'funny',
})

console.log(await llm.predict(formattedPrompt))

Nota. Mediante una plantilla template, se sustituye el placeholder {adjective} mediante el uso de inputVariables. Con format, se reemplaza la referencia para generar una prompt formateado para ser empleado en la nueva petición a OpenAI.

Gabriel Ichcanziho Pérez Landa

student•

Espero no sea una pregunta muy obvia, pero ...

Qué ventajas me daría usar esto en lugar de un f string:

def generar_peticion(nombre, edad):
	peticion = f"""Vas a recibir un nombre y una edad y vas a saludar de la siguiente manera:
Entrada: Gabriel, 26.
Salida: Hola, Gabriel, tienes 26 años.

Entrada: {nombre}, {edad}
Salida:
"""
	return peticion

Victor Rodriguez

student•

Pero adicionándole solo esa orden en la plantilla, ahora si solo se limita a respoder que no tiene ni idea, ome!!

Joser rivas

student•

Yo utilice una manera diferente, no se si le funcione a alguien: from getpass import getpass OPENAI_API_KEY = getpass() import os os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY from langchain.prompts.chat import ( ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate) from langchain.schema import HumanMessage, SystemMessagefrom langchain_openai import ChatOpenAI chat = ChatOpenAI( model = "gpt-3.5-turbo", temperature = 0, n = 1) messages = [ SystemMessage( content="**Contexto:** Los modelos de lenguaje de gran escala (MLGEs) son lo último en modelos usados en el Procesamiento del Lenguaje Natural (NLP). Útiles para los desarrolladores que arman aplicaciones con NLP. Estos modelos se pueden acceder vía librería transformers de Hugging Face, vía OpenAI usando la librería openai, y vía Cohere usando la librería cohere." ), HumanMessage( content="**Pregunta:** ¿Qué librerías están cerca de Buenos Aires?" ), SystemMessage( content="**Instrucción:** Responde la pregunta basándote en el contexto de abajo. Si la pregunta no puede ser respondida usando la información proporcionada, responde con 'Ni idea, che'.", style="instruction" )] # ESTA RESPUESTA TRAE TODO LO QUE # chat(messages) # procesar los mensajesla_respuesta = chat(messages)response = la_respuesta.content print(response) # SI QUIERO SABER EN TOTAL CUANTOS TOKENS UTILIZAMOS SERIAla_respuesta.response_metadata['token_usage']['total_tokens']



from getpass import getpass

OPENAI_API_KEY = getpass()

import os

os.environ['OPENAI_API_KEY'] = OPENAI_API_KEY

from langchain.prompts.chat import (
    ChatPromptTemplate,
    HumanMessagePromptTemplate,
    SystemMessagePromptTemplate
)

from langchain.schema import HumanMessage, SystemMessage
from langchain_openai import ChatOpenAI

chat = ChatOpenAI(
    model = "gpt-3.5-turbo",
    temperature = 0,
    n = 1
)

messages = [
    SystemMessage(
        content="**Contexto:** Los modelos de lenguaje de gran escala (MLGEs) son lo último en modelos usados en el Procesamiento del Lenguaje Natural (NLP). Útiles para los desarrolladores que arman aplicaciones con NLP. Estos modelos se pueden acceder vía librería `transformers` de Hugging Face, vía OpenAI usando la librería `openai`, y vía Cohere usando la librería `cohere`."
    ),
    HumanMessage(
        content="**Pregunta:** ¿Qué librerías están cerca de Buenos Aires?"
    ),
    SystemMessage(
        content="**Instrucción:** Responde la pregunta basándote en el contexto de abajo. Si la pregunta no puede ser respondida usando la información proporcionada, responde con 'Ni idea, che'.", style="instruction"
    )
]

# ESTA RESPUESTA TRAE TODO LO QUE 
# chat(messages)

# procesar los mensajes
la_respuesta = chat(messages)
response = la_respuesta.content

print(response)

# SI QUIERO SABER EN TOTAL CUANTOS TOKENS UTILIZAMOS SERIA
la_respuesta.response_metadata['token_usage']['total_tokens']

Angelica Maria Vanegas Arrieta

student•

Hola Jose, te recomiendo que utilices el símbolo de escribir código para que sea mas legible para las personas que queremos mirar cómo desarrollaste el código. Saludos! :D

David Vallejo Gomez

student•


from langchain_core.prompts import ChatPromptTemplate

template = ChatPromptTemplate([
    ("system", """Responde a la pregunta con base en el siguiente {contexto}, parce. Si la
pregunta no puede ser respondida con la información proporcionada, responde
con "No tengo ni idea, ome".
Respuesta (escribe como colombiano informal): """),
    ("human", "{pregunta}")
],
    input_variables=["contexto", "pregunta"]
)
``````python
#from langchain import LLMChain fue removido ahora se usa el formato `prompt | llm`()

chain = template | llm_gpt3_5

pregunta = "¿ChatGPT es un LLM?"

response = chain.invoke({
    "contexto": """"LLM (Large Language Models) son un tipo de inteligencia artificial, 
                    más concretamente modelos de aprendizaje automático o machine learning, diseñados para comprender y generar lenguaje humano. 
                    Son capaces de realizar diversas tareas de procesamiento de lenguaje natural, como responder preguntas, traducir textos, generar contenido, etc.""",

    "pregunta" : pregunta
})

print(response.content)
``````python
pregunta = "¿Qué es el vallentato?"

response = chain.invoke({
    "contexto": """"LLM (Large Language Models) son un tipo de inteligencia artificial, 
                    más concretamente modelos de aprendizaje automático o machine learning, diseñados para comprender y generar lenguaje humano. 
                    Son capaces de realizar diversas tareas de procesamiento de lenguaje natural, como responder preguntas, traducir textos, generar contenido, etc.""",

    "pregunta" : pregunta
})

print(response.content)

Eduardo Ortiz Quiroz

student•

Hola, comunidad. 😉

En lo personal no me gusta usar modelos de OpenIA así que yo hice esto con un modelo de Ollama y sale básicamente lo mismo.

from langchain_ollama import OllamaLLM

chat = OllamaLLM(
    model="llama3.2:3b",
    n=1,
    temperature=0.3
)
```![](https://static.platzi.com/media/user_upload/Screenshot%202025-03-11%20114409-d8b0efe1-3e42-40a4-b2dd-8914a76c321e.jpg)

Eduardo Ortiz Quiroz

student•

Carlos Arturo Gonzalez Meyberg

student•

Sería interesante actualizar el curso usando la función ChatOpenAI en convinación con system messages.

Ayriel Noriega

student•

que es eso?

Victor Rodriguez

student•

Bueno, aquí al mismo template de la clase, le hice una pregunta que no esta en el contexto dado de LLMs y me la respondío bien. Ahora supongo que porque la pregunta se puede determinar que esta dentro del contexto Colombiano.

Carlos Arturo Gonzalez Meyberg

student•

*combinación