2. Chat Prompt Template

Define structured message prompts using ChatPromptTemplate and class constructors

In this section, you will learn how to define structured message-based prompts using ChatPromptTemplate and send them to Chat Models.

Objectives

1. Construct a structured prompt template using the helper classmethod .from_messages() with Tuples.
2. Construct a prompt template using the direct class constructor ChatPromptTemplate(...).
3. Format templates into messages, invoke models, and display responses.
4. Understand when to use .from_messages() versus the direct constructor, and string templates versus chat templates.

---

Code Implementation

Each step of the implementation is preceded by extensive comments explaining the code logic.

Method 1: Construction via .from_messages() with Tuples

This is the most common method. You pass a list of ("role", "template_string") tuples, and LangChain automatically parses roles and placeholder values.

# Import environmental loader from dotenv
from dotenv import load_dotenv

# Import prompt templates and model initialization helpers
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import init_chat_model

# Load keys and environment settings from local .env
load_dotenv()

# Initialize the Groq model using core abstractions
model = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")

# Define system behavior and human instructions using tuples
messages_tuples = [
    ("system", "You are a comedian who tells jokes about {topic}."),
    ("human", "Tell me {joke_count} jokes."),
]

# Instantiate the chat template using the helper classmethod
chat_prompt_template = ChatPromptTemplate.from_messages(messages_tuples)

print("----- Method 1: .from_messages() with Tuples -----")

# Format the chat template by invoking it with specific values
formatted_prompt = chat_prompt_template.invoke({"topic": "lawyers", "joke_count": 3})

# Invoke the model passing the formatted prompt values
result = model.invoke(formatted_prompt)

# Print the textual content returned by the LLM
print("Model Response:")
print(result.content)

---

Method 2: Construction via Direct Class Constructor

You can initialize ChatPromptTemplate directly by passing a list of message objects or message template objects using the messages parameter in the constructor.

# Import environmental loader from dotenv
from dotenv import load_dotenv

# Import prompt templates, message classes, and model initialization helpers
from langchain.prompts import ChatPromptTemplate
from langchain_core.messages import SystemMessage, HumanMessage
from langchain.chat_models import init_chat_model

# Load keys and environment settings from local .env
load_dotenv()

# Initialize the Groq model using core abstractions
model = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")

# Instantiate the class constructor directly with static message wrappers
# Note: Since these messages are static classes, we do not define dynamic string templates here
chat_prompt_direct = ChatPromptTemplate(
    messages=[
        SystemMessage(content="You are a polite receptionist."),
        HumanMessage(content="Hello, is anyone there?")
    ]
)

print("\n----- Method 2: Direct Class Instantiation -----")

# Invoke the directly instantiated template
formatted_prompt_direct = chat_prompt_direct.invoke({})

# Invoke the model passing the formatted prompt values
result = model.invoke(formatted_prompt_direct)

# Print the model response content
print("Model Response:")
print(result.content)

---

Caveat: Mixing Message Objects and Placeholders

When defining templates, you must format variables dynamically using tuples. If you pass an instantiated Message class (like HumanMessage) with placeholder variables in its string content, LangChain’s formatter will fail to detect and inject the variables.

1. Instantiating a Message without dynamic placeholders (Works)

from langchain.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage

# System role uses a tuple with a placeholder; HumanMessage is static
messages = [
    ("system", "You are a comedian who tells jokes about {topic}."),
    HumanMessage(content="Tell me 3 jokes."),
]

# Create template
prompt_template = ChatPromptTemplate.from_messages(messages)

# Invoke with only the topic variable (since joke_count is hardcoded in HumanMessage)
prompt = prompt_template.invoke({"topic": "lawyers"})
print("\n----- Hardcoded Message Instance (Works) -----")
print(prompt)

2. Placing placeholders inside Message classes (Fails)

from langchain.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage

# Attempting to define a placeholder within an instantiated HumanMessage class
messages = [
    ("system", "You are a comedian who tells jokes about {topic}."),
    HumanMessage(content="Tell me {joke_count} jokes."),
]

# Instantiate template
prompt_template = ChatPromptTemplate.from_messages(messages)

# This invocation will catch an error since the HumanMessage content is not parsed at runtime
try:
    prompt = prompt_template.invoke({"topic": "lawyers", "joke_count": 3})
except Exception as e:
    print("\n----- Dynamic Message Instance (Expected Failure) -----")
    print(f"Caught Expected Error: {e}")

[!WARNING] Always use the tuple format ("role", "template string") when you want placeholders to be dynamically populated at runtime inside a chat prompt template.

---

When to Use What

1. .from_messages() vs. Direct Constructor

• .from_messages(): Best when you want to quickly build a dynamic sequence of messages (such as system instructions combined with user input) using the simplified ("role", "template") tuple structure.
• Direct Class Constructor (ChatPromptTemplate(messages=[...])): Best when you already have pre-constructed message templates or message objects (e.g., loading them from a database or memory log) and need to pass them directly.

2. PromptTemplate vs. ChatPromptTemplate

• PromptTemplate: Use when working with completion-style language models that accept a single plain string as input.
• ChatPromptTemplate: Use when building applications for Chat Models (like ChatGPT, Claude, or Gemini) which expect structured lists of conversation messages representing different participant roles.

3. ChatPromptTemplate.from_template() vs ChatPromptTemplate.from_messages()

ChatPromptTemplate.from_template() is a convenient shortcut for creating a chat prompt with a single human message, while ChatPromptTemplate.from_messages() is used when you need multiple messages or different message roles such as system, human, and ai.

Method	Use
from_template()	One human message; simple prompts
from_messages()	Multiple messages; supports different roles

from langchain_core.prompts import ChatPromptTemplate

# from_template()
prompt = ChatPromptTemplate.from_template(
    "Explain {topic} in simple terms."
)

# Equivalent to:
prompt = ChatPromptTemplate.from_messages([
    ("human", "Explain {topic} in simple terms.")
])

# from_messages()
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an expert Python teacher."),
    ("human", "Explain {topic} in simple terms.")
])

---

Practice & Exercises

To practice feeding prompt templates into chat models, open the interactive notebook:

Practice & Exercises

Practice formatting dynamic chat messages, using message list wrappers, and invoking models.

💻 VS Code | 🚀 Colab | 📥 Download