最近在尝试将大模型应用到企业级业务场景时，很多开发者朋友都遇到了相似的困境：网上资料零散，要么是简单的API调用示例，要么是过于理论化的框架介绍，真正能串联起从数据准备、模型集成、RAG构建到Agent编排的完整实战教程少之又少。面对海量的技术栈选择，如何搭建一个稳定、高效且可维护的智能应用系统，成为了一个普遍的技术痛点。

本文旨在解决这一难题。我将结合近期多个企业级项目的落地经验，为你系统性地拆解如何从零开始，基于 LangChain 框架构建一个完整的 RAG（检索增强生成）与 Agent（智能体）项目。内容将涵盖核心概念、环境搭建、代码实战、性能优化及生产部署注意事项，力求做到“即学即用”。无论你是希望入门大模型应用开发的新手，还是寻求项目落地最佳实践的资深工程师，都能从本文中找到清晰的路径和可复用的代码。

学完本文，你将能够：

1. 透彻理解 LangChain 的核心组件与设计哲学。
2. 独立搭建一个支持私有知识库问答的 RAG 系统。
3. 开发具备工具调用和复杂任务规划能力的 Agent。
4. 掌握企业级项目中的性能调优、错误处理和部署方案。
5. 形成一套可复用于实际业务的技术架构思路。

1. 背景与核心概念：为什么是 LangChain、RAG 与 Agent？

在深入代码之前，我们必须厘清几个核心概念及其价值，这决定了我们技术选型的合理性。

1.1 大模型应用开发的挑战大型语言模型（LLM）如 GPT、Claude、文心一言等，拥有强大的理解和生成能力。然而，直接将其用于企业场景会面临三大挑战：

• 知识滞后性：模型训练数据有截止日期，无法获取最新、最专业的内部知识（如公司财报、产品手册）。
• 幻觉问题：模型可能生成看似合理但事实错误的“幻觉”内容，在严谨的业务场景中这是致命的。
• 缺乏行动力：模型本身是“思考者”，而非“执行者”。它无法查询数据库、调用 API 或操作外部系统。

1.2 RAG：为模型注入“最新、最准”的知识检索增强生成正是为解决前两个挑战而生。其核心思想是“先检索，后生成”：

1. 索引：将你的私有文档（PDF、Word、网页等）进行切片、向量化，存入向量数据库。
2. 检索：当用户提问时，从向量数据库中检索出与问题最相关的文档片段。
3. 增强：将这些相关片段作为“上下文”，与用户问题一起提交给大模型。
4. 生成：模型基于提供的上下文生成答案，从而保证答案的准确性和时效性。

RAG 系统让大模型具备了“翻阅企业知识库”的能力，是构建智能客服、知识库问答系统的核心技术。

1.3 Agent：赋予模型“思考与行动”的能力如果说 RAG 扩展了模型的“知识”，那么Agent（智能体）则扩展了模型的“能力”。一个 Agent 通常包含几个核心组件：

• 规划：将复杂任务拆解为可执行的子步骤。
• 工具：定义 Agent 可以调用的外部函数，如搜索、计算、数据库查询、API调用等。
• 记忆：保存对话历史或执行状态，实现多轮交互。
• 执行：根据规划，选择并调用合适的工具，根据工具返回的结果决定下一步行动。

通过 Agent，我们可以构建能自动分析数据、执行工作流、甚至进行决策辅助的复杂应用，例如自动报表生成、智能运维机器人等。

1.4 LangChain：大模型应用的“连接器”与“脚手架”LangChain 不是一个模型，而是一个框架。它就像乐高积木的底板和连接件，其主要价值在于：

• 组件化：将大模型应用开发中常见的环节（模型调用、提示词管理、记忆、索引、链、代理）抽象成标准化、可替换的组件。
• 集成化：无缝连接了数百种 LLM（OpenAI, Anthropic, 本地模型）、向量数据库（Chroma, Pinecone, Weaviate）、工具（搜索引擎, APIs）等。
• 编排能力：通过Chain和Agent等高级抽象，轻松组合多个组件，构建复杂的工作流。

简单比喻：LLM 是“大脑”，RAG 是给大脑配的“资料库”，Agent 是驱动大脑和手脚协同工作的“神经系统”，而 LangChain 就是构建这套系统的“工具箱和设计图”。

2. 环境准备与版本说明

我们将构建一个完整的项目，因此需要一个清晰的开发环境。以下配置是经过验证的稳定组合，建议保持一致以避免兼容性问题。

2.1 基础环境

• 操作系统：Ubuntu 20.04+/macOS Monterey+/Windows 10/11 (WSL2 推荐)
• Python 版本：3.8 - 3.11（本文使用3.9）
• 包管理工具：pip 或 conda

2.2 核心依赖库及版本我们将使用requirements.txt来管理依赖。关键版本说明如下：

# requirements.txt langchain==0.1.0 langchain-community==0.0.10 # 社区集成组件 langchain-openai==0.0.5 # OpenAI 集成 langchain-chroma==0.0.1 # Chroma 向量数据库集成 # 大模型与嵌入模型 openai==1.6.1 tiktoken==0.5.2 # 向量数据库 chromadb==0.4.22 # 文档加载与处理 pypdf==3.17.4 python-docx==1.1.0 unstructured==0.12.2 langchain-text-splitters==0.0.1 # Web 框架 (用于构建简单API) fastapi==0.104.1 uvicorn[standard]==0.24.0 # 环境变量管理 python-dotenv==1.0.0

版本说明：LangChain 版本迭代较快，0.1.x是一个重要的稳定版本，其模块化程度更高（如将langchain拆分为langchain-core,langchain-community等）。本文示例基于此版本结构编写，与旧版（如0.0.x）的导入方式有较大差异，请特别注意。

2.3 可选：本地大模型部署如果你想完全本地运行，避免使用 OpenAI 等云端 API，可以使用Ollama运行本地模型。

• Ollama：一个强大的本地大模型运行和管理的工具。
• 常用模型：llama2,mistral,qwen等。
• 安装后，通过ollama pull llama2:7b下载模型，LangChain 可通过langchain-community中的ChatOllama类来调用。

2.4 项目结构预览在开始编码前，先规划好我们的项目目录，这有助于保持代码清晰。

langchain-rag-agent-project/ ├── .env # 存储API密钥等敏感信息 ├── requirements.txt # 项目依赖 ├── app.py # 主应用入口或FastAPI应用 ├── core/ # 核心业务逻辑 │ ├── __init__.py │ ├── config.py # 配置管理 │ ├── document_loader.py # 文档加载与处理 │ ├── vector_store.py # 向量数据库相关操作 │ └── chains.py # 定义各种Chain ├── agents/ # Agent相关逻辑 │ ├── __init__.py │ └── custom_agent.py # 自定义Agent ├── tools/ # 自定义工具 │ ├── __init__.py │ └── calculator.py # 示例：计算器工具 ├── data/ # 存放原始文档 │ └── your_document.pdf └── chroma_db/ # Chroma向量数据库持久化目录（自动生成）

3. 核心组件拆解：LangChain 的五大基石

理解 LangChain 的抽象概念是灵活运用的关键。我们将其核心拆解为五个部分。

3.1 Models (模型)这是与 LLM 交互的入口。LangChain 提供了统一的接口。

• ChatModels：用于对话模型（如 GPT-4, Claude）。
• LLMs：用于文本补全模型（如 text-davinci-003）。
• Embeddings：用于将文本转换为向量。

# core/config.py import os from langchain_openai import ChatOpenAI, OpenAIEmbeddings from dotenv import load_dotenv load_dotenv() # 从 .env 文件加载环境变量 # 初始化聊天模型 llm = ChatOpenAI( model="gpt-3.5-turbo", temperature=0, # 控制随机性，0表示更确定性的输出 openai_api_key=os.getenv("OPENAI_API_KEY") ) # 初始化嵌入模型 embeddings = OpenAIEmbeddings( model="text-embedding-3-small", openai_api_key=os.getenv("OPENAI_API_KEY") ) # 如果是本地模型，例如使用 Ollama # from langchain_community.chat_models import ChatOllama # llm = ChatOllama(model="llama2:7b")

3.2 Prompts (提示词)管理与大模型交互的指令模板。好的提示词是成功的一半。

• PromptTemplate：基础模板。
• ChatPromptTemplate：更适合对话场景，可以包含SystemMessagePromptTemplate,HumanMessagePromptTemplate等。

from langchain.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate # 定义一个用于RAG的提示词模板 system_template = """ 你是一个专业的助手，请严格根据以下上下文信息来回答问题。 如果上下文信息中没有相关答案，请直接说“根据提供的资料，我无法回答这个问题”，不要编造信息。 上下文： {context} """ system_message_prompt = SystemMessagePromptTemplate.from_template(system_template) human_template = "{question}" human_message_prompt = HumanMessagePromptTemplate.from_template(human_template) chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt]) # 使用模板 formatted_prompt = chat_prompt.format(context="... retrieved documents ...", question="用户的问题是什么？")

3.3 Indexes (索引) - RAG 的核心这涉及文档加载、文本分割、向量化存储和检索。

• Document Loaders：从各种源（PDF, Web, DB）加载文档。
• Text Splitters：将长文档分割成适合模型上下文窗口的小块。
• Vectorstores：存储和检索向量。

# core/document_loader.py from langchain_community.document_loaders import PyPDFLoader, TextLoader from langchain.text_splitter import RecursiveCharacterTextSplitter def load_and_split_documents(file_path: str): """加载PDF文档并进行智能分割""" loader = PyPDFLoader(file_path) documents = loader.load() # 递归字符分割器：按字符递归分割，尽量保持段落和句子的完整性 text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, # 每个块的最大字符数 chunk_overlap=50, # 块之间的重叠字符，避免信息割裂 separators=["\n\n", "\n", "。", "！", "？", "；", "，", " ", ""] # 分割优先级 ) split_docs = text_splitter.split_documents(documents) print(f"原始文档数: {len(documents)}， 分割后块数: {len(split_docs)}") return split_docs

3.4 Chains (链)将多个组件按顺序组合起来，形成一个工作流。这是 LangChain 编排能力的体现。

• LLMChain：最基本的链，组合一个 PromptTemplate 和一个 LLM。
• SequentialChain：按顺序执行多个链。
• RetrievalQA：一个封装好的、用于问答的链，内部集成了检索器。

# core/chains.py from langchain.chains import RetrievalQA from langchain.prompts import PromptTemplate from .vector_store import get_vector_store # 假设我们有一个获取向量库的函数 def create_rag_chain(llm, embeddings, persist_directory="./chroma_db"): """创建并返回一个RAG问答链""" vectorstore = get_vector_store(embeddings, persist_directory) retriever = vectorstore.as_retriever(search_kwargs={"k": 3}) # 检索最相关的3个片段 # 自定义提示词 qa_prompt = PromptTemplate.from_template( """请根据以下上下文信息回答问题。如果你不知道答案，就说不知道，不要试图编造答案。 上下文：{context} 问题：{question} 答案：""" ) qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", # 将检索到的所有文档“塞”进上下文 retriever=retriever, chain_type_kwargs={"prompt": qa_prompt}, return_source_documents=True # 返回源文档，便于溯源 ) return qa_chain

3.5 Agents (代理) & Tools (工具)让模型学会使用工具。这是实现复杂任务自动化的关键。

• Tools：一个可调用的函数，包含名称、描述和参数。模型根据描述决定是否及如何调用它。
• Agent：一个由 LLM 驱动的实体，它根据目标、工具和历史，决定下一步行动（调用哪个工具，传入什么参数）。

# tools/calculator.py from langchain.tools import tool import math @tool def calculator(expression: str) -> str: """一个简单的计算器工具。输入一个数学表达式字符串（如 '3 + 5 * 2'），返回计算结果。只支持基本算术和math库函数。""" try: # 警告：直接使用eval有安全风险，仅用于演示。生产环境需使用安全评估库如 `asteval`。 # 这里进行简单过滤，仅允许数字、运算符和部分math函数 allowed_chars = set("0123456789+-*/(). sqrt cos sin tan log pi e ") if not all(c in allowed_chars for c in expression): return "错误：表达式包含不安全字符。" result = eval(expression, {"__builtins__": None}, math.__dict__) return str(result) except Exception as e: return f"计算错误: {e}" # agents/custom_agent.py from langchain.agents import AgentExecutor, create_react_agent from langchain import hub from core.config import llm # 导入之前定义的llm from tools.calculator import calculator def create_calculator_agent(): """创建一个可以使用计算器工具的智能体""" # 从LangChain Hub拉取一个预设的提示词（ReAct格式） prompt = hub.pull("hwchase17/react") # 定义工具列表 tools = [calculator] # 创建ReAct智能体 agent = create_react_agent(llm, tools, prompt) # 创建执行器 agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, # 打印详细的思考过程 handle_parsing_errors=True # 优雅地处理解析错误 ) return agent_executor

4. 完整实战案例：构建企业级知识库问答与智能体系统

现在，我们将把所有组件串联起来，构建两个核心应用：1) 一个基于私有文档的 RAG 问答系统；2) 一个能使用工具的智能体。

4.1 第一步：初始化项目与环境变量

# 创建项目目录并进入 mkdir langchain-rag-agent-project && cd langchain-rag-agent-project # 创建虚拟环境 (Python 3.9) python -m venv venv # 激活虚拟环境 # Linux/macOS source venv/bin/activate # Windows venv\Scripts\activate # 安装依赖 pip install -r requirements.txt

创建.env文件，存放你的密钥（切勿提交到版本控制）：

# .env OPENAI_API_KEY=sk-your-openai-api-key-here # 如果使用其他模型，添加对应的密钥，如 ANTHROPIC_API_KEY, GROQ_API_KEY 等

4.2 第二步：构建 RAG 知识库系统我们将实现一个完整的流程：加载PDF -> 分割 -> 向量化 -> 存储 -> 检索问答。

# core/vector_store.py import os from langchain_chroma import Chroma from langchain_community.document_loaders import DirectoryLoader, PyPDFLoader from langchain.text_splitter import RecursiveCharacterTextSplitter def create_and_persist_vectorstore(embeddings, data_path="./data", persist_directory="./chroma_db"): """ 从指定目录加载文档，创建向量库并持久化。 如果向量库已存在，则直接加载。 """ # 检查是否已存在持久化的向量库 if os.path.exists(persist_directory) and os.listdir(persist_directory): print(f"加载已存在的向量库从 {persist_directory}") return Chroma(persist_directory=persist_directory, embedding_function=embeddings) # 1. 加载文档 print("开始加载文档...") loader = DirectoryLoader( data_path, glob="**/*.pdf", # 加载所有PDF文件，也可以添加 "**/*.txt", "**/*.docx" loader_cls=PyPDFLoader, show_progress=True ) documents = loader.load() if not documents: raise ValueError(f"在 {data_path} 目录下未找到任何PDF文档。") # 2. 分割文档 print("开始分割文档...") text_splitter = RecursiveCharacterTextSplitter( chunk_size=1000, chunk_overlap=200, separators=["\n\n", "\n", "。", "！", "？", "；", "，", " ", ""] ) splits = text_splitter.split_documents(documents) print(f"共加载 {len(documents)} 个文档，分割为 {len(splits)} 个文本块。") # 3. 创建并持久化向量库 print("开始创建向量库...") vectorstore = Chroma.from_documents( documents=splits, embedding=embeddings, persist_directory=persist_directory ) vectorstore.persist() print(f"向量库已创建并持久化到 {persist_directory}") return vectorstore def get_vector_store(embeddings, persist_directory="./chroma_db"): """获取向量库实例（如果不存在则创建）""" return Chroma(persist_directory=persist_directory, embedding_function=embeddings)

4.3 第三步：创建问答链并测试

# app_rag.py import sys sys.path.append('.') from core.config import llm, embeddings from core.chains import create_rag_chain from core.vector_store import create_and_persist_vectorstore def main(): # 1. 创建/加载向量知识库 (首次运行会处理文档，较慢) print("初始化知识库...") vectorstore = create_and_persist_vectorstore(embeddings, data_path="./data") # 2. 创建RAG问答链 print("创建问答链...") qa_chain = create_rag_chain(llm, embeddings) # 3. 交互式问答 print("\n===== 企业知识库问答系统已就绪 =====") print("输入 'exit' 或 'quit' 退出程序。") while True: question = input("\n请输入您的问题: ").strip() if question.lower() in ['exit', 'quit']: print("再见！") break if not question: continue try: # 执行问答 result = qa_chain.invoke({"query": question}) answer = result["result"] sources = result.get("source_documents", []) print(f"\n答案: {answer}") if sources: print("\n参考来源:") for i, doc in enumerate(sources[:2]): # 显示前两个来源 print(f" [{i+1}] {doc.metadata.get('source', '未知')} (页码: {doc.metadata.get('page', 'N/A')})") # print(f" 片段: {doc.page_content[:200]}...") # 可选：预览内容 except Exception as e: print(f"查询过程中出现错误: {e}") if __name__ == "__main__": main()

运行测试：

1. 将你的企业文档（如product_manual.pdf）放入./data目录。
2. 运行python app_rag.py。
3. 首次运行会进行文档处理和向量化，需要一些时间。
4. 之后，你就可以针对文档内容提问了。

4.4 第四步：构建多功能智能体 (Agent)我们将创建一个更强大的智能体，它不仅能回答知识库问题，还能使用计算器、搜索（模拟）等工具。

# tools/search_tool.py from langchain.tools import tool import requests @tool def search_web(query: str) -> str: """一个模拟的网络搜索工具。输入搜索关键词，返回模拟的搜索结果摘要。""" # 注意：这是一个模拟工具。真实场景可以集成 SerperAPI、Google Search API 等。 # 这里我们返回一个固定的模拟结果。 mock_results = { "天气": "北京今天晴，气温15-25度。", "新闻": "今日科技头条：AI芯片取得新突破。", "LangChain": "LangChain是一个用于开发大语言模型应用的框架。", } return mock_results.get(query, f"未找到关于 '{query}' 的模拟信息。") # agents/multi_tool_agent.py from langchain.agents import AgentExecutor, create_react_agent from langchain import hub from core.config import llm from core.chains import create_rag_chain from tools.calculator import calculator from tools.search_tool import search_web def create_multi_tool_agent(rag_chain): """创建一个结合了RAG、计算器和搜索工具的智能体""" # 1. 将RAG链包装成一个工具 from langchain.tools import Tool def rag_qa_tool(question: str) -> str: """一个基于企业知识库的问答工具。当问题涉及公司产品、政策、流程时使用此工具。""" result = rag_chain.invoke({"query": question}) return result["result"] rag_tool = Tool( name="Company_Knowledge_Base", func=rag_qa_tool, description="当用户询问关于公司产品、服务、政策、内部流程或文档内容时，使用此工具。" ) # 2. 定义工具列表 tools = [rag_tool, calculator, search_web] # 3. 创建智能体 prompt = hub.pull("hwchase17/react") agent = create_react_agent(llm, tools, prompt) # 4. 创建执行器 agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, handle_parsing_errors=True, max_iterations=5 # 限制最大迭代次数，防止死循环 ) return agent_executor # app_agent.py import sys sys.path.append('.') from core.config import llm, embeddings from core.chains import create_rag_chain from agents.multi_tool_agent import create_multi_tool_agent def main(): print("初始化智能体系统...") # 1. 创建RAG链（复用之前的逻辑） qa_chain = create_rag_chain(llm, embeddings) # 2. 创建多功能智能体 agent_executor = create_multi_tool_agent(qa_chain) print("\n===== 多功能智能体已启动 =====") print("我可以：1) 回答公司知识库问题；2) 进行数学计算；3) 搜索简单信息。") print("输入 'exit' 退出。") while True: user_input = input("\n您有什么需要？: ").strip() if user_input.lower() in ['exit', 'quit']: break try: response = agent_executor.invoke({"input": user_input}) print(f"\n最终回答: {response['output']}") except Exception as e: print(f"智能体执行出错: {e}") if __name__ == "__main__": main()

运行智能体：

1. 确保 RAG 知识库已构建完成。
2. 运行python app_agent.py。
3. 尝试提问：“我们公司产品的保修期是多久？”（触发 RAG 工具）
4. 尝试提问：“计算一下 125 的平方根加上 50 是多少？”（触发计算器工具）
5. 尝试提问：“今天北京的天气怎么样？”（触发搜索工具） 观察控制台输出的Thought、Action、Observation步骤，理解智能体的思考过程。

5. 常见问题与排查思路

在实际开发中，你一定会遇到各种问题。以下是高频问题及解决方案。

6. 最佳实践与工程建议

将原型转化为稳定、可维护的企业级应用，需要遵循以下工程实践。

6.1 配置与密钥管理

• 永远不要硬编码密钥：使用.env文件和环境变量。
• 使用配置类：创建一个config.py集中管理所有配置项（模型名称、温度、块大小等），便于不同环境（开发/测试/生产）切换。
• 考虑使用配置中心：在微服务架构中，可以考虑使用 Apollo、Nacos 等管理 LLM 相关配置。

6.2 性能优化

• 缓存：对频繁相同的查询结果进行缓存。LangChain 支持InMemoryCache、RedisCache等。

  from langchain.globals import set_llm_cache from langchain.cache import InMemoryCache set_llm_cache(InMemoryCache())

• 异步调用：对于 I/O 密集型操作（如调用 API、检索向量库），使用异步接口 (ainvoke,astream) 提升并发性能。
• 批处理：当需要处理大量文档或进行批量问答时，使用模型的批处理接口。

6.3 可观测性与日志

• 结构化日志：使用logging模块，记录关键步骤（文档加载、分割数量、检索耗时、模型调用耗时、Token 使用量）。
• LangSmith：这是 LangChain 官方提供的追踪和调试平台。它能可视化整个 Chain 或 Agent 的执行流程，是排查复杂问题的利器。只需设置环境变量LANGCHAIN_TRACING_V2=true和LANGCHAIN_API_KEY。
• 监控与告警：在生产环境，监控 API 调用延迟、错误率、Token 消耗成本，并设置告警。

6.4 生产环境部署

• API 服务化：使用 FastAPI 或 Flask 将你的 RAG/Agent 逻辑封装成 RESTful API。

  # main.py (FastAPI 示例) from fastapi import FastAPI, HTTPException from pydantic import BaseModel from core.config import llm, embeddings from core.chains import create_rag_chain app = FastAPI() qa_chain = create_rag_chain(llm, embeddings) # 启动时加载，避免每次请求重复初始化 class QueryRequest(BaseModel): question: str @app.post("/ask") async def ask_question(request: QueryRequest): try: result = qa_chain.invoke({"query": request.question}) return {"answer": result["result"], "sources": result.get("source_documents", [])} except Exception as e: raise HTTPException(status_code=500, detail=str(e))

• 容器化：使用 Docker 打包应用，确保环境一致性。
• 健康检查与就绪探针：在 Kubernetes 或 Docker Compose 部署中，为你的服务添加健康检查端点。
• 限流与熔断：使用 API 网关或slowapi等库对接口进行限流，防止被误刷或攻击。

6.5 安全与合规

• 输入输出过滤：对用户输入进行必要的清洗和过滤，防止 Prompt 注入攻击。对模型输出进行审查，避免生成有害或不适当内容。
• 数据隐私：如果使用云端模型 API，确保传输和处理的文档数据不涉及敏感信息，或与云服务商签订数据处理协议（DPA）。对于极高敏感数据，坚持使用本地模型。
• 访问控制：为你的智能应用 API 添加认证和授权机制。

掌握 LangChain、RAG 与 Agent 的核心原理与实战技能，已经成为当今 AI 应用开发者的关键竞争力。本文从概念解析到环境搭建，从核心组件拆解到两个完整项目实战（企业知识库问答系统与多功能智能体），为你提供了一条清晰的学习路径。更重要的是，我们探讨了企业级应用中必然会遇到的性能、安全、部署等工程化问题。

技术的价值在于解决实际问题。建议你以本文的代码为起点，尝试将其应用到你的具体业务场景中：也许是内部技术文档的智能查询，也许是结合 CRM 数据的销售辅助助手，或者是自动化的客户工单分类与处理流程。在实践过程中，你会更深入地理解如何调优检索策略、设计更有效的工具、以及构建更鲁棒的智能体工作流。

下一步，你可以继续探索：

• LangGraph：用于构建有状态、多参与者的复杂 Agent 工作流（如模拟辩论、多步骤审批）。
• 高级检索技巧：如混合检索（结合关键词与向量）、重排序（Rerank）以提升精度。
• 智能体评估：如何定量评估你的 RAG 或 Agent 系统的效果。
• 多模态 RAG：处理图像、表格等非文本信息。

学习资料方面，除了官方文档，多关注 LangChain 的 GitHub 仓库和 Discord 社区，那里有最前沿的讨论和示例。记住，这个领域迭代飞快，保持动手实践和持续学习是最好的方式。如果在实践中遇到新的问题，欢迎在评论区交流探讨。