LangChain 核心组件全解析：构建大模型应用的 “乐高积木”

【个人主页：玄同765】

大语言模型（LLM）开发工程师 ｜中国传媒大学·数字媒体技术（智能交互与游戏设计）

**深耕领域：**大语言模型开发 / RAG知识库 / AI Agent落地 / 模型微调

**技术栈：**Python / LangChain/RAG（Dify+Redis+Milvus）| SQL/NumPy | FastAPI+Docker ️

**工程能力：**专注模型工程化部署、知识库构建与优化，擅长全流程解决方案

「让AI交互更智能，让技术落地更高效」

欢迎技术探讨/项目合作！关注我，解锁大模型与智能交互的无限可能！

在大模型应用开发中，你是否曾被这些问题困扰：

如何让大模型调用外部工具（如数据库、API）？
如何将大模型与自有知识库结合，实现精准问答？
如何构建多轮对话系统，让模型记住上下文？
如何将大模型能力封装为可复用的组件？

LangChain 作为大模型应用开发的 "瑞士军刀"，通过一系列模块化核心组件，让开发者可以像搭乐高积木一样快速构建复杂的大模型应用。本文将从底层原理出发，带你彻底搞懂 LangChain 的核心组件，以及如何用它们构建生产级大模型应用。

一、LangChain 的核心设计理念：模块化与可组合性

LangChain 的核心理念是将大模型应用拆解为独立组件，通过组合实现复杂功能。这些组件可以独立使用，也可以灵活组合，覆盖了大模型应用开发的全流程：

复制代码

graph LR
    A[LangChain核心组件] --> B[模型层（Models）]
    A --> C[数据连接层（Data Connection）]
    A --> D[链（Chains）]
    A --> E[代理（Agents）]
    A --> F[记忆（Memory）]
    A --> G[工具（Tools）]

每个组件都有明确的职责，开发者可以根据需求选择合适的组件进行组合，大大降低了大模型应用的开发门槛。

二、核心组件 1：模型层（Models）------ 大模型的 "接口层"

模型层是 LangChain 与大模型交互的核心组件，负责将用户的请求发送给大模型，并处理模型的响应。

1. 核心类型

（1）LLM（大语言模型）

处理纯文本输入输出，如 GPT-3.5-turbo、Llama 2、文心一言等：

复制代码

from langchain.llms import OpenAI

# 初始化OpenAI LLM
llm = OpenAI(model_name="text-davinci-003", temperature=0.7)

# 生成文本
response = llm("请写一篇关于LangChain的技术博客")
print(response)

（2）ChatModel（对话模型）

专门处理对话场景，支持多轮对话历史，如 GPT-4、Claude 3 等：

复制代码

from langchain.chat_models import ChatOpenAI
from langchain.schema import HumanMessage, SystemMessage

# 初始化ChatGPT模型
chat_model = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.7)

# 多轮对话
messages = [
    SystemMessage(content="你是一名专业的技术博客作者"),
    HumanMessage(content="请写一篇关于LangChain核心组件的技术博客")
]
response = chat_model(messages)
print(response.content)

（3）EmbeddingModel（嵌入模型）

将文本转换为向量，用于语义检索、相似度计算等场景，如 OpenAI Embeddings、Llama Embeddings 等：

复制代码

from langchain.embeddings import OpenAIEmbeddings

# 初始化嵌入模型
embeddings = OpenAIEmbeddings()

# 生成文本向量
text = "LangChain is a framework for building LLM applications"
vector = embeddings.embed_query(text)
print(f"向量维度：{len(vector)}")

2. 关键特性

统一接口：不同大模型的接口差异被抽象为统一的 API，开发者无需为每个模型单独适配；
参数配置：支持温度（temperature）、最大 Token 数（max_tokens）等参数的全局配置；
异步支持：所有模型都支持异步调用，提升大模型应用的并发性能；
模型缓存：支持缓存模型响应，避免重复调用相同请求，降低成本。

三、核心组件 2：数据连接层（Data Connection）------ 大模型的 "知识库"

数据连接层负责将外部数据（如文档、数据库、API 数据）与大模型结合，实现检索增强生成（RAG），让大模型可以基于自有知识库生成精准回答。

1. 核心组件

（1）Document Loaders（文档加载器）

将外部文档（如 PDF、Word、Markdown、网页）加载为 LangChain 的Document对象：

复制代码

from langchain.document_loaders import PyPDFLoader

# 加载PDF文档
loader = PyPDFLoader("langchain_whitepaper.pdf")
documents = loader.load()
print(f"加载的文档页数：{len(documents)}")

支持的文档类型包括：PDF、Word、Excel、Markdown、HTML、JSON、CSV 等，甚至可以加载 YouTube 视频字幕、Notion 页面等。

（2）Text Splitters（文本分割器）

将长文档分割为适合大模型处理的小片段，避免超过模型的上下文窗口：

复制代码

from langchain.text_splitter import RecursiveCharacterTextSplitter

# 初始化文本分割器
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,  # 每个片段的最大Token数
    chunk_overlap=200,  # 片段之间的重叠部分，保持语义连贯性
    length_function=len
)

# 分割文档
split_documents = text_splitter.split_documents(documents)
print(f"分割后的片段数量：{len(split_documents)}")

（3）Vector Stores（向量数据库）

将文本片段的向量存储到向量数据库中，支持快速语义检索：

复制代码

from langchain.vectorstores import Chroma

# 将分割后的文档存储到Chroma向量数据库
vector_store = Chroma.from_documents(
    documents=split_documents,
    embedding=OpenAIEmbeddings()
)

# 语义检索
query = "LangChain的核心组件有哪些？"
retrieved_documents = vector_store.similarity_search(query, k=3)
print(f"检索到的相关文档数量：{len(retrieved_documents)}")

支持的向量数据库包括：Chroma、Pinecone、Milvus、Weaviate、FAISS 等。

（4）Retrievers（检索器）

封装向量数据库的检索逻辑，提供统一的检索接口，方便与其他组件组合：

复制代码

# 从向量数据库创建检索器
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

# 检索相关文档
retrieved_documents = retriever.get_relevant_documents(query)

四、核心组件 3：链（Chains）------ 组件的 "流水线"

链（Chains）是 LangChain 的核心组件，负责将多个组件组合成一个可执行的流水线，实现复杂的大模型应用逻辑。

1. 基础链：LLMChain

最基础的链，将 Prompt 模板和 LLM 组合起来：

复制代码

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# 创建Prompt模板
prompt = PromptTemplate(
    input_variables=["topic"],
    template="请写一篇关于{topic}的技术博客，要求不少于500字。"
)

# 创建LLMChain
chain = LLMChain(llm=llm, prompt=prompt)

# 执行链
response = chain.run(topic="LangChain核心组件")
print(response)

2. 高级链：RetrievalQA

将大模型与检索器组合，实现检索增强生成（RAG）：

复制代码

from langchain.chains import RetrievalQA

# 创建RetrievalQA链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",  # 将检索到的文档直接放入Prompt中
    retriever=retriever,
    return_source_documents=True  # 返回检索到的源文档
)

# 执行问答
response = qa_chain({"query": "LangChain的核心组件有哪些？"})
print(f"回答：{response['result']}")
print(f"参考文档数量：{len(response['source_documents'])}")

3. 自定义链：SequentialChain

将多个链组合成一个流水线，实现多步骤的大模型应用：

复制代码

from langchain.chains import SequentialChain

# 第一个链：生成博客大纲
prompt1 = PromptTemplate(
    input_variables=["topic"],
    template="请为{topic}生成一篇技术博客的大纲，要求不少于5个章节。"
)
chain1 = LLMChain(llm=llm, prompt=prompt1, output_key="outline")

# 第二个链：根据大纲生成博客内容
prompt2 = PromptTemplate(
    input_variables=["outline"],
    template="请根据以下大纲生成一篇技术博客：\n{outline}\n要求不少于1000字。"
)
chain2 = LLMChain(llm=llm, prompt=prompt2, output_key="content")

# 组合成SequentialChain
overall_chain = SequentialChain(
    chains=[chain1, chain2],
    input_variables=["topic"],
    output_variables=["outline", "content"],
    verbose=True  # 打印链的执行过程
)

# 执行链
response = overall_chain.run(topic="LangChain核心组件")
print(f"博客大纲：{response['outline']}")
print(f"博客内容：{response['content']}")

五、核心组件 4：代理（Agents）------ 大模型的 "大脑"

代理（Agents）是 LangChain 的高阶组件，它让大模型可以自主决策，根据用户的请求选择并调用合适的工具，实现复杂的任务。

1. 核心概念

AgentExecutor：代理的执行器，负责协调 Agent 和 Tools；
Agent：决定下一步执行什么动作（如调用工具、直接回答）；
Tools：Agent 可以调用的外部工具（如搜索引擎、数据库、API）；
Toolkits：一组相关工具的集合（如 SQL 数据库工具包、Python REPL 工具包）。

2. 实战：构建一个可以调用 Google 搜索的 Agent

复制代码

from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI

# 初始化LLM
llm = OpenAI(temperature=0)

# 加载工具：Google搜索
tools = load_tools(["google-search"], llm=llm)

# 初始化Agent
agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,  # 零样本Agent，无需示例
    verbose=True
)

# 执行任务
response = agent.run("2024年LangChain的最新特性有哪些？")
print(f"回答：{response}")

3. 常用 Agent 类型

ZeroShotAgent：零样本 Agent，无需示例即可理解并调用工具；
ConversationalAgent：对话 Agent，适合构建多轮对话系统；
SelfAskWithSearchAgent：自问自答 Agent，通过分步提问解决复杂问题；
SQLDatabaseAgent：数据库 Agent，可直接与 SQL 数据库交互；
PythonREPLAgent：Python 代码执行 Agent，可运行 Python 代码解决问题。

六、核心组件 5：记忆（Memory）------ 大模型的 "短期记忆"

记忆（Memory）组件负责存储对话历史，让大模型可以记住之前的对话内容，实现多轮对话。

1. 基础记忆：ConversationBufferMemory

最简单的记忆组件，直接存储所有对话历史：

复制代码

from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

# 初始化记忆组件
memory = ConversationBufferMemory()

# 创建对话链
conversation = ConversationChain(
    llm=llm,
    memory=memory,
    verbose=True
)

# 多轮对话
conversation.predict(input="你好，我叫张三")
conversation.predict(input="我想了解LangChain的核心组件")
conversation.predict(input="我刚才问了什么问题？")  # 模型应该能记住之前的问题

2. 高级记忆类型

（1）ConversationSummaryMemory

将对话历史总结为摘要，避免占用过多上下文窗口：

复制代码

from langchain.memory import ConversationSummaryMemory

memory = ConversationSummaryMemory(llm=llm)

（2）ConversationBufferWindowMemory

只保留最近 N 轮对话，适合长对话场景：

复制代码

from langchain.memory import ConversationBufferWindowMemory

memory = ConversationBufferWindowMemory(k=3)  # 只保留最近3轮对话

（3）VectorStoreRetrieverMemory

将对话历史存储到向量数据库中，支持语义检索，适合复杂对话场景：

复制代码

from langchain.memory import VectorStoreRetrieverMemory

retriever = vector_store.as_retriever(search_kwargs={"k": 3})
memory = VectorStoreRetrieverMemory(retriever=retriever)

七、核心组件 6：工具（Tools）------ 大模型的 "手脚"

工具（Tools）是 LangChain 与外部系统交互的接口，让大模型可以调用外部资源，实现更复杂的任务。

1. 内置工具

LangChain 内置了大量常用工具：

搜索引擎：Google Search、Bing Search；
数据库：SQLDatabaseToolkit、MongoDBToolkit；
代码执行：PythonREPLTool；
文件操作：FileTool、DirectoryTool；
API 调用：RequestsTool；
其他：Calculator、WeatherTool、NewsTool 等。

2. 自定义工具

开发者可以根据需求自定义工具：

复制代码

from langchain.tools import BaseTool, StructuredTool, tool

# 方式1：使用@tool装饰器
@tool
def add_numbers(a: int, b: int) -> int:
    """计算两个数的和"""
    return a + b

# 方式2：继承BaseTool
class MultiplyNumbersTool(BaseTool):
    name = "multiply_numbers"
    description = "计算两个数的乘积"

    def _run(self, a: int, b: int) -> int:
        return a * b

    def _arun(self, a: int, b: int) -> int:
        # 异步实现
        return self._run(a, b)

八、组件组合：构建生产级大模型应用

通过组合 LangChain 的核心组件，我们可以快速构建复杂的生产级大模型应用。以下是一个典型的企业级问答系统架构：

复制代码

graph TD
    A[用户提问] --> B[对话链（ConversationChain）]
    B --> C[记忆组件（Memory）]
    C --> D[大模型（LLM）]
    D --> E[检索器（Retriever）]
    E --> F[向量数据库（Vector Store）]
    F --> G[知识库（Documents）]
    D --> H[工具调用（Tools）]
    H --> I[外部系统（数据库、API、搜索引擎）]
    D --> J[回答生成]
    J --> K[用户]

实战：构建企业知识库问答系统

复制代码

# 1. 加载知识库文档
loader = PyPDFLoader("company_knowledge_base.pdf")
documents = loader.load()

# 2. 分割文档
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
split_documents = text_splitter.split_documents(documents)

# 3. 存储到向量数据库
vector_store = Chroma.from_documents(documents=split_documents, embedding=OpenAIEmbeddings())
retriever = vector_store.as_retriever(search_kwargs={"k": 3})

# 4. 创建RetrievalQA链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

# 5. 创建对话链，添加记忆组件
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
conversation_chain = ConversationalRetrievalChain.from_llm(
    llm=llm,
    retriever=retriever,
    memory=memory,
    verbose=True
)

# 6. 执行多轮问答
response = conversation_chain({"question": "公司的核心产品有哪些？"})
print(f"回答：{response['answer']}")

九、总结：LangChain 的核心价值

LangChain 的核心价值在于降低大模型应用开发的复杂度，通过模块化的核心组件，让开发者可以快速构建复杂的大模型应用，而无需从零开始实现所有功能。

核心组件的价值

模型层：统一大模型接口，降低多模型适配成本；
数据连接层：实现大模型与自有知识库的结合，提升回答精准度；
链：组件的流水线，实现复杂应用逻辑的组合；
代理：让大模型可以自主决策，调用外部工具；
记忆：实现多轮对话，提升用户体验；
工具：扩展大模型的能力边界，实现更复杂的任务。

未来趋势

LangChain 正在向平台化、生态化方向发展，未来将提供更多的内置组件、工具和集成，让大模型应用开发变得更加简单高效。同时，LangChain 也在积极推进开源社区建设，吸引更多开发者贡献组件和工具，形成一个繁荣的大模型应用开发生态。

如果你想快速构建生产级大模型应用，LangChain 绝对是你的不二之选！现在就开始用 LangChain 的核心组件，搭建你的第一个大模型应用吧！🚀