Prompt Composition with LangChain’s PipelinePromptTemplate

https://python.langchain.com.cn/docs/modules/model_io/prompts/prompt_templates/prompt_composition

Learning Guide: Prompt Composition with LangChain’s PipelinePromptTemplate

This guide simplifies how to combine multiple prompts for reuse (using LangChain’s PipelinePromptTemplate), while keeping all original code, examples, and key points exactly as they appear in the link.

1. What is PipelinePromptTemplate?

It’s a LangChain tool to reuse parts of prompts. It has two key parts:

• Final Prompt: The last, complete prompt you get after combining all parts. It uses placeholders (like {introduction}, {example}) to “hold space” for other small prompts.
• Pipeline Prompts: A list of “name + small prompt” pairs. Each small prompt is formatted first, then put into the final prompt using its name (to match the placeholder).

2. Step-by-Step Code (Exact as Original)

We’ll follow the original code step by step. Each code block is unchanged, and we’ll explain what it does simply.

Step 1: Import Needed Tools

First, we get the two tools we need from LangChain:

from langchain.prompts.pipeline import PipelinePromptTemplate
from langchain.prompts.prompt import PromptTemplate

• PipelinePromptTemplate: Helps combine multiple prompts.
• PromptTemplate: Makes single, reusable prompt templates.

Step 2: Make the Final Prompt Template

This is the “big” prompt that will hold all the small parts. It uses 3 placeholders:

full_template = """{introduction}
{example}
{start}"""
full_prompt = PromptTemplate.from_template(full_template)

• full_template: The structure of the final prompt (with placeholders).
• PromptTemplate.from_template(): Turns the text structure into a LangChain “prompt object” (so we can use it later).

Step 3: Make Small Reusable Prompts

We create 3 small prompts (each is a reusable part). Each has its own variables:

1. Introduction Prompt (sets who to impersonate)

introduction_template = """You are impersonating {person}."""
introduction_prompt = PromptTemplate.from_template(introduction_template)

• Uses {person}: We’ll fill this in later (e.g., “Elon Musk”).

2. Example Prompt (gives a sample interaction)

example_template = """Here's an example of an interaction:
Q: {example_q}
A: {example_a}"""
example_prompt = PromptTemplate.from_template(example_template)

• Uses {example_q} (sample question) and {example_a} (sample answer).

3. Start Prompt (asks for a real response)

start_template = """Now, do this for real!
Q: {input}
A:"""
start_prompt = PromptTemplate.from_template(start_template)

• Uses {input}: The real question we want to ask later.

Step 4: Link Small Prompts to the Final Prompt

We make a list to connect each small prompt to its placeholder in the final prompt:

input_prompts = [("introduction", introduction_prompt),  # "introduction" → matches {introduction}("example", example_prompt),            # "example" → matches {example}("start", start_prompt)                 # "start" → matches {start}
]

Step 5: Create the PipelinePromptTemplate

We put the final prompt and the small prompt list together:

pipeline_prompt = PipelinePromptTemplate(final_prompt=full_prompt, pipeline_prompts=input_prompts)

Step 6: Check Required Variables

To use the pipeline, we need to know all variables we must fill in. The original code shows these variables:

pipeline_prompt.input_variables
# Output: ['example_a', 'person', 'example_q', 'input']

• These come from the small prompts: person (from introduction), example_q/example_a (from example), input (from start).

3. Generate the Final Prompt

We fill in all required variables and print the result. The code and output are exactly as in the original:

Code to Format the Prompt

print(pipeline_prompt.format(person="Elon Musk",example_q="What's your favorite car?",example_a="Telsa",input="What's your favorite social media site?"
))

Final Output

You are impersonating Elon Musk.Here's an example of an interaction: Q: What's your favorite car?A: TelsaNow, do this for real!Q: What's your favorite social media site?A:

Key Takeaway (No Extra Info)

PipelinePromptTemplate helps you reuse prompt parts (like the “impersonate” or “example” sections) so you don’t rewrite code. All parts combine to make one final prompt, and you only need to fill in the required variables.