Prompts for Chat Models in LangChain

https://python.langchain.com.cn/docs/modules/model_io/models/chat/how_to/prompts

Prompts for Chat Models in LangChain

This content is based on LangChain’s official documentation (langchain.com.cn) and explains prompts for chat models—which are built around messages (not just plain text)—in simplified terms. It strictly preserves all original source codes, examples, and knowledge points without any additions or modifications.

1. Key Feature of Chat Model Prompts

Prompts for chat models are structured around messages (e.g., system messages, human messages, AI messages) rather than single blocks of text.

• Use MessagePromptTemplate (and its subclasses like SystemMessagePromptTemplate, HumanMessagePromptTemplate) to create reusable message templates.
• Combine multiple MessagePromptTemplates into a ChatPromptTemplate.
• Use ChatPromptTemplate.format_prompt() to generate a PromptValue, which can be converted to a string or message objects (for chat models).

2. Step 1: Import Required Modules

The code below imports all necessary classes—exactly as in the original documentation:

from langchain import PromptTemplate
from langchain.prompts.chat import (
    ChatPromptTemplate,
    SystemMessagePromptTemplate,
    AIMessagePromptTemplate,
    HumanMessagePromptTemplate,
)

Note: A chat model (e.g., ChatOpenAI) is required to run the final step, but it is not imported in the original documentation—we will reference it as chat (consistent with the original code).

3. Method 1: Create Message Templates with from_template

This is a concise way to build MessagePromptTemplates directly from template strings.

Step 3.1: Create System and Human Message Templates

# System message template: Defines the assistant's role (translator)
template = "You are a helpful assistant that translates {input_language} to {output_language}."
system_message_prompt = SystemMessagePromptTemplate.from_template(template)

# Human message template: Defines the user's input (text to translate)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

Step 3.2: Combine into ChatPromptTemplate

chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])

Step 3.3: Format and Run the Prompt

Use format_prompt() to fill in the placeholders, convert to messages, and pass to the chat model. The original code and output are preserved exactly:

# Get formatted messages and pass to the chat model
chat(chat_prompt.format_prompt(
    input_language="English", 
    output_language="French", 
    text="I love programming."
).to_messages())

Output (exact as original):

AIMessage(content="J'adore la programmation.", additional_kwargs={})

4. Method 2: Create Message Templates with External PromptTemplate

For more flexibility, you can first define a PromptTemplate and then pass it to SystemMessagePromptTemplate.

Step 4.1: Create an External PromptTemplate

prompt = PromptTemplate(
    template="You are a helpful assistant that translates {input_language} to {output_language}.",
    input_variables=["input_language", "output_language"],  # Explicitly list variables
)

Step 4.2: Wrap into SystemMessagePromptTemplate

system_message_prompt = SystemMessagePromptTemplate(prompt=prompt)

Note: You can combine this system message prompt with the same human_message_prompt (from Method 1) into a ChatPromptTemplate and run it—same as Step 3.2 and 3.3.

Key Takeaways

• Chat model prompts are built with message templates (e.g., SystemMessagePromptTemplate).
• Two ways to create message templates: from_template (concise) or external PromptTemplate (flexible).
• ChatPromptTemplate.from_messages() combines multiple message templates.
• format_prompt().to_messages() converts the template to chat-model-compatible messages.