LangChain’s PromptTemplate isn’t just about filling in blanks; it’s about orchestrating the precise information flow that a language model needs to perform a task.
Let’s see it in action. Imagine we want to build a simple customer service bot that can answer questions about our fictional "Acme Corp" products.
from langchain_core.prompts import PromptTemplate
# Define the template
template = """You are a helpful assistant for Acme Corp.
Answer the following question based on the context provided.
Context:
{context}
Question:
{question}
Answer:"""
# Create the prompt template instance
prompt_template = PromptTemplate(
input_variables=["context", "question"],
template=template
)
# Example usage
context_data = "Acme Corp's flagship product, the Widget 5000, is known for its durability and ease of use. It costs $99.99."
user_question = "What are the key features of the Widget 5000?"
# Format the prompt
formatted_prompt = prompt_template.format(
context=context_data,
question=user_question
)
print(formatted_prompt)
This code will output:
You are a helpful assistant for Acme Corp.
Answer the following question based on the context provided.
Context:
Acme Corp's flagship product, the Widget 5000, is known for its durability and ease of use. It costs $99.99.
Question:
What are the key features of the Widget 5000?
Answer:
The core problem PromptTemplate solves is the brittle nature of hardcoded prompts. As your application grows, you’ll need to dynamically inject different pieces of information – user queries, retrieved documents, system instructions, specific examples – into your prompts. Doing this manually, with string concatenation or f-strings, quickly becomes unmanageable and error-prone, especially when dealing with complex structures or multiple dynamic variables. PromptTemplate provides a structured, declarative way to define these prompts, separating the static prompt text from the dynamic inputs.
Internally, PromptTemplate parses your template string, identifying placeholders enclosed in curly braces {}. These placeholders are registered as input_variables. When you call the .format() method, LangChain iterates through the provided keyword arguments, matching them to the input_variables, and substitutes the values into the template. This ensures that each variable is placed exactly where you intend it to be, maintaining the integrity of your prompt’s structure and instructions. You have precise control over the order and placement of these variables, which is critical for guiding the LLM’s response.
The input_variables list is not just for defining what goes into the prompt; it’s also the contract for how you use the template. If you define input_variables=["user_input", "system_message"], you must provide values for both user_input and system_message when calling .format(). If you forget one, or try to pass a variable not listed, LangChain will raise an error, preventing malformed prompts from ever reaching the LLM. This strictness is a feature, not a bug, as it enforces consistency.
Most users think of input_variables as simply the things they want to inject. However, the order in which you list input_variables in the PromptTemplate constructor directly influences the order in which LangChain expects them in the .format() method if you were to call .format() without keyword arguments (though using keyword arguments is generally preferred for clarity). More importantly, the order of variables within the template string itself is paramount. If your template expects context before a question, ensure {context} appears before {question}. This sequential dependency is how you guide the LLM’s processing; it reads and processes information in the order presented.
The next challenge is handling variable types and ensuring data is correctly formatted before injection.