LangChain architecture overview - Step-by-Step Execution

Concept Flow - LangChain architecture overview

User Input

↓

Prompt Template

↓

Language Model (LLM)

↓

Chains

↓

Agents

↓

Memory

↓

Output Result

This flow shows how user input moves through prompt templates, language models, chains, agents, and memory to produce the final output.

Execution Sample

LangChain

from langchain import LLMChain, PromptTemplate, OpenAI

prompt = PromptTemplate(input_variables=["topic"], template="Write a summary about {topic}.")
llm = OpenAI()
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run({"topic": "LangChain architecture"})

This code creates a prompt template, connects it to an OpenAI language model, runs the chain with a topic, and gets a summary output.

Execution Table

Step	Component	Input	Action	Output
1	User Input	LangChain architecture	User provides topic	LangChain architecture
2	Prompt Template	LangChain architecture	Insert topic into template	Write a summary about LangChain architecture.
3	Language Model (LLM)	Write a summary about LangChain architecture.	Generate text based on prompt	LangChain is a framework to build apps with LLMs.
4	Chain	Generated text	Process output if needed	LangChain is a framework to build apps with LLMs.
5	Agent	Chain output	Decide next steps or tools	Decides no further action needed
6	Memory	Conversation context	Store or retrieve info	Stores topic and summary
7	Output Result	Final processed text	Return to user	LangChain is a framework to build apps with LLMs.

💡 Output returned to user after processing through all components.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 6	Final
user_input	None	LangChain architecture	LangChain architecture	LangChain architecture	LangChain architecture
prompt_text	None	Write a summary about LangChain architecture.	Write a summary about LangChain architecture.	Write a summary about LangChain architecture.	Write a summary about LangChain architecture.
llm_output	None	None	LangChain is a framework to build apps with LLMs.	LangChain is a framework to build apps with LLMs.	LangChain is a framework to build apps with LLMs.
memory_store	Empty	Empty	Empty	Stores topic and summary	Stores topic and summary

Key Moments - 3 Insights

Why does the prompt template need the user input before calling the language model?

The prompt template inserts the user input into a fixed sentence structure to create a clear instruction for the language model, as shown in step 2 of the execution_table.

What role does the agent play after the chain produces output?

The agent decides if more actions or tools are needed based on the chain output. In this example, it decides no further action is needed (step 5).

How does memory improve the interaction in LangChain?

Memory stores conversation context like the topic and summary so future interactions can remember past info, as shown in step 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output of the prompt template at step 2?

A LangChain architecture

B LangChain is a framework to build apps with LLMs.

C Write a summary about LangChain architecture.

D Stores topic and summary

💡 Hint

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

At which step does the language model generate text based on the prompt?

A Step 3

B Step 5

C Step 1

D Step 6

💡 Hint

Look for the step where 'Language Model (LLM)' is the component in the execution_table.

If the agent decided more actions were needed, which step would change in the execution_table?

A Step 4

B Step 5

C Step 6

D Step 7

💡 Hint

The agent's decision is shown at step 5 in the execution_table.

Concept Snapshot

LangChain architecture flows user input through prompt templates to create instructions.
The language model generates text based on these prompts.
Chains process outputs; agents decide next steps.
Memory stores context for ongoing conversations.
Final output is returned to the user.

Full Transcript

LangChain architecture starts with the user giving input, such as a topic. This input goes into a prompt template that creates a clear instruction sentence. The language model then reads this prompt and generates text based on it. Chains handle the output from the language model, possibly processing it further. Agents decide if more steps or tools are needed to complete the task. Memory keeps track of conversation context, like previous inputs and outputs, to make interactions smoother. Finally, the processed output is sent back to the user. This flow helps build applications that use language models effectively.

Practice

1. What is the main purpose of a chain in LangChain architecture?

easy

A. To link different steps like prompts and LLMs to build language apps

B. To store data permanently in a database

C. To create user interfaces for language models

D. To train new language models from scratch

Solution

1. Step 1: Understand the role of chains

   Chains connect parts like prompt templates and language models to form a workflow.

2. Step 2: Identify the main purpose

   Chains help organize and link these steps to build smart language apps easily.

3. Final Answer:

   To link different steps like prompts and LLMs to build language apps -> Option A

4. Quick Check:

   Chains link steps = D [OK]

Hint: Chains connect prompts and models to build apps [OK]

Common Mistakes:

• Thinking chains store data permanently
• Confusing chains with UI components
• Assuming chains train models

2. Which of the following is the correct way to create a prompt template in LangChain?

easy

A. PromptTemplate.create("Hello, {name}!")

B. PromptTemplate("Hello, {name}!")

C. PromptTemplate(template="Hello, {name}!")

D. PromptTemplate.new(template="Hello, {name}!")

Solution

1. Step 1: Recall PromptTemplate syntax

   PromptTemplate requires a named argument 'template' with the string pattern.

2. Step 2: Match syntax to options

   Only PromptTemplate(template="Hello, {name}!") uses PromptTemplate(template="...") correctly.

3. Final Answer:

   PromptTemplate(template="Hello, {name}!") -> Option C

4. Quick Check:

   Named 'template' argument = A [OK]

Hint: Use named 'template' argument to create PromptTemplate [OK]

Common Mistakes:

• Passing template string without argument name
• Using non-existent create() or new() methods
• Confusing positional and keyword arguments

3. Given this code snippet, what will be the output?

from langchain import PromptTemplate, LLMChain

prompt = PromptTemplate(template="What is the capital of {country}?")
chain = LLMChain(prompt=prompt)
result = chain.run(country="France")
print(result)

medium

A. "Paris"

B. An error because LLM is missing

C. "What is the capital of France?"

D. "France"

Solution

1. Step 1: Analyze the code components

   The chain is created with a prompt but no LLM (language model) is provided.

2. Step 2: Understand LangChain requirements

   LLMChain needs an LLM to generate answers; missing it causes an error.

3. Final Answer:

   An error because LLM is missing -> Option B

4. Quick Check:

   LLM missing causes error = B [OK]

Hint: LLMChain needs an LLM instance to run [OK]

Common Mistakes:

• Assuming chain.run returns prompt text
• Expecting output without LLM
• Confusing prompt template with output

4. Identify the error in this LangChain code snippet:

from langchain import PromptTemplate, LLMChain

prompt = PromptTemplate(template="Say hello to {name}")
chain = LLMChain(prompt=prompt, llm=None)
output = chain.run(name="Alice")
print(output)

medium

A. LLMChain requires a valid LLM, not None

B. PromptTemplate syntax is incorrect

C. run() method does not accept arguments

D. Missing import for LLM class

Solution

1. Step 1: Check PromptTemplate usage

   PromptTemplate is correctly created with a template string.

2. Step 2: Check LLMChain initialization

   LLMChain requires a valid LLM object; passing None causes failure.

3. Final Answer:

   LLMChain requires a valid LLM, not None -> Option A

4. Quick Check:

   LLM must be valid, not None = A [OK]

Hint: LLMChain needs a real LLM instance, not None [OK]

Common Mistakes:

• Thinking run() can't take arguments
• Assuming PromptTemplate syntax is wrong
• Missing imports but not causing this error

5. You want to build a LangChain app that asks a user's name, then uses an LLM to greet them. Which architecture correctly links these parts?

hard

A. Create a PromptTemplate and run it directly without an LLMChain

B. Create an LLMChain without a prompt and run it with user input

C. Create an LLM instance and call it directly without prompt or chain

D. Create a PromptTemplate for the question, then an LLMChain with that prompt and an LLM, then run the chain with user input

Solution

1. Step 1: Understand LangChain app structure

   PromptTemplate creates the question, LLMChain links prompt and LLM to generate answers.

2. Step 2: Identify correct linking

   Create a PromptTemplate for the question, then an LLMChain with that prompt and an LLM, then run the chain with user input correctly creates prompt, then LLMChain with prompt and LLM, then runs with input.

3. Final Answer:

   Create a PromptTemplate for the question, then an LLMChain with that prompt and an LLM, then run the chain with user input -> Option D

4. Quick Check:

   Prompt + LLM in chain = C [OK]

Hint: Chain = prompt + LLM + run with input [OK]

Common Mistakes:

• Trying to run prompt alone without chain
• Using LLM without prompt or chain
• Skipping linking steps in LangChain