麻瓜教程

Appearance

LangChain 组件 ​

LangChain 由多个核心组件组成，这些组件共同构成了构建 LLM 应用的基础。本节将详细介绍 LangChain 1.2 的主要组件及其功能。

1. 模型（Models） ​

模型是 LangChain 的核心组件，负责处理文本生成和理解。LangChain 支持多种类型的模型：

语言模型（LLMs） ​

语言模型是最基本的模型类型，接受文本输入并生成文本输出。

示例代码：使用 OpenAI 的语言模型 ​

python
from langchain_openai import OpenAI

# 初始化语言模型
llm = OpenAI(api_key="your-api-key")

# 生成文本
response = llm("What is LangChain?")
print(response)

聊天模型（Chat Models） ​

聊天模型专门用于对话场景，接受消息列表作为输入并生成消息作为输出。

示例代码：使用 OpenAI 的聊天模型 ​

python
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

# 初始化聊天模型
chat_model = ChatOpenAI(api_key="your-api-key")

# 发送消息
messages = [
    SystemMessage(content="You are a helpful assistant"),
    HumanMessage(content="What is LangChain?")
]

response = chat_model(messages)
print(response.content)

嵌入模型（Embedding Models） ​

嵌入模型用于将文本转换为向量表示，常用于语义搜索和知识检索。

示例代码：使用 OpenAI 的嵌入模型 ​

python
from langchain_openai import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings(api_key="your-api-key")

# 生成嵌入向量
text = "LangChain is a framework for building LLM applications"
embedding = embeddings.embed_query(text)
print(len(embedding))  # 输出向量维度

2. 提示词（Prompts） ​

提示词是指导模型生成特定输出的输入文本。LangChain 提供了提示词模板，使开发者可以更灵活地构建和管理提示词。

提示词模板 ​

提示词模板允许开发者创建可重用的提示词结构，并在运行时填充变量。

示例代码：使用提示词模板 ​

python
from langchain_core.prompts import PromptTemplate

# 创建提示词模板
template = "What is a good name for a {product} company that makes {description}?"
prompt = PromptTemplate(template=template, input_variables=["product", "description"])

# 填充变量
formatted_prompt = prompt.format(product="tech", description="smartphones")
print(formatted_prompt)

聊天提示词模板 ​

聊天提示词模板专门用于聊天模型，允许开发者创建结构化的对话提示。

示例代码：使用聊天提示词模板 ​

python
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.messages import HumanMessage, SystemMessage

# 创建聊天提示词模板
chat_template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant"),
    ("human", "What is a good name for a {product} company?")
])

# 填充变量
formatted_messages = chat_template.format_messages(product="tech")
print(formatted_messages)

3. 链（Chains） ​

链是将多个组件组合在一起的方式，形成一个完整的工作流。在 LangChain 1.2 中，推荐使用 LCEL（LangChain Expression Language）语法来创建链。

基础链（LCEL） ​

使用 LCEL 语法，可以通过管道操作符 | 将组件组合在一起。

示例代码：使用 LCEL 创建链 ​

python
from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain_core.output_parsers import StrOutputParser

# 创建提示词模板
template = "What is a good name for a {product} company that makes {description}?"
prompt = PromptTemplate(template=template, input_variables=["product", "description"])

# 初始化语言模型
llm = OpenAI(api_key="your-api-key")

# 创建输出解析器
output_parser = StrOutputParser()

# 使用 LCEL 语法创建链
chain = prompt | llm | output_parser

# 运行链
response = chain.invoke({"product": "tech", "description": "smartphones"})
print(response)

复合链（RunnableSequence） ​

使用 RunnableSequence 可以将多个链按顺序组合，前一个链的输出作为后一个链的输入。

示例代码：使用 RunnableSequence ​

python
from langchain_core.prompts import PromptTemplate
from langchain_openai import OpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableSequence, RunnableParallel

# 初始化语言模型
llm = OpenAI(api_key="your-api-key")

# 创建输出解析器
output_parser = StrOutputParser()

# 创建第一个链
prompt1 = PromptTemplate(
    template="What is a good name for a {product} company that makes {description}?",
    input_variables=["product", "description"]
)
chain1 = prompt1 | llm | output_parser

# 创建第二个链
prompt2 = PromptTemplate(
    template="Write a tagline for a company named {company_name} that makes {description}.",
    input_variables=["company_name", "description"]
)
chain2 = prompt2 | llm | output_parser

# 创建组合链
combined_chain = (
    RunnableParallel(
        company_name=chain1,
        description=lambda x: x["description"]
    )
    | (lambda x: {"company_name": x["company_name"], "description": x["description"]})
    | chain2
)

# 运行组合链
response = combined_chain.invoke({"product": "tech", "description": "smartphones"})
print("Tagline:", response)

4. 代理（Agents） ​

代理是能够自主决策和执行任务的组件，它可以使用工具来完成复杂的任务。

示例代码：使用代理 ​

python
from langchain_openai import OpenAI
from langchain.agents import AgentType, initialize_agent, load_tools

# 初始化语言模型
llm = OpenAI(api_key="your-api-key")

# 加载工具
tools = load_tools(["serpapi", "llm-math"], llm=llm)

# 初始化代理
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 运行代理
response = agent.run("What is the current temperature in New York?")
print(response)

5. 工具（Tools） ​

工具是代理可以使用的外部服务或功能，如搜索、计算、数据库查询等。

内置工具 ​

LangChain 提供了多种内置工具，如：

  • serpapi：用于搜索网络
  • llm-math：用于数学计算
  • python_repl：用于执行 Python 代码
  • wikipedia：用于查询维基百科

自定义工具 ​

开发者也可以创建自定义工具，扩展代理的能力。

示例代码：创建自定义工具 ​

python
from langchain.tools import BaseTool
from langchain_openai import OpenAI
from langchain.agents import AgentType, initialize_agent
from typing import Optional, Type
from pydantic import BaseModel, Field

# 定义工具输入模式
class CalculatorInput(BaseModel):
    expression: str = Field(description="数学表达式")

# 创建自定义工具
class CalculatorTool(BaseTool):
    name = "calculator"
    description = "用于计算数学表达式"
    args_schema: Type[BaseModel] = CalculatorInput

    def _run(self, expression: str) -> str:
        try:
            result = eval(expression)
            return f"计算结果: {result}"
        except Exception as e:
            return f"计算错误: {str(e)}"

# 初始化语言模型
llm = OpenAI(api_key="your-api-key")

# 初始化工具
tools = [CalculatorTool()]

# 初始化代理
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# 运行代理
response = agent.run("3 + 5 * 2 等于多少？")
print(response)

6. 记忆（Memory） ​

记忆是用于存储和管理会话历史的组件，使 LLM 应用能够保持上下文信息。

使用 RunnableWithMessageHistory（推荐） ​

在 LangChain 1.2 中，推荐使用 RunnableWithMessageHistory 来管理对话历史。

示例代码：使用 RunnableWithMessageHistory ​

python
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory

# 创建消息历史存储
store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# 创建提示词模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}")
])

# 初始化模型
llm = ChatOpenAI(api_key="your-api-key")

# 创建输出解析器
output_parser = StrOutputParser()

# 使用 LCEL 语法创建链
chain = prompt | llm | output_parser

# 创建带记忆的链
chain_with_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history"
)

# 运行链
response1 = chain_with_history.invoke(
    {"input": "What is LangChain?"},
    config={"configurable": {"session_id": "user_123"}}
)
print("Response 1:", response1)

response2 = chain_with_history.invoke(
    {"input": "Can you give me an example?"},
    config={"configurable": {"session_id": "user_123"}}
)
print("Response 2:", response2)

传统记忆类型（向后兼容） ​

LangChain 还提供了传统记忆类型，如：

  • ConversationBufferMemory：简单地存储对话历史
  • ConversationBufferWindowMemory：只保留最近的对话历史
  • ConversationSummaryMemory：对对话历史进行总结

7. 向量存储（Vector Stores） ​

向量存储用于存储和检索文本的向量表示，是实现语义搜索和知识检索的关键组件。

示例代码：使用向量存储 ​

python
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter

# 加载文档
loader = TextLoader("path/to/document.txt")
documents = loader.load()

# 分割文档
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

# 初始化嵌入模型
embeddings = OpenAIEmbeddings(api_key="your-api-key")

# 创建向量存储
vectorstore = FAISS.from_documents(texts, embeddings)

# 相似度搜索
query = "What is LangChain?"
docs = vectorstore.similarity_search(query)
print(docs[0].page_content)

总结 ​

LangChain 的组件系统为构建复杂的 LLM 应用提供了强大的基础。在 LangChain 1.2 中，推荐使用 LCEL 语法来创建链，使用 RunnableWithMessageHistory 来管理对话历史。通过灵活组合这些组件，开发者可以构建各种功能强大的 LLM 应用，如聊天机器人、问答系统、文档分析工具等。

在接下来的章节中，我们将详细介绍如何使用这些组件构建实际的 LLM 应用。

Copyright © 2025-2026 京公网安备 11010102000001号 京ICP备2024078128号-1