LangChain 链简介
了解 LangChain 中链的概念，以及它们如何支持使用 LLM 执行多步骤操作
LangChain 链简介 是 CoddyKit 上的免费 AI Agents with LangChain & Autonomous Workflows 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 AI Agents with LangChain & Autonomous Workflows 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
What are LangChain Chains?
Welcome to LangChain Chains! Imagine you have a complex task for an AI, like writing a blog post or summarizing a long document. A single command to a Large Language Model (LLM) might not be enough.
This is where 'Chains' come in. They help you break down complex AI tasks into smaller, manageable steps, executed in a specific order. Think of them as a blueprint for AI workflows.
Why We Need Chains
An LLM is powerful, but for multi-step problems or interactions requiring specific formatting, you need more structure. Chains provide this structure by:
- Enabling multi-step reasoning: Allowing the LLM to process information iteratively.
- Connecting components: Linking LLMs with prompts, output parsers, or other tools.
- Building structured workflows: Ensuring tasks are performed in a predefined sequence, making complex applications manageable.
Chains: A Sequential Flow
At its core, a chain is about sequential processing. The output from one step automatically becomes the input for the next step. It's like an assembly line for AI tasks.
This allows you to build sophisticated applications by combining different LangChain components and operations in a logical, step-by-step flow.
Key Components in Chains
Chains typically link together various LangChain components. The most common ones you'll encounter are:
- LLMs: The 'brain' that generates text or responses.
- Prompt Templates: Structured instructions that guide the LLM's behavior.
- Output Parsers: Tools to format the LLM's raw text output into a more usable structure (e.g., JSON, lists).
For this lesson, we'll focus on LLMs and Prompt Templates.
The Simplest Chain: LLMChain
The most fundamental chain in LangChain is the LLMChain. It's designed to take an input, apply a PromptTemplate to format it, pass the formatted prompt to an LLM, and get a text output.
It's the basic building block for many more complex interactions and a great starting point for understanding chains.
Setting Up LLM & Prompt
Before we build an LLMChain, let's prepare our ingredients: an LLM and a Prompt Template. We'll use a simple prompt to ask the LLM to say something nice to a person by name.
Remember to replace 'YOUR_OPENAI_API_KEY' with your actual key or set it as an environment variable.
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate
# Set your API key (replace with your actual key or env var)
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
# 1. Initialize the LLM (e.g., OpenAI's GPT-3.5)
llm = ChatOpenAI(temperature=0.7)
# 2. Define a Prompt Template
# '{name}' is the input variable for this prompt
prompt = PromptTemplate.from_template(
"Hello, my name is {name}. Can you say something nice to me?"
)
print("LLM and Prompt Template are ready!")Creating an LLMChain
Now, let's combine our LLM and Prompt Template into an LLMChain. This chain will take a 'name' as input, format it into the prompt, send it to the LLM, and return the LLM's response.
The LLMChain class from langchain.chains connects these two components seamlessly.
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate
from langchain.chains import LLMChain
# Set your API key (replace with your actual key or env var)
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY"
# 1. Initialize the LLM
llm = ChatOpenAI(temperature=0.7)
# 2. Define a Prompt Template
prompt = PromptTemplate.from_template(
"Hello, my name is {name}. Can you say something nice to me?"
)
# 3. Create the LLMChain
# The chain connects the prompt and the LLM
chain = LLMChain(llm=llm, prompt=prompt)
# 4. Invoke the chain with an input
# The input key 'name' must match the prompt variable
response = chain.invoke({"name": "Alice"})
print("Chain invoked successfully!")
print("Response:")
print(response["text"])Understanding Chain Output
Notice that the output from chain.invoke() is a dictionary. For a basic LLMChain, it typically contains:
- The input variables you provided (e.g.,
'name'). 'text': The LLM's generated response based on the prompt.
This structured output makes it easy to extract the LLM's answer and use it in subsequent steps or display it to a user.
Benefits of LLMChain
Even though it's simple, the LLMChain offers significant benefits:
- Encapsulation: It neatly packages the prompt and LLM logic together, making your code modular.
- Readability: It makes your LLM interactions cleaner and easier to understand than raw API calls.
- Foundation: It serves as the fundamental building block for constructing more complex multi-step chains and agents.
It helps organize your LLM interactions efficiently.
Quick Check
You've learned that LangChain Chains help organize multi-step operations. Based on our discussion, which of the following best describes the core purpose of an LLMChain?
Recap: Getting Chained Up!
Great job! In this lesson, you learned about:
- The concept of Chains in LangChain for structuring multi-step AI tasks.
- Why chains are essential for building complex, controlled workflows with LLMs.
- The basic components that typically make up a chain (LLMs, Prompt Templates).
- How to create and run an LLMChain, the simplest chain, by combining a PromptTemplate and an LLM.
Next, we'll explore how to combine multiple LLMChains into more powerful sequential workflows!
常见问题解答
「LangChain 链简介」课时是免费的吗？
是的 — 「LangChain 链简介」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Agents with LangChain & Autonomous Workflows 课程的其余内容，请升级到 CoddyKit PRO。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。
「LangChain 链简介」这节课中我会学到什么？
了解 LangChain 中链的概念，以及它们如何支持使用 LLM 执行多步骤操作 你通过在浏览器中直接运行的动手代码来练习 AI Agents with LangChain & Autonomous Workflows，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 AI Agents with LangChain & Autonomous Workflows 需要有经验吗？
无需任何先前经验。CoddyKit 上的 AI Agents with LangChain & Autonomous Workflows 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。
「LangChain 链简介」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 AI Agents with LangChain & Autonomous Workflows 课中编写并运行代码吗？
能。每节 AI Agents with LangChain & Autonomous Workflows 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。