0
# Prompt Templates
1

2
Template system for creating dynamic prompts with variable substitution and formatting. Prompt templates enable reusable and parameterized prompt construction.
3

4
## Capabilities
5

6
### Base Prompt Template
7

8
Abstract base class for all prompt templates.
9

10
```typescript { .api }
11
/**
12
 * Abstract base class for prompt templates
13
 * @template RunInput - Input values type
14
 * @template RunOutput - Prompt value output type
15
 */
16
abstract class BasePromptTemplate<RunInput extends InputValues = InputValues, RunOutput extends PromptValue = PromptValue> extends Runnable<RunInput, RunOutput> {
17
  /** Input variables required by this template */
18
  inputVariables: string[];
19
  /** Optional variables that can be used */
20
  optionalVariables?: string[];
21
  /** Output parser for post-processing */
22
  outputParser?: BaseOutputParser;
23
  /** Additional template data */
24
  templateFormat?: string;
25
  /** Partial variables with pre-filled values */
26
  partialVariables?: Record<string, unknown>;
27
  
28
  constructor(input: BasePromptTemplateInput);
29
  
30
  /** Format template to string */
31
  abstract format(values: InputValues): Promise<string>;
32
  
33
  /** Format template to PromptValue */
34
  abstract formatPromptValue(values: InputValues): Promise<RunOutput>;
35
  
36
  /** Create template with partial variables */
37
  partial(values: Record<string, unknown>): Promise<BasePromptTemplate<RunInput, RunOutput>>;
38
  
39
  /** Merge with another template */
40
  pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): Runnable<RunInput, NewRunOutput>;
41
}
42
```
43

44
### String Prompt Template
45

46
Template for generating string prompts.
47

48
```typescript { .api }
49
/**
50
 * Template for string-based prompts
51
 */
52
class PromptTemplate extends BasePromptTemplate<InputValues, StringPromptValue> {
53
  /** Template string with variable placeholders */
54
  template: string;
55
  /** Format for template variables (f-string, mustache, etc.) */
56
  templateFormat: TemplateFormat;
57
  /** Function to validate input variables */
58
  validateTemplate?: boolean;
59
  
60
  constructor(input: PromptTemplateInput);
61
  
62
  /** Format template with input values */
63
  async format(values: InputValues): Promise<string>;
64
  
65
  /** Format to PromptValue object */
66
  async formatPromptValue(values: InputValues): Promise<StringPromptValue>;
67
  
68
  /** Create template from string */
69
  static fromTemplate(template: string, options?: Partial<PromptTemplateInput>): PromptTemplate;
70
  
71
  /** Create from examples */
72
  static fromExamples(examples: string[], suffix: string, inputVariables: string[], options?: Partial<PromptTemplateInput>): PromptTemplate;
73
}
74
```
75

76
**Usage Examples:**
77

78
```typescript
79
import { PromptTemplate } from "@langchain/core/prompts";
80

81
// Simple template
82
const template = PromptTemplate.fromTemplate(
83
  "What is a good name for a company that makes {product}?"
84
);
85

86
const prompt = await template.format({ product: "colorful socks" });
87
console.log(prompt); // "What is a good name for a company that makes colorful socks?"
88

89
// Template with multiple variables
90
const complexTemplate = PromptTemplate.fromTemplate(`
91
You are a {role} helping a user with {task}.
92
The user's experience level is {experience_level}.
93
Please provide {response_type} advice.
94

95
User question: {question}
96
`);
97

98
const complexPrompt = await complexTemplate.format({
99
  role: "senior developer",
100
  task: "debugging JavaScript",
101
  experience_level: "beginner",
102
  response_type: "step-by-step",
103
  question: "Why is my variable undefined?"
104
});
105
```
106

107
### Chat Prompt Template
108

109
Template for generating chat message sequences.
110

111
```typescript { .api }
112
/**
113
 * Template for chat message sequences
114
 */
115
class ChatPromptTemplate extends BasePromptTemplate<InputValues, ChatPromptValue> {
116
  /** Array of message templates */
117
  promptMessages: BaseMessagePromptTemplate[];
118
  /** Whether to validate template variables */
119
  validateTemplate?: boolean;
120
  
121
  constructor(input: ChatPromptTemplateInput);
122
  
123
  /** Format to chat messages */
124
  async formatMessages(values: InputValues): Promise<BaseMessage[]>;
125
  
126
  /** Format to PromptValue */
127
  async formatPromptValue(values: InputValues): Promise<ChatPromptValue>;
128
  
129
  /** Format to string representation */
130
  async format(values: InputValues): Promise<string>;
131
  
132
  /** Create from array of message templates */
133
  static fromMessages(promptMessages: (BaseMessagePromptTemplate | BaseMessageLike)[]): ChatPromptTemplate;
134
  
135
  /** Create from template string */
136
  static fromTemplate(template: string, options?: Partial<ChatPromptTemplateInput>): ChatPromptTemplate;
137
}
138
```
139

140
**Usage Examples:**
141

142
```typescript
143
import { ChatPromptTemplate, HumanMessagePromptTemplate, SystemMessagePromptTemplate } from "@langchain/core/prompts";
144

145
// From template string
146
const chatTemplate = ChatPromptTemplate.fromTemplate(
147
  "You are a helpful assistant. Help the user with: {task}"
148
);
149

150
// From message templates  
151
const complexChatTemplate = ChatPromptTemplate.fromMessages([
152
  SystemMessagePromptTemplate.fromTemplate("You are a {role}"),
153
  HumanMessagePromptTemplate.fromTemplate("Help me with {request}"),
154
  ["ai", "I'll help you with {request}. What specifically do you need?"],
155
  ["human", "{followup_question}"]
156
]);
157

158
const messages = await complexChatTemplate.formatMessages({
159
  role: "helpful assistant",
160
  request: "writing code",
161
  followup_question: "How do I handle errors?"
162
});
163
```
164

165
### Message Prompt Templates
166

167
Templates for specific message types.
168

169
```typescript { .api }
170
/**
171
 * Template for human messages
172
 */
173
class HumanMessagePromptTemplate extends BaseMessagePromptTemplate {
174
  static fromTemplate(template: string, options?: Partial<PromptTemplateInput>): HumanMessagePromptTemplate;
175
}
176

177
/**
178
 * Template for AI messages  
179
 */
180
class AIMessagePromptTemplate extends BaseMessagePromptTemplate {
181
  static fromTemplate(template: string, options?: Partial<PromptTemplateInput>): AIMessagePromptTemplate;
182
}
183

184
/**
185
 * Template for system messages
186
 */
187
class SystemMessagePromptTemplate extends BaseMessagePromptTemplate {
188
  static fromTemplate(template: string, options?: Partial<PromptTemplateInput>): SystemMessagePromptTemplate;
189
}
190
```
191

192
### Few-Shot Prompt Template
193

194
Template for few-shot learning with examples.
195

196
```typescript { .api }
197
/**
198
 * Template with examples for few-shot learning
199
 */
200
class FewShotPromptTemplate extends BasePromptTemplate {
201
  /** Array of example objects */
202
  examples: Record<string, string>[];
203
  /** Template for each example */
204
  examplePrompt: PromptTemplate;
205
  /** Separator between examples */
206
  exampleSeparator: string;
207
  /** Prefix before examples */
208
  prefix?: string;
209
  /** Suffix after examples */
210
  suffix?: string;
211
  /** Example selector for dynamic selection */
212
  exampleSelector?: BaseExampleSelector;
213
  
214
  constructor(input: FewShotPromptTemplateInput);
215
}
216
```
217

218
**Usage Examples:**
219

220
```typescript
221
import { FewShotPromptTemplate, PromptTemplate } from "@langchain/core/prompts";
222

223
const examplePrompt = PromptTemplate.fromTemplate(
224
  "Input: {input}\nOutput: {output}"
225
);
226

227
const fewShotTemplate = new FewShotPromptTemplate({
228
  examples: [
229
    { input: "happy", output: "sad" },
230
    { input: "tall", output: "short" },
231
    { input: "hot", output: "cold" }
232
  ],
233
  examplePrompt,
234
  suffix: "Input: {word}\nOutput:",
235
  inputVariables: ["word"]
236
});
237

238
const prompt = await fewShotTemplate.format({ word: "big" });
239
// Returns formatted examples + "Input: big\nOutput:"
240
```
241

242
## Prompt Values
243

244
### Prompt Value Types
245

246
```typescript { .api }
247
/**
248
 * Base class for prompt values
249
 */
250
abstract class BasePromptValue {
251
  /** Convert to string representation */
252
  abstract toString(): string;
253
  
254
  /** Convert to chat messages */
255
  abstract toChatMessages(): BaseMessage[];
256
}
257

258
/**
259
 * String-based prompt value
260
 */
261
class StringPromptValue extends BasePromptValue {
262
  value: string;
263
  
264
  constructor(value: string);
265
  toString(): string;
266
  toChatMessages(): BaseMessage[];
267
}
268

269
/**
270
 * Chat message sequence prompt value
271
 */
272
class ChatPromptValue extends BasePromptValue {
273
  messages: BaseMessage[];
274
  
275
  constructor(messages: BaseMessage[]);
276
  toString(): string;
277
  toChatMessages(): BaseMessage[];
278
}
279
```
280

281
## Types
282

283
```typescript { .api }
284
interface InputValues {
285
  [key: string]: unknown;
286
}
287

288
type TemplateFormat = "f-string" | "mustache" | "jinja2";
289

290
interface BasePromptTemplateInput {
291
  inputVariables: string[];
292
  optionalVariables?: string[];
293
  partialVariables?: Record<string, unknown>;
294
  outputParser?: BaseOutputParser;
295
}
296

297
interface PromptTemplateInput extends BasePromptTemplateInput {
298
  template: string;
299
  templateFormat?: TemplateFormat;
300
  validateTemplate?: boolean;
301
}
302

303
interface ChatPromptTemplateInput extends BasePromptTemplateInput {
304
  promptMessages: BaseMessagePromptTemplate[];
305
  validateTemplate?: boolean;
306
}
307

308
interface FewShotPromptTemplateInput extends BasePromptTemplateInput {
309
  examples: Record<string, string>[];
310
  examplePrompt: PromptTemplate;
311
  exampleSeparator?: string;
312
  prefix?: string;
313
  suffix?: string;
314
  exampleSelector?: BaseExampleSelector;
315
}
316

317
type BaseMessageLike = BaseMessage | string | [string, string];
318
```