基于LangChain构建企业级RAG知识库与智能体实战指南

如果你正在为如何让大语言模型（LLM）准确回答你公司内部文档、代码库或私有知识的问题而头疼，那么这篇文章就是为你准备的。一个常见的误区是，以为只要把文档喂给 ChatGPT 或 Claude 就能得到精准答案。现实往往是：模型要么“幻觉”出不存在的信息，要么对最新的、非公开的数据一无所知。这背后的核心矛盾在于，LLM 的“记忆”是静态的，而你的知识是动态且私有的。

解决这个问题的技术范式，正是RAG。但仅仅知道 RAG（检索增强生成）这个词，距离搭建一个真正可用、可靠的企业级 AI 知识库，中间还隔着巨大的工程鸿沟。你需要串联文档加载、文本分割、向量化、向量数据库检索、提示工程、对话链等多个环节，任何一个环节的疏漏都会导致系统失效。

本文要做的，就是帮你填平这道鸿沟。我们将以LangChain这一当前最流行的 LLM 应用开发框架为核心，手把手带你从零构建一个完整的 RAG 系统，并进一步升级到能自主调用工具的Agent 智能体。我的核心判断是：对于大多数企业场景，基于 LangChain 的 RAG 是当前性价比最高、可控性最强的 AI 知识库落地方案。它既避免了从头训练大模型的巨大成本，又比单纯使用模型 API 提供了更强的准确性和可解释性。

读完本文，你将彻底掌握：

1. RAG 系统的核心原理与架构设计，理解为什么它比微调更适合知识库场景。
2. LangChain 的核心模块，包括 Models、Prompts、Chains、Indexes、Agents，并理解它们如何协同工作。
3. 从零搭建一个可运行的 RAG 知识库，涵盖文档处理、向量化、存储、检索、生成全流程，并提供全套可复现代码。
4. 将 RAG 系统升级为 Agent，让 AI 不仅能回答问题，还能根据问题自动调用计算器、搜索引擎等工具。
5. 生产环境的最佳实践与避坑指南，包括版本选择、错误处理、性能优化和安全考量。

我们不会停留在概念层面，而是通过一个贯穿始终的实战项目——“企业技术文档问答助手”来演示每一步。让我们开始吧。

1. 为什么你需要 RAG + LangChain，而不是直接调用 API？

在深入代码之前，我们必须先厘清一个根本问题：当你有私有知识需要查询时，为什么首选方案是 RAG 而非其他？

方案对比：微调 vs. 长上下文 vs. RAG

1. 全量微调：用你的数据重新训练模型。代价极高（数十万至上百万），需要大量数据、算力和专家，且知识更新困难。适合打造专属基础模型，但对大多数团队不现实。
2. 长上下文模型：使用支持 128K 或 200K 上下文的模型（如 GPT-4 Turbo, Claude 3），将文档全部塞进提示词。问题在于：成本随上下文长度飙升，且模型在处理超长文本时存在“中间遗忘”现象，检索精度无法保证。
3. RAG：将私有知识库转换为可检索的格式（通常是向量），在提问时，只检索最相关的片段注入给 LLM 生成答案。它精准命中了“低成本、高准确、易更新”这个甜蜜点。

LangChain 的价值：从“胶水代码”到“标准化框架”

没有框架时，你需要自己写代码来：调用 Embedding 接口、管理向量数据库连接、组装提示词模板、处理异步调用、管理对话历史……这些“胶水代码”极其繁琐且容易出错。

LangChain 的出现，将这些通用模式抽象成了标准化的组件和接口。它就像 LLM 应用开发的“Spring Framework”，提供了：

• 模块化：每个功能（文档加载、文本分割、向量存储）都是可插拔的模块。
• 链式编排：将多个步骤（检索 -> 生成）组合成一个可执行的“链”。
• 生态集成：无缝对接数十种 LLM、Embedding 模型、向量数据库和工具。

结论：对于构建企业级 AI 知识库，RAG 是技术选型的必然，而 LangChain 是实现 RAG 的最高效路径。它能让你专注于业务逻辑，而非基础设施。

2. 核心概念全景图：LangChain、RAG 与 Agent

在动手之前，我们需要统一语言。下图清晰地展示了我们将要构建的系统核心组件及其关系：

graph TD A[原始文档] --> B[文档加载器<br/>Document Loader] B --> C[文本分割器<br/>Text Splitter] C --> D[文本块<br/>Chunks] D --> E[嵌入模型<br/>Embedding Model] E --> F[向量数据库<br/>Vector Store] G[用户问题] --> H[检索器<br/>Retriever] H --> F F --> I[相关上下文<br/>Context] I --> J[提示模板<br/>Prompt Template] G --> J J --> K[大语言模型<br/>LLM] K --> L[最终答案] M[外部工具<br/>Tool] --> N[智能体<br/>Agent] K --> N N --> O[工具调用<br/>Tool Use] O --> P[增强答案]

关键概念解读：

• Document & Chunk（文档与块）：一份 PDF、一个网页都是 Document。为了高效检索，需要将其分割成更小的 Chunk（如 500 字符一段）。分割策略直接影响检索质量。
• Embedding（嵌入）：将文本转换为高维空间中的向量（一组数字）。语义相似的文本，其向量在空间中的距离也更近。这是实现语义检索的数学基础。
• Vector Store（向量数据库）：专门用于存储和高效检索向量的数据库。它接收文本块和对应的向量，并建立索引。当输入查询时，它能快速找到最相似的向量（即最相关的文本块）。常见的如 Chroma, Pinecone, Milvus, Qdrant。
• Retriever（检索器）：封装了从向量数据库（或其他来源）中根据查询查找相关文档的逻辑。它是 LangChain 中的一个抽象接口。
• Chain（链）：LangChain 的核心抽象。它将多个组件（如Retriever+LLM）按顺序组合成一个可执行的工作流。我们即将构建的RetrievalQA就是一个标准链。
• Agent（智能体）：链的升级版。智能体具备“思考”能力，可以自主决定在何时、调用何种工具来解决问题。例如，遇到数学计算问题时，它可以决定调用计算器工具，而不是试图让 LLM 自己算。

理解了这些，你就掌握了我们接下来所有操作的“地图”。

3. 环境准备：打造你的开发工作台

我们将使用 Python 作为开发语言。请确保你的环境满足以下要求。

基础环境：

• 操作系统：Windows 10/11, macOS, 或 Linux (Ubuntu 20.04+ 推荐)。本文命令以 Linux/macOS 为例，Windows 用户可在 Git Bash 或 WSL 中运行。
• Python 版本：Python 3.10 或 3.11。LangChain 对 3.12 的支持可能因包而异，3.10/3.11 是最稳定的选择。
• 包管理工具：pip(建议使用虚拟环境)。

第一步：创建并激活虚拟环境虚拟环境能隔离项目依赖，避免包冲突。这是 Python 开发的最佳实践。

# 创建项目目录并进入 mkdir langchain-rag-tutorial && cd langchain-rag-tutorial # 创建虚拟环境（以 venv 为例） python -m venv venv # 激活虚拟环境 # Linux/macOS: source venv/bin/activate # Windows: # venv\Scripts\activate

激活后，你的命令行提示符前通常会显示(venv)。

第二步：安装核心依赖我们将安装 LangChain 及其相关生态包。这里我们选择 OpenAI 的模型和 Chroma 向量数据库，因为它们对初学者最友好。

# 升级 pip pip install --upgrade pip # 安装 LangChain 核心库及 OpenAI 集成 pip install langchain langchain-openai # 安装文档加载器（支持 txt, pdf, html, docx 等） pip install pypdf python-dotenv tiktoken # 安装 Chroma 向量数据库及其 LangChain 集成 pip install chromadb langchain-chroma # 安装用于 Agent 的工具包示例 pip install langchain-community wikipedia

关键依赖说明：

• langchain: 核心框架。
• langchain-openai: 官方维护的 OpenAI 集成，替换了旧的openai包。
• pypdf: 用于读取 PDF 文件。
• python-dotenv: 用于管理环境变量（如 API Key）。
• tiktoken: OpenAI 的令牌计算器，用于文本分割。
• chromadb: 轻量级、开源的向量数据库，可本地运行，无需额外服务。
• langchain-chroma: Chroma 的 LangChain 集成。
• wikipedia: 我们将用它作为 Agent 的一个示例工具。

第三步：获取并配置 API Key为了使用 OpenAI 的模型，你需要一个 API Key。请前往 OpenAI Platform 创建。

在项目根目录下创建一个名为.env的文件，用于安全地存储密钥：

# .env 文件内容 OPENAI_API_KEY="你的-openai-api-key-放在这里"

重要安全提示：务必在.gitignore文件中加入.env，切勿将 API Key 提交到版本控制系统。

4. 实战第一步：构建你的第一个 RAG 系统

现在，我们从最简单的流程开始：读取本地文档，创建向量索引，并进行问答。

项目结构：

langchain-rag-tutorial/ ├── .env ├── requirements.txt (可选，记录依赖) ├── docs/ # 存放你的知识文档 │ └── company_handbook.pdf ├── data/ # 用于存储向量数据库 ├── basic_rag.py # 基础 RAG 脚本 └── agent_demo.py # Agent 演示脚本

4.1 文档加载与处理在docs目录下放一个示例文档（如company_handbook.txt），内容可以是一些产品介绍或规章制度。

创建basic_rag.py文件：

# basic_rag.py import os from dotenv import load_dotenv from langchain_openai import OpenAIEmbeddings, ChatOpenAI from langchain_community.document_loaders import TextLoader from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_chroma import Chroma from langchain.chains import RetrievalQA # 1. 加载环境变量 load_dotenv() openai_api_key = os.getenv("OPENAI_API_KEY") # 2. 加载文档 loader = TextLoader("./docs/company_handbook.txt", encoding="utf-8") documents = loader.load() print(f"已加载文档数：{len(documents)}") print(f"首文档内容预览：{documents[0].page_content[:200]}...") # 3. 分割文本 text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, # 每个块的最大字符数 chunk_overlap=50, # 块之间的重叠字符数，保持上下文连贯 separators=["\n\n", "\n", "。", "！", "？", "，", " ", ""] # 分割符优先级 ) chunks = text_splitter.split_documents(documents) print(f"分割后的文本块数：{len(chunks)}") # 4. 初始化 Embedding 模型和 LLM embeddings = OpenAIEmbeddings(model="text-embedding-3-small", openai_api_key=openai_api_key) llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, openai_api_key=openai_api_key) # 5. 创建向量数据库并持久化 vector_store = Chroma.from_documents( documents=chunks, embedding=embeddings, persist_directory="./data/chroma_db" # 向量数据将保存到此目录 ) vector_store.persist() # 显式持久化到磁盘 print("向量数据库已创建并持久化到 ./data/chroma_db") # 6. 创建检索器 retriever = vector_store.as_retriever(search_kwargs={"k": 3}) # 检索最相关的3个块 # 7. 创建检索问答链 qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # 最常用的类型，将所有检索到的上下文“塞”进提示词 retriever=retriever, return_source_documents=True # 返回源文档，便于调试 ) # 8. 进行问答 query = "公司今年的主要目标是什么？" result = qa_chain.invoke({"query": query}) print(f"\n问题：{query}") print(f"答案：{result['result']}") print(f"\n参考来源：") for i, doc in enumerate(result['source_documents']): print(f"[{i+1}] {doc.page_content[:150]}...")

关键代码解释：

• RecursiveCharacterTextSplitter: 是 LangChain 中最常用的分割器，它会递归地尝试用不同的分隔符分割，以得到大小接近chunk_size的块。chunk_overlap是关键参数，避免在句子中间切断语义。
• Chroma.from_documents: 这个方法一次性完成了向量化、存储和索引创建。persist_directory参数使得数据可以保存到本地，下次启动无需重新处理文档。
• RetrievalQA: 这是 LangChain 提供的一个高级链，它封装了“检索 -> 组装上下文 -> 提问 LLM -> 返回答案”的完整流程。chain_type="stuff"是最直接的方式，适合上下文总长度不超过模型限制的情况。

运行脚本：

python basic_rag.py

如果一切顺利，你将看到文档被加载、分割、存储，并最终得到基于你文档内容的答案。

5. 进阶：打造更健壮的生产级 RAG 系统

上面的例子跑通了流程，但离“企业级”还有距离。接下来，我们针对关键环节进行强化。

5.1 优化文本分割策略chunk_size=500可能不是最优的。对于技术文档，更大的块（如 1000-2000）可能保留更完整的逻辑；对于对话记录，更小的块可能更精准。你可以尝试不同的分割器：

from langchain.text_splitter import CharacterTextSplitter, TokenTextSplitter # 按字符数分割（简单直接） char_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=100) # 按 Token 数分割（更贴合模型限制） token_splitter = TokenTextSplitter(chunk_size=500, chunk_overlap=50)

5.2 实现增量更新企业知识库是不断更新的。重新处理全部文档成本高昂。我们需要支持增量添加。

# incremental_update.py from langchain_chroma import Chroma from langchain_openai import OpenAIEmbeddings from langchain_community.document_loaders import TextLoader from langchain.text_splitter import RecursiveCharacterTextSplitter load_dotenv() embeddings = OpenAIEmbeddings() # 假设已有向量数据库存储在 ./data/chroma_db vector_store = Chroma( persist_directory="./data/chroma_db", embedding_function=embeddings ) # 加载新文档 new_loader = TextLoader("./docs/new_policy.txt", encoding="utf-8") new_docs = new_loader.load() text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50) new_chunks = text_splitter.split_documents(new_docs) # 向现有向量库添加新文档块 vector_store.add_documents(new_chunks) vector_store.persist() # 再次持久化 print(f"已成功添加 {len(new_chunks)} 个新文本块。")

5.3 优化检索：重排序与混合搜索简单的向量相似度搜索有时会漏掉关键词完全匹配的重要文档。可以引入重排序或混合搜索。

# enhanced_retrieval.py from langchain.retrievers import ContextualCompressionRetriever from langchain.retrievers.document_compressors import LLMChainExtractor from langchain_openai import ChatOpenAI load_dotenv() llm = ChatOpenAI(temperature=0) # 基础检索器 base_retriever = vector_store.as_retriever(search_kwargs={"k": 5}) # 1. 使用 LLM 进行重排序/提炼 (Contextual Compression) # 原理：让 LLM 从检索到的多个文档中，提取出与问题最相关的部分。 compressor = LLMChainExtractor.from_llm(llm) compression_retriever = ContextualCompressionRetriever( base_compressor=compressor, base_retriever=base_retriever ) # 2. 混合搜索：结合向量搜索和关键词搜索（需要支持此功能的向量库，如 Weaviate） # 这里以 Chroma 的简单关键词过滤为例（非真正混合搜索，但展示了思路） def hybrid_retriever(query: str, vector_store, k=3): # 向量相似度搜索 vector_results = vector_store.similarity_search(query, k=k) # 简单的关键词匹配（在实际项目中，你可能需要集成 BM25 等算法） # 这里仅作演示，实际应使用更专业的文本检索库 keyword_results = [doc for doc in chunks if query.lower() in doc.page_content.lower()] # 合并去重（简化处理） combined = vector_results + keyword_results[:2] # 取部分关键词结果 seen = set() unique_results = [] for doc in combined: if doc.page_content not in seen: seen.add(doc.page_content) unique_results.append(doc) return unique_results[:k] # 返回前k个 # 使用增强后的检索器创建 QA 链 qa_chain_enhanced = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", retriever=compression_retriever, # 使用重排序检索器 return_source_documents=True )

重排序会消耗额外的 LLM Token，但能显著提升答案相关性，尤其是在检索到大量文档时。

6. 从 RAG 到 Agent：让 AI 学会使用工具

RAG 让 AI 拥有了“记忆”，而 Agent 让 AI 拥有了“手脚”。当问题无法仅凭内部知识回答时（如需要实时信息、计算或执行操作），Agent 可以自主调用预定义的工具。

6.1 什么是 LangChain Agent？Agent 的核心是一个“推理循环”：接收用户输入 -> 思考（决定是否使用工具、使用哪个工具）-> 执行工具 -> 观察结果 -> 再次思考或给出最终答案。LangChain 提供了多种 Agent 类型，如ReAct,OpenAI Tools。

6.2 构建一个能调用工具的多面手 Agent我们将创建一个 Agent，它既拥有我们之前构建的 RAG 知识库（作为工具之一），又能调用计算器和维基百科。

# agent_demo.py import os from dotenv import load_dotenv from langchain_openai import ChatOpenAI from langchain.agents import AgentExecutor, create_openai_tools_agent from langchain.tools import Tool from langchain import hub from langchain.chains import RetrievalQA from langchain_community.utilities import WikipediaAPIWrapper from langchain_community.tools import WikipediaQueryRun from langchain_community.agent_toolkits import create_retriever_tool # 0. 加载环境与已有向量库 load_dotenv() from langchain_openai import OpenAIEmbeddings from langchain_chroma import Chroma embeddings = OpenAIEmbeddings() vector_store = Chroma(persist_directory="./data/chroma_db", embedding_function=embeddings) retriever = vector_store.as_retriever(search_kwargs={"k": 3}) # 1. 定义工具 # 工具1：RAG 知识库问答工具 rag_tool = create_retriever_tool( retriever, "company_knowledge_base", "专门用于查询公司内部知识，如员工手册、产品文档、规章制度等。输入应为一个明确的问题。" ) # 工具2：计算器工具 (需要安装 numexpr) try: from langchain_community.tools import numexpr calculator_tool = numexpr.NumExprCalculator() except ImportError: print("请先安装 `numexpr`: pip install numexpr") # 定义一个简单的替代工具 from langchain.tools import BaseTool from typing import Optional class SimpleCalculatorTool(BaseTool): name = "Calculator" description = "用于执行简单的数学计算。输入一个数学表达式，如 '2 + 2' 或 'sqrt(16)'。" def _run(self, query: str) -> str: try: # 警告：使用 eval 有安全风险，仅用于演示。生产环境应用安全库。 return str(eval(query)) except Exception as e: return f"计算错误：{e}" async def _arun(self, query: str) -> str: raise NotImplementedError("异步执行未实现") calculator_tool = SimpleCalculatorTool() # 工具3：维基百科工具 wiki_wrapper = WikipediaAPIWrapper(top_k_results=2, doc_content_chars_max=500) wiki_tool = WikipediaQueryRun(api_wrapper=wiki_wrapper) # 将所有工具放入列表 tools = [rag_tool, calculator_tool, wiki_tool] # 2. 初始化 LLM 并获取提示词模板 llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) # 从 LangChain Hub 拉取一个为 OpenAI Tools 设计好的提示词模板 prompt = hub.pull("hwchase17/openai-tools-agent") # 3. 创建 Agent agent = create_openai_tools_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True) # 4. 运行 Agent print("=== Agent 演示开始 ===") queries = [ "公司今年的主要目标是什么？", # 应使用 RAG 工具 "请计算 15 的平方加上 20 的三分之一次方是多少？", # 应使用计算器工具 "谁是 LangChain 的创始人？", # 应使用维基百科工具 "结合公司目标和 LangChain 的信息，我们该如何推进 AI 项目？" # 需要组合多个工具 ] for query in queries: print(f"\n用户问题：{query}") print("-" * 50) try: result = agent_executor.invoke({"input": query}) print(f"最终答案：{result['output']}") except Exception as e: print(f"执行出错：{e}") print("-" * 50)

关键代码解释：

• create_retriever_tool: 这是 LangChain 的一个便捷函数，将我们之前构建的检索器包装成一个 Agent 可调用的工具，并赋予了名称和描述。描述非常重要，Agent 会根据工具的描述来决定是否调用它。
• hub.pull(“hwchase17/openai-tools-agent”): LangChain Hub 是一个预置提示词模板的仓库。我们拉取了一个为 OpenAI 的 Function Calling 功能优化过的 Agent 提示词模板。
• AgentExecutor: 负责运行 Agent 的推理循环。verbose=True会打印出 Agent 的思考过程（非常推荐在调试时开启），handle_parsing_errors=True能更优雅地处理 LLM 输出格式错误。

运行脚本：

python agent_demo.py

观察输出，你会看到 Agent 的完整思考链（Thought/Action/Observation），它如何选择工具，以及如何整合不同工具的结果来生成最终答案。这演示了如何将静态知识库与动态工具能力相结合。

7. 部署与生产环境最佳实践

让系统在本地运行只是第一步。要服务于真实用户，必须考虑部署和稳定性。

7.1 向量数据库选型与部署

• 开发/轻量生产：Chroma。开源、轻量、可嵌入，适合快速启动和中小规模数据。本文示例即使用它。
• 中大型生产：Qdrant,Milvus,Weaviate,Pinecone（云服务）。它们支持分布式、高可用、更丰富的过滤和混合搜索。例如，使用 Docker 部署 Qdrant：

  docker pull qdrant/qdrant docker run -p 6333:6333 qdrant/qdrant

  然后在 LangChain 中更换客户端连接即可。

7.2 异步化与性能优化LangChain 支持异步调用，对于高并发 API 服务至关重要。

# async_qa.py import asyncio from langchain_openai import ChatOpenAI, OpenAIEmbeddings from langchain_chroma import Chroma from langchain.chains import RetrievalQA async def async_qa_chain(query: str): embeddings = OpenAIEmbeddings() vector_store = Chroma(persist_directory="./data/chroma_db", embedding_function=embeddings, client_settings=..., async_client=...) # 需配置异步客户端 retriever = vector_store.as_retriever() llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0, streaming=True) # 支持流式 qa_chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever) # 异步调用链 result = await qa_chain.ainvoke({"query": query}) return result["result"] # 在 FastAPI 或异步框架中使用 @app.post("/ask") async def ask_question(request: QuestionRequest): answer = await async_qa_chain(request.query) return {"answer": answer}

7.3 监控、日志与评估

• 日志：记录用户的查询、检索到的源文档、LLM 的输入输出、耗时和 Token 使用量。这有助于调试和成本分析。
• 评估：定期用一批标准问题测试系统，评估答案的准确性和相关性。可以使用RAGAS、TruLens等框架进行自动化评估。
• 限流与降级：为 API 设置速率限制。当主要 LLM 服务不可用时，应有降级策略（如返回缓存答案或提示稍后重试）。

8. 常见问题与排查指南

在开发过程中，你几乎一定会遇到以下问题。这里提供快速排查思路。

9. 总结：从入门到精通的路径

至此，你已经完成了一个从零到一的企业级 AI 知识库与智能体构建之旅。我们来回顾一下核心要点，并规划下一步：

你已经掌握的核心技能：

1. 环境搭建与依赖管理：使用虚拟环境，安装 LangChain 及其生态工具。
2. 文档处理流水线：使用Document Loaders和Text Splitters将原始知识转化为结构化的“块”。
3. 向量化与存储：利用Embedding Models和Vector Stores（如 Chroma）构建可语义检索的知识索引。
4. 检索增强生成：使用RetrievalQA链，将用户问题、检索到的上下文和 LLM 的生成能力无缝结合。
5. 智能体开发：将 RAG 系统封装成工具，并与其他工具（计算器、搜索）组合，创建能自主决策和执行的 Agent。

下一步深入方向：

• 探索更强大的框架：了解LangGraph，它用于构建有状态、多智能体的复杂工作流，是 LangChain 的进阶。
• 优化检索质量：深入研究重排序、查询改写、多向量检索等高级技术。
• 引入评估体系：使用RAGAS等工具，从“忠实度”、“答案相关性”、“上下文相关性”等维度量化你的 RAG 系统质量。
• 前端与部署：使用Streamlit、Gradio快速构建 Web 界面，或使用FastAPI构建企业级后端服务，并通过Docker容器化部署。
• 探索本地模型：为追求数据隐私和成本控制，可以研究如何在本地部署 LLM（如 Llama 3、Qwen）和 Embedding 模型，构建完全离线的 AI 应用。

最后的工程建议：从一个小而具体的业务场景开始（例如“客服标准问答库”或“新员工入职指引”），快速迭代一个 MVP（最小可行产品）。在真实使用中收集反馈，持续优化你的分割策略、检索参数和提示词模板。AI 应用的构建是一个“数据-模型-反馈”的持续循环，而 LangChain 为你提供了启动这个循环最坚实的脚手架。

（本文所有完整代码已整理至项目仓库，你可以在 CSDN 代码仓库或通过文末链接获取，建议收藏并动手实践。）