What is a PipelinePromptTemplate in LangChain?

At the heart of interacting with large language models (LLMs) lies the art of crafting prompts—the guiding questions or instructions that shape the AI's responses. But what if our project demands more complexity than a single prompt can offer? This is where PipelinePromptTemplate comes in. It is a powerful feature from LangChain designed just for occasions like this. Think of it as building a multilayered cake, where each layer, or prompt in this case, adds its own flavor, contributing to a rich final outcome.

A practical example

Let's look at a practical example to understand why and how this might be needed. Imagine we’re developing a customer support chatbot that handles different types of inquiries, such as product information, troubleshooting, and feedback collection. Each type of inquiry requires a distinct approach, but they all share some common elements, like greeting the user and closing the conversation politely.

Traditionally, we might create separate, static prompts for each inquiry type, incorporating the greeting and closing in each prompt. This straightforward approach leads to duplication of effort and makes prompt management challenging. Any changes to the common elements (like modifying the greeting) would require updates across all prompts, increasing the risk of inconsistencies.

Suppose we have two static prompts for a customer support chatbot handling product information and troubleshooting inquiries:

Here's how we can structure this using PipelinePromptTemplate:

Greeting prompt: This prompt template defines a friendly greeting and a general offer of assistance. For example, we can have a template that says, "Good morning! How can I assist you today?"
Closing prompt: Similarly, this prompt template encapsulates a polite closing message. It can be something like, "If you have any other questions, feel free to ask. Have a great day!"
Product information prompt: This prompt focuses on providing information about products. It doesn't include a greeting or closing because those will be added from the other prompts. An example can be, "You're interested in learning more about our products. Here are the details about our latest product [product]."
Troubleshooting prompt: This one is dedicated to helping users with product issues. This also doesn't include a greeting or closing. It might read, "It seems you're having trouble with [product]. Let me guide you through some steps to resolve this. [troubleshooting steps]."

With these components defined, we can use a PipelinePromptTemplate to assemble the full prompts dynamically. The pipeline would first insert the greeting, followed by either the product information or troubleshooting content, and conclude with the closing. This approach ensures consistency across all interactions and simplifies prompt maintenance.

Here's a simplified code illustration of how this might look:

from langchain.prompts import PipelinePromptTemplate, PromptTemplate
# Define the component prompts
greeting_prompt = PromptTemplate.from_template("Good morning! How can I assist you today?")
closing_prompt = PromptTemplate.from_template("If you have any other questions, feel free to ask. Have a great day!")
product_info_prompt = PromptTemplate.from_template("You're interested in learning more about our products. Here are the details about our latest product {product}.")
troubleshooting_prompt = PromptTemplate.from_template("It seems you're having trouble with {product}. Let me guide you through some steps to resolve this.")
full_template = """{greeting}
{content}
{closing}"""
full_prompt = PromptTemplate.from_template(full_template)
# Assemble the pipeline prompts
pipeline_prompts = [
    ("greeting", greeting_prompt),
    ("content", product_info_prompt),  # This can be replaced with troubleshooting_prompt as needed
    ("closing", closing_prompt),
]
# Create the PipelinePromptTemplate
pipeline_prompt = PipelinePromptTemplate(
    final_prompt=full_prompt, pipeline_prompts=pipeline_prompts
)
# Example usage for product information
full_prompt = pipeline_prompt.format(product="Educative Bot")
print(full_prompt)
# Assemble the pipeline prompts for troubleshooting prompt
pipeline_prompts = [
    ("greeting", greeting_prompt),
    ("trouble", troubleshooting_prompt),  # This can be replaced with content_prompt as needed
    ("closing", closing_prompt),
]
troubleshoot_template = """{greeting}
{trouble}
{closing}"""
full_prompt = PromptTemplate.from_template(troubleshoot_template)
pipeline_prompt = PipelinePromptTemplate(
    final_prompt=full_prompt, pipeline_prompts=pipeline_prompts
)
full_prompt = pipeline_prompt.format(product="Educative Bot")
print(full_prompt)

Line 1: We import the necessary classes from LangChain, PipelinePromptTemplate for creating a pipeline of prompt templates and PromptTemplate for defining individual prompt templates.

Lines 4–7: We define prompt templates for four different messages.

Note: Lines 6–7 set up a prompt template for providing information about a specific product. They use a placeholder {product} that can be dynamically replaced with actual product information. However that's not part of the scope of this answer.

Lines 9–15: We define the full_template template, which will act as the final prompt of our pipeline.

Lines 18–22: We define a list of pipeline prompts. Each entry is a tuple with a name (greeting, content, closing) and the corresponding prompt template. The content part is currently set to product_info_prompt, but it can be swapped out for troubleshooting_prompt depending on the context.

Lines 30–31: The format() method of pipeline_prompt generates a complete prompt. It replaces the {product} placeholder in product_info_prompt with "Educative Bot". Then, we print the fully assembled prompt to the console.

Note: We repeat the process on lines 34–53 for the troubleshooting prompt.

By leveraging a PipelinePromptTemplate, we gain the flexibility to craft complex, multipart prompts with ease. This modular approach not only reduces redundancy and the risk of errors but also enables us to create more personalized and engaging user interactions.

Try it yourself

Explore the Jupyter Notebook below to see LangChain's PipelinePromptTemplate mechanisms in action and discover how they can transform conversational AI applications yourself.