PromptTemplates in Langchain

PromptTemplates in LangChain

In the area of AI and language models, creating effective prompts is crucial for achieving accurate and contextually relevant responses. LangChain offers a powerful tool PromptTemplate that allows for the dynamic creation of prompts. This guide will explore what PromptTemplate is, the different types available, and the benefits of using it.

What is Prompt?

A prompt for a language model is a set of instructions or input provided by a user to guide the model’s response, helping it understand the context and generate relevant and coherent language-based output, such as answering questions, completing sentences, or engaging in a conversation.

Build a Simple LLM Application with LCEL | 🦜️🔗 LangChain

What is a PromptTemplate?

A PromptTemplate in LangChain is a foundational component used to define how a prompt should be formatted before being sent to a language model. It allows for the dynamic insertion of variables into a fixed template, making it easier to create structured and consistent prompts for various tasks. This flexibility is essential for customizing interactions with language models to fit specific needs.

Types of PromptTemplates in LangChain

LangChain offers several types of PromptTemplate, each catering to different use cases. Let's delve into the details and examples of each type:

1. Basic PromptTemplate: This is the simplest form, ideal for straightforward tasks. Placeholders within a fixed string are replaced with your desired variables. For instance, translating text or summarizing an article can be achieved with basic templates.
2. Few-shot PromptTemplate: This template leverages the power of “few-shot learning” by incorporating example prompts and outputs. The LLM learns from these examples, allowing it to better understand the desired task and generate more accurate responses. Imagine using a few-shot template for question answering, where examples demonstrate the question-answer format.
3. Partial PromptTemplate: This template provides flexibility by allowing you to partially fill in a prompt and complete it later. This is useful when some variables are unavailable initially. For example, you could partially fill a translation prompt with the target language and then add the text later. Additionally, functions can be used to dynamically generate variables within the template, such as incorporating the current date.

1. Basic PromptTemplate

The Basic PromptTemplate is the simplest form, where placeholders are used to insert variables into a fixed string.

Example 1:

from langchain.prompts import PromptTemplate

template = """
Translate the following text to {language}: {text}
"""
prompt = PromptTemplate(template=template)
formatted_prompt = prompt.format(text="Hello, how are you?", language="Hindi")
print(formatted_prompt)

Output:

Translate the following text to Hindi: Hello, how are you?

Example 2:

template = """
Summarize the following article in one sentence: {article}
"""
prompt = PromptTemplate(template=template)
formatted_prompt = prompt.format(article="AI is transforming the world by enabling new capabilities and improving efficiencies across various industries.")
print(formatted_prompt)

Output:

Summarize the following article in one sentence: AI is transforming the world by enabling new capabilities and improving efficiencies across various industries.

2. Few-shot PromptTemplate

The Few-shot PromptTemplate includes several examples (shots) to guide the language model on how to perform the task.

Example 1:

from langchain.prompts import FewShotPromptTemplate, PromptTemplate

examples = [
    {"input": "Hello", "output": "Bonjour"},
    {"input": "Goodbye", "output": "Au revoir"},
]
example_template = PromptTemplate(
    input_variables=["input", "output"],
    template="{input} -> {output}"
)
prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_template,
    suffix="{input} ->",
    input_variables=["input"]
)
formatted_prompt = prompt.format(input="Thank you")
print(formatted_prompt)

Output:

Hello -> Bonjour
Goodbye -> Au revoir
Thank you ->

Example 2:

examples = [
    {"question": "What is the capital of France?", "answer": "Paris"},
    {"question": "What is the capital of Germany?", "answer": "Berlin"},
]

example_template = PromptTemplate(
    input_variables=["question", "answer"],
    template="{question} Answer: {answer}"
)
prompt = FewShotPromptTemplate(
    examples=examples,
    example_prompt=example_template,
    suffix="{question} Answer:",
    input_variables=["question"]
)
formatted_prompt = prompt.format(question="What is the capital of Italy?")
print(formatted_prompt)

Output:

What is the capital of France? Answer: Paris
What is the capital of Germany? Answer: Berlin
What is the capital of Italy? Answer:

Partial PromptTemplate

The Partial PromptTemplate allows for partially filling in a prompt and deferring the completion until later. This can be useful when some variables are known early, and others are provided later.

Partial with Strings:

template = "Translate the following English text to {language}: {text}"
partial_prompt = PromptTemplate.from_template(template=template).partial(language="Spanish")
formatted_prompt = partial_prompt.format(text="Good morning")
print(formatted_prompt)

Output:

Translate the following English text to Spanish: Good morning

Partial with Functions:

from datetime import datetime

def get_datetime():
    now = datetime.now()
    return now.strftime("%m/%d/%Y, %H:%M:%S")
prompt = PromptTemplate(
    template="Tell me a {adjective} joke about the day {date}",
    input_variables=["adjective", "date"],
)
partial_prompt = prompt.partial(date=get_datetime)
print(partial_prompt.format(adjective="funny"))

Output:

Tell me a funny joke about the day 08/07/2024, 10:25:47

Benefits of Using PromptTemplates

• Consistency: Ensures that prompts are structured consistently, leading to more predictable responses from language models.
• Flexibility: Allows for dynamic insertion of variables, enabling the creation of customized and contextually relevant prompts.
• Efficiency: Reduces the need to manually construct prompts each time, saving development time and effort.
• Scalability: Facilitates the creation of scalable solutions where prompts need to adapt based on varying inputs and conditions.

Conclusion

LangChain’s PromptTemplate is an essential tool for anyone looking to enhance their prompt engineering capabilities. By understanding and utilizing Basic, Few-shot, and Partial, you can create dynamic, consistent, and contextually rich prompts for a wide range of AI applications. Embrace the power of LangChain and take your language model interactions to the next level.