1. Prompt Template

In this section, you will learn how to construct, format, and invoke plain string-based prompt templates using PromptTemplate.

The Prompt Template Workflow

Before looking at code, here are the main steps in the standard prompt interaction pipeline:

Creating the Template: Write a text prompt containing placeholder variables in curly braces {}.
- API: PromptTemplate.from_template() or PromptTemplate(input_variables=..., template=...)
- Ex:
  prompt_template = PromptTemplate.from_template("Tell me a joke about {topic}.")
Formatting the Template: Inject actual runtime user inputs into the template’s placeholder variables.
- API:
  - .format(**kwargs) - returns str
  - .invoke(dict) - returns PromptValue
- Ex:
  prompt_value = prompt_template.invoke({"topic": "cats"})
Passing to the LLM: Send the formatted prompt output to the Chat Model.
- API: model.invoke(prompt_value)
Processing the Result: Retrieve the generated response and extract the text content.
- API: result.content

Objectives

Define a string prompt template using the helper classmethod .from_template().
Construct a string prompt template using the direct class constructor PromptTemplate(...).
Format templates using .format() and .invoke().
Send formatted prompt inputs to Chat Models and display results.

Code Implementation

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

Method 1: Construction via `.from_template()`

This helper classmethod automatically infers the input variables from your template string based on curly braces {}. We then format it, send it to the model, and print the output.

# Import environmental loader from dotenv
from dotenv import load_dotenv

# Import prompt templates and model initialization helpers
from langchain.prompts import PromptTemplate
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 a simple prompt template string with a placeholder '{topic}'
template_str = "Tell me a joke about {topic}."

# Construct the template object using the helper classmethod
prompt_template = PromptTemplate.from_template(template_str)

print("----- Method 1: .from_template() -----")

# Format the template into a plain string using keyword arguments
formatted_str = prompt_template.format(topic="cats")
print("Formatted string:")
print(formatted_str)

# Invoke the template to get a PromptValue wrapper object
prompt_value = prompt_template.invoke({"topic": "cats"})

# Feed the formatted PromptValue directly to the Chat Model
result = model.invoke(prompt_value)

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

Method 2: Construction via Direct Class Constructor

You can also construct a template directly using the PromptTemplate class constructor. This requires you to explicitly specify the list of input_variables.

# Import environmental loader from dotenv
from dotenv import load_dotenv

# Import prompt templates and model initialization helpers
from langchain.prompts import PromptTemplate
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")

# Construct the template directly by invoking the constructor class
# and specifying the input variable list explicitly
prompt_template_direct = PromptTemplate(
    input_variables=["adjective", "animal"],
    template="Tell me a {adjective} story about a {animal}."
)

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

# Invoke the directly instantiated template with the values for its placeholders
prompt_value = prompt_template_direct.invoke({"adjective": "funny", "animal": "panda"})

# Feed the formatted prompt directly to the Chat Model
result = model.invoke(prompt_value)

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

When to Use What

Using `.from_template()`

Usage: PromptTemplate.from_template("text {var}")
Best For: Fast prototyping, interactive shells, and simpler templates.
Pros: Concise syntax; automatically parses and registers variable placeholders.
Cons: Offers less control; cannot pre-define or customize variable properties explicitly.

Using the Direct Class Constructor

Usage: PromptTemplate(input_variables=["var"], template="text {var}")
Best For: Production codebases and complex prompt workflows.
Pros: Explicit declaration of inputs; enables validation of variables at startup time.
Cons: Requires more lines of setup.

[!TIP] Use .from_template() for quick scripts and interactive testing. For stable, production-grade applications, use the direct class constructor PromptTemplate to explicitly declare variable requirements and enforce strict verification.

Practice & Exercises

To practice configuring and running basic string templates, open the interactive notebook:

Practice & Exercises

Practice formatting plain string prompt templates, adding placeholders, and feeding inputs to models.💻 VS Code | 🚀 Colab | 📥 Download

Introduction

Chat Models

Templates & Parsers

Chains

RAG

Tools and Agents

The Prompt Template Workflow

Objectives

Code Implementation

Method 1: Construction via `.from_template()`

Method 2: Construction via Direct Class Constructor

When to Use What

Using `.from_template()`

Using the Direct Class Constructor

Practice & Exercises

Practice & Exercises

​The Prompt Template Workflow

​Objectives

​Code Implementation

​Method 1: Construction via .from_template()

​Method 2: Construction via Direct Class Constructor

​When to Use What

​Using .from_template()

​Using the Direct Class Constructor

​Practice & Exercises

Practice & Exercises

The Prompt Template Workflow

Objectives

Code Implementation

Method 1: Construction via `.from_template()`

Method 2: Construction via Direct Class Constructor

When to Use What

Using `.from_template()`

Using the Direct Class Constructor

Practice & Exercises