Question reformulation with history in LangChain - Step-by-Step Execution

Concept Flow - Question reformulation with history

User asks new question

↓

Retrieve conversation history

↓

Combine history + new question

↓

Pass combined input to reformulation chain

↓

Generate reformulated question

↓

Return reformulated question for next processing

The system takes the new question and past conversation, combines them, then reformulates the question to include context.

Execution Sample

LangChain

from langchain.chains import ConversationChain
from langchain.llms import OpenAI

conversation = ConversationChain(llm=OpenAI())
response = conversation.predict(input="What is AI?")

This code uses LangChain's ConversationChain to reformulate a question considering conversation history.

Execution Table

Step	Action	Input	Output	Notes
1	User inputs new question	"What is AI?"	New question stored	Start of interaction
2	Retrieve conversation history	Previous Q&A (empty initially)	History retrieved	No prior history on first question
3	Combine history + new question	'' + 'What is AI?'	Combined input: 'What is AI?'	First question, so just the question
4	Pass to reformulation chain	Combined input	Reformulated question: 'What is AI?'	No change for first question
5	Return reformulated question	Reformulated question	Output ready for next step	Ready for answer generation
6	User inputs follow-up question	"How does it work?"	New question stored	Second question in conversation
7	Retrieve conversation history	Previous Q&A: 'What is AI?'	History retrieved	History now includes first question
8	Combine history + new question	'What is AI?' + 'How does it work?'	Combined input with context	Context added to new question
9	Pass to reformulation chain	Combined input	Reformulated question: 'How does AI work?'	Question reformulated with history
10	Return reformulated question	Reformulated question	Output ready for next step	Ready for answer generation

💡 Execution stops after reformulated question is returned for each user input.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
new_question	None	"What is AI?"	"How does it work?"	None	None	None
conversation_history	''	''	"What is AI?"	"What is AI?"	"What is AI? + How does it work?"	"What is AI? + How does it work?"
combined_input	''	"What is AI?"	"What is AI? + How does it work?"	"What is AI?"	"What is AI? + How does it work?"	"What is AI? + How does it work?"
reformulated_question	''	"What is AI?"	"How does AI work?"	"What is AI?"	"How does AI work?"	"How does AI work?"

Key Moments - 3 Insights

Why does the first question not change after reformulation?

Because there is no prior conversation history, the reformulation chain returns the question as is, as shown in execution_table step 4.

How does the conversation history affect the reformulated question?

The history is combined with the new question before reformulation, adding context so the chain can produce a clearer question, as seen in steps 8 and 9.

What happens if the history is empty or missing?

The combined input is just the new question, so reformulation does not add context, resulting in the original question returned, as in step 3.

Visual Quiz - 3 Questions

Look at the execution_table at step 9. What is the reformulated question?

A "How does it work?"

B "What is AI?"

C "How does AI work?"

D "What is AI? How does it work?"

💡 Hint

Check the 'Output' column at step 9 in the execution_table.

At which step does the system combine the conversation history with the new question for the second user input?

A Step 6

B Step 8

C Step 7

D Step 9

💡 Hint

Look for the step where 'Combine history + new question' happens for the second question.

If the conversation history was empty, how would the reformulated question at step 9 change?

A It would be the same as the new question 'How does it work?'

B It would be empty

C It would remain 'How does AI work?'

D It would combine both questions anyway

💡 Hint

Refer to the behavior at step 4 when history is empty.

Concept Snapshot

Question reformulation with history:
- Take new question + conversation history
- Combine them as input
- Pass to reformulation chain
- Get clearer question with context
- Use reformulated question for next steps
- First question returns as is (no history)

Full Transcript

This visual execution shows how LangChain reformulates a user's question by including conversation history. First, the user inputs a question. The system retrieves any past conversation history and combines it with the new question. This combined input is sent to the reformulation chain, which outputs a clearer, context-aware question. For the first question, with no history, the reformulated question is the same as the input. For follow-up questions, the history helps produce a better question. Variables like new_question, conversation_history, combined_input, and reformulated_question change step-by-step as shown. Key moments include understanding why the first question is unchanged and how history affects reformulation. The quiz tests understanding of these steps and outputs.