Context formatting and injection in LangChain - Step-by-Step Execution

Concept Flow - Context formatting and injection

Start with raw context data

↓

Format context into template

↓

Inject formatted context into prompt

↓

Send prompt to language model

↓

Receive and process model output

This flow shows how raw context is first formatted into a template, then injected into a prompt before sending to the language model.

Execution Sample

LangChain

from langchain.prompts import PromptTemplate

context = "The sky is blue."
template = "Context: {context}\nQuestion: What color is the sky?"
prompt = PromptTemplate(input_variables=["context"], template=template)
formatted_prompt = prompt.format(context=context)

This code formats a context string into a prompt template by injecting the context into the placeholder.

Execution Table

Step	Action	Input	Output	Notes
1	Receive raw context	"The sky is blue."	"The sky is blue."	Raw context string stored
2	Define template	"Context: {context}\nQuestion: What color is the sky?"	Template with placeholder	Template ready for formatting
3	Create PromptTemplate	input_variables=["context"], template=template	PromptTemplate object	Setup for formatting
4	Format prompt	context="The sky is blue."	"Context: The sky is blue.\nQuestion: What color is the sky?"	Context injected into template
5	Send prompt to model	Formatted prompt string	Model output (e.g. "The sky is blue.")	Model processes prompt
6	Process output	Model output	Final answer	Use output as needed
7	End			Execution complete

💡 All steps complete; prompt formatted and sent to model, output processed.

Variable Tracker

Variable	Start	After Step 1	After Step 4	Final
context	None	"The sky is blue."	"The sky is blue."	"The sky is blue."
template	None	None	"Context: {context}\nQuestion: What color is the sky?"	"Context: {context}\nQuestion: What color is the sky?"
formatted_prompt	None	None	"Context: The sky is blue.\nQuestion: What color is the sky?"	"Context: The sky is blue.\nQuestion: What color is the sky?"

Key Moments - 2 Insights

Why do we need to format the context before sending it to the model?

Because the model expects a complete prompt string. Formatting injects the context into the template to create that prompt, as shown in step 4 of the execution_table.

What happens if the context variable is missing when formatting?

The formatting will fail or produce an incomplete prompt because the placeholder {context} has no value, as seen in step 4 where context is required.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output after step 4?

A "Context: The sky is blue.\nQuestion: What color is the sky?"

B "The sky is blue."

C PromptTemplate object

D Model output

💡 Hint

Check the 'Output' column for step 4 in the execution_table.

At which step is the context injected into the template?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the step where formatting happens in the execution_table.

If the context changes to "Grass is green.", which variable changes in variable_tracker?

A template

B formatted_prompt

C Both B and D

D context

💡 Hint

See how context and formatted_prompt depend on the context variable in variable_tracker.

Concept Snapshot

Context formatting and injection:
- Define a template with placeholders like {context}
- Use PromptTemplate to prepare formatting
- Inject actual context into template with format()
- Send formatted prompt to language model
- Receive and use model output
Key: context must be provided to fill placeholders

Full Transcript

This visual execution shows how context formatting and injection works in Langchain. First, raw context data is received. Then a template string with placeholders is defined. A PromptTemplate object is created with the template and input variables. Next, the context is injected into the template using the format method, producing a complete prompt string. This prompt is sent to the language model, which returns an output. Finally, the output is processed for use. Variables like context, template, and formatted_prompt change values as the steps progress. Key points include the necessity of formatting before sending to the model and ensuring all placeholders have values to avoid errors.

Practice

1. What is the main purpose of context formatting in Langchain?

easy

A. To create database connections

B. To execute code asynchronously

C. To prepare prompts with placeholders for dynamic data

D. To store user credentials securely

Solution

1. Step 1: Understand context formatting

   Context formatting is about creating prompt templates with placeholders that can be filled later.

2. Step 2: Identify the purpose

   This allows dynamic injection of data into prompts, making AI responses relevant.

3. Final Answer:

   To prepare prompts with placeholders for dynamic data -> Option C

4. Quick Check:

   Context formatting = placeholders in prompts [OK]

Hint: Think of placeholders as empty boxes to fill later [OK]

Common Mistakes:

• Confusing context formatting with code execution
• Thinking it stores credentials
• Mixing it with database operations

2. Which of the following is the correct way to inject a variable user_name into a Langchain prompt template?

easy

A. prompt_template.inject(user_name)

B. prompt_template.append(user_name)

C. prompt_template.fill(user_name)

D. prompt_template.format(user_name=user_name)

Solution

1. Step 1: Recall Langchain prompt syntax

   Langchain uses the format() method to fill placeholders in prompt templates.

2. Step 2: Match method to injection

   Only format(user_name=user_name) correctly injects the variable into the placeholder.

3. Final Answer:

   prompt_template.format(user_name=user_name) -> Option D

4. Quick Check:

   Use format() to inject variables [OK]

Hint: Use .format() to fill placeholders in templates [OK]

Common Mistakes:

• Using non-existent methods like inject() or fill()
• Trying to append variables instead of formatting
• Forgetting to name the variable in format()

3. Given this code snippet:

template = "Hello, {name}! Today is {day}."
prompt = template.format(name="Alice", day="Monday")
print(prompt)

What will be the output?

medium

A. Hello, Alice! Today is Monday.

B. Hello, name! Today is day.

C. Hello, {name}! Today is {day}.

D. Error: Missing placeholders

Solution

1. Step 1: Understand the template string

   The template has placeholders {name} and {day} to be replaced by actual values.

2. Step 2: Apply the format method

   Calling format(name="Alice", day="Monday") replaces placeholders with given values.

3. Final Answer:

   Hello, Alice! Today is Monday. -> Option A

4. Quick Check:

   Placeholders replaced by values = output string [OK]

Hint: format() replaces placeholders with given values [OK]

Common Mistakes:

• Printing the template without formatting
• Confusing placeholder names with literal text
• Expecting an error when placeholders are correctly filled

4. Identify the error in this Langchain prompt injection code:

template = "Welcome, {user}!"
prompt = template.format(user)
print(prompt)

medium

A. Incorrect placeholder syntax in template

B. Missing variable name in format() call

C. Using print() instead of return

D. Template string should use double braces {{}}

Solution

1. Step 1: Check format() usage

   The format method requires named arguments matching placeholders or positional arguments in order.

2. Step 2: Identify missing variable name

   Here, format(user) passes a positional argument but the placeholder expects a named argument {user}.

3. Final Answer:

   Missing variable name in format() call -> Option B

4. Quick Check:

   Named placeholders need named arguments in format() [OK]

Hint: Match placeholder names with named format() arguments [OK]

Common Mistakes:

• Passing positional argument without naming it
• Thinking placeholder syntax is wrong
• Confusing print() with return statements

5. You want to create a prompt that greets a user and mentions their favorite color using Langchain. Which code correctly formats and injects the context for user_name = "Bob" and color = "blue"?

hard

A. template = "Hi {user_name}, your favorite color is {color}."
prompt = template.format(user_name=user_name, color=color)

B. template = "Hi {user}, your favorite color is {color}."
prompt = template.format(user_name=user_name, color=color)

C. template = "Hi {user_name}, your favorite color is {color}."
prompt = template.format(user=user_name, color=color)

D. template = "Hi {user_name}, your favorite color is {color}."
prompt = template.fill(user_name, color)

Solution

1. Step 1: Match placeholders with variable names

   The template uses placeholders {user_name} and {color}, so format() must use these exact names.

2. Step 2: Check format() arguments

   template = "Hi {user_name}, your favorite color is {color}." prompt = template.format(user_name=user_name, color=color) correctly passes named arguments matching placeholders: user_name=user_name, color=color.

3. Step 3: Eliminate incorrect options

   template = "Hi {user}, your favorite color is {color}." prompt = template.format(user_name=user_name, color=color) uses {user} placeholder mismatching the user_name= argument. template = "Hi {user_name}, your favorite color is {color}." prompt = template.format(user=user_name, color=color) mismatches placeholder and argument names. template = "Hi {user_name}, your favorite color is {color}." prompt = template.fill(user_name, color) uses non-existent fill() method.

4. Final Answer:

   template = "Hi {user_name}, your favorite color is {color}." prompt = template.format(user_name=user_name, color=color) -> Option A

5. Quick Check:

   Placeholder names must match format() argument names [OK]

Hint: Keep placeholder and format() argument names identical [OK]

Common Mistakes:

• Mismatching placeholder and argument names
• Using wrong method like fill()
• Ignoring placeholder names in template