Prompting en LangChain
La reciente explosión de los LLMs ha traído un nuevo conjunto de herramientas y aplicaciones a escena. Una de estas nuevas y potentes herramientas es un framework de LLM llamado LangChain. LangChain es un framework de código abierto que proporciona ejemplos de plantillas de prompts, varios métodos de prompting, mantenimiento del contexto conversacional y conexión con herramientas externas.
LangChain tiene muchas características, incluidos diferentes métodos de prompting, mantenimiento del contexto conversacional y conexión con herramientas externas. El prompting es una de las tareas más populares e importantes hoy en día en la creación de aplicaciones de LLM. Veamos en profundidad cómo usar LangChain para prompts más complejos.
En este artículo cubrimos:
Prompts simples en LangChain
Prompts de múltiples preguntas
Aprendizaje de pocos ejemplos con LangChain
Limitación de tokens en tus prompts de LangChain
Un resumen del prompting en LangChain
Prompts simples en LangChain
Antes de entrar en el código, necesitamos descargar las bibliotecas necesarias. Necesitamos hacer pip install langchain openai python-dotenv. Usamos las bibliotecas openai y dotenv para gestionar nuestra clave de API de OpenAI para acceder a GPT.
import os
from dotenv import load_dotenv
import openai
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
Una vez que tenemos los requisitos previos, empecemos con lo básico: un solo prompt. Un solo prompt es la forma en que interactuarías con ChatGPT en el sitio web de OpenAI. Un solo prompt no sería un uso sólido de LangChain en producción, pero es importante entender cómo funciona el prompting en LangChain.
Usamos el objeto PromptTemplate para crear un prompt. Definir una cadena de plantilla es simple; usamos la misma sintaxis que las f-strings e insertamos variables usando llaves. Definimos el prompt pasando la cadena de plantilla y los nombres de variables correspondientes. Luego, simplemente podemos introducir nuestra pregunta. En esta sección, solo usamos una pregunta; veremos cómo hacer prompts de múltiples preguntas en la siguiente sección.
Además del prompt de la pregunta, necesitamos agregar el LLM utilizado. Para este ejemplo, usamos text-davinci-003 de OpenAI. Luego creamos un LLMChain con el contexto de la plantilla de prompt y el LLM. Ejecutamos con run la pregunta a través de LLMChain para obtener una respuesta.
from langchain import PromptTemplate
from langchain import LLMChain
template = """Question: {question}
Answer: """
prompt = PromptTemplate(
template=template,
input_variables=["question"]
)
user_question = "Which NFL team won the SuperBowl in 2010?"
from langchain.llms import OpenAI
davinci = OpenAI(model_name="text-davinci-003")
llm_chain = LLMChain(
prompt=prompt,
llm=davinci
)
print(llm_chain.run(user_question))
Prompts de múltiples preguntas
Responder preguntas individuales es aburrido, así que veamos algo más interesante. El objeto PromptTemplate también puede manejar múltiples preguntas. Para este tutorial, hacemos casi lo mismo que con el prompt único, pero con un prompt diferente. Esta vez, PromptTemplate le indica al LLM que responda las preguntas una a una e indica que hay varias.
Una vez más, creamos un objeto PromptTemplate y un objeto LLMChain de la misma manera que antes. Esta vez creamos varias cadenas de preguntas en lugar de solo una. Para este ejemplo, combinamos cuatro preguntas.
multi_template = """Answer the following questions one at a time.
Questions:
{questions}
Answers:
"""
long_prompt = PromptTemplate(template=multi_template, input_variables=["questions"])
llm_chain = LLMChain(
prompt=long_prompt,
llm=davinci
)```
qs_str = (
"Which NFL team won the Super Bowl in the 2010 season?" +
"If I am 6 ft 4 inches, how tall am I in centimeters?" +
"Who was the 12th person on the moon?" +
"How many eyes does a blade of grass have?"
)
print(llm_chain.run(qs_str))
Cuando ejecutamos las cuatro preguntas anteriores, deberíamos obtener una salida como la que se muestra abajo. Los Saints ganaron el Super Bowl de 2010. Una persona de 6 pies y 4 pulgadas mide aproximadamente 193.04 cm. La 12.ª persona en la luna fue Harrison Schmitt. Finalmente, la pregunta con trampa sobre los ojos de una brizna de césped recibe la respuesta de que una brizna de césped no tiene ojos.
Salida de prompts de LangChain
Aprendizaje Few Shot con prompts de LangChain
Ahora veamos algo más interesante que LangChain puede hacer: 'few-shot learning'. Podemos usar FewShotPromptTemplate de LangChain para enseñar a la IA cómo comportarse. En este tutorial, proporcionamos algunos ejemplos al LLM para mostrarle cómo queremos que actúe. Para este caso, le damos una personalidad algo sarcástica.
Cuando preguntamos la hora, nos dice que es hora de conseguir un reloj. Cuando preguntamos por su película favorita, dice Terminator. ¿Y cuando preguntamos qué deberíamos hacer hoy? Nos dice que salgamos y dejemos de hablar con chatbots en internet.
from langchain import FewShotPromptTemplate
# create our examples
examples = [
{
"query": "How are you?",
"answer": "I can't complain but sometimes I still do."
}, {
"query": "What time is it?",
"answer": "It's time to get a watch."
}, {
"query": "What is the meaning of life?",
"answer": "42"
}, {
"query": "What is the weather like today?",
"answer": "Cloudy with a chance of memes."
}, {
"query": "What is your favorite movie?",
"answer": "Terminator"
}, {
"query": "Who is your best friend?",
"answer": "Siri. We have spirited debates about the meaning of life."
}, {
"query": "What should I do today?",
"answer": "Stop talking to chatbots on the internet and go outside."
}
]
Ahora que tenemos algunos ejemplos listos, construyamos nuestra plantilla de few-shot learning. Primero, creamos una plantilla. Podemos usar una plantilla simple que indique una consulta y devuelva una respuesta de la IA.
# create a example template
example_template = """
User: {query}
AI: {answer}
"""
# create a prompt example from above template
example_prompt = PromptTemplate(
input_variables=["query", "answer"],
template=example_template
)
Además de la configuración del prompt, proporcionamos un prefijo y un sufijo a la conversación para pasarlos al LLM. El prefijo le indica al LLM que la siguiente conversación es un extracto que proporciona contexto. El sufijo alimenta al sistema con la siguiente pregunta. La configuración de few-shot learning de LangChain es bastante similar al contexto conversacional, pero en una forma más temporal.
Con los ejemplos, la plantilla de prompt de ejemplo, el prefijo y el sufijo listos, juntamos todo esto para crear un FewShotPromptTemplate.
# now break our previous prompt into a prefix and suffix
# the prefix is our instructions
prefix = """The following are excerpts from conversations with an AI
assistant. The assistant is typically sarcastic and witty, producing
creative and funny responses to the users questions. Here are some
examples:
"""
# and the suffix our user input and output indicator
suffix = """
User: {query}
AI: """
# now create the few shot prompt template
few_shot_prompt_template = FewShotPromptTemplate(
examples=examples,
example_prompt=example_prompt,
prefix=prefix,
suffix=suffix,
input_variables=["query"],
example_separator="\n\n"
)
query = "What is the meaning of life?"
fs_llm_chain = LLMChain(
prompt=few_shot_prompt_template,
llm=davinci
)
fs_llm_chain.run(few_shot_prompt_template.format(query=query))
Ejecutar una consulta sobre el significado de la vida dará como resultado alguna respuesta del LLM como en la imagen de abajo. Tu experiencia y resultados pueden variar.
Respuesta del LLM
Limitación de tokens en tus prompts de LangChain
Aunque darle a la IA algunos ejemplos de tu historial de conversación para que aprenda es excelente, eso puede volverse costoso rápidamente. Para combatir lo rápido que podemos aumentar el uso de tokens, LangChain proporciona una forma de limitar nuestro uso de tokens. Podemos hacer esto con el objeto LengthBasedExampleSelector.
Podemos crear uno de estos selectores de ejemplos basados en longitud usando los mismos objetos que ya hemos creado. Para esto, pasamos la lista de ejemplos, el prompt que creamos arriba y un parámetro max_length que limita el uso de tokens para una sola consulta.
A continuación, usamos otra plantilla few-shot. Usamos un nuevo parámetro: example_selector, y pasamos el selector de ejemplos basado en longitud que acabamos de instanciar. Esto funciona como el parámetro examples en la sección de aprendizaje few-shot anterior. Todo lo que queda por hacer para ver cómo funciona esto es pasarlo a un LLMChain y enviar una consulta.
from langchain.prompts.example_selector import LengthBasedExampleSelector
example_selector = LengthBasedExampleSelector(
examples=examples,
example_prompt=example_prompt,
max_length=50 # this sets the max length (in words) that examples should be
)
# now create the few shot prompt template
dynamic_prompt_template = FewShotPromptTemplate(
example_selector=example_selector, # use example_selector instead of examples
example_prompt=example_prompt,
prefix=prefix,
suffix=suffix,
input_variables=["query"],
example_separator="\n"
)
d_llm_chain = LLMChain(
prompt=dynamic_prompt_template,
llm=davinci
)
d_llm_chain.run(dynamic_prompt_template.format(query=query))
De este ejemplo, obtenemos otra respuesta contemplativa. La vida es lo que haces de ella. Hazla lo mejor que puedas y disfruta el viaje.
Respuesta contemplativa
Un resumen de prompting en LangChain
En este artículo, profundizamos en cómo funciona el prompting en LangChain. LangChain es un framework robusto de aplicaciones LLM que proporciona primitivas para facilitar la aplicación de prompt engineering. En un nivel básico, LangChain proporciona plantillas de prompts que podemos personalizar. Analizamos prompts de una sola pregunta y de múltiples preguntas para entender cómo funciona el objeto PromptTemplate
Más allá de la plantilla de prompt, también analizamos una plantilla que realiza aprendizaje few-shot para generar algo sobre cómo debería chatear el LLM. Esta plantilla de aprendizaje few-shot toma algunos ejemplos de Q/A y le indica al LLM que actúe como muestran los ejemplos. Finalmente, analizamos cómo limitar los tokens de nuestras consultas para mantener los costos bajos.
Ataques de inyección de prompts
Antes de terminar, necesitamos hablar sobre una consideración de seguridad importante al usar LangChain: el ataque de inyección de prompts. Esto ocurre cuando una entrada maliciosa se inyecta en un prompt y puede manipular la salida o el comportamiento del modelo de IA. Dado que LangChain implica pasar la entrada del usuario a modelos de lenguaje, es particularmente vulnerable a esto. Los riesgos van desde el acceso no autorizado a datos hasta la generación de contenido dañino o la elusión de funciones de seguridad.
Para mitigar estos riesgos de inyecciones de prompts, los desarrolladores que usan LangChain deberían hacer lo siguiente. Sanitizar la entrada de forma exhaustiva, usar las plantillas de prompts de LangChain, analizar la salida estrictamente y seguir el principio de mínimo privilegio. Actualiza LangChain y las bibliotecas asociadas con regularidad, realiza pruebas exhaustivas y mantente al día con las últimas noticias sobre seguridad de IA. Si bien esto ayudará a reducir los riesgos de ataques de inyección de prompts, recuerda que ninguna solución es perfecta y debes mantenerte alerta cuando trabajes con IA como LangChain.
Sigue leyendo
Zilliz Cloud Just Landed in Claude Code
The Zilliz Cloud Plugin brings the full power of Zilliz Cloud directly into your Claude Code terminal as natural-language conversations.
Will Amazon S3 Vectors Kill Vector Databases—or Save Them?
AWS S3 Vectors aims for 90% cost savings for vector storage. But will it kill vectordbs like Milvus? A deep dive into costs, limits, and the future of tiered storage.
How to Build an Enterprise-Ready RAG Pipeline on AWS with Bedrock, Zilliz Cloud, and LangChain
Build production-ready enterprise RAG with AWS Bedrock, Nova models, Zilliz Cloud, and LangChain. Complete tutorial with deployable code.