🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

大家好，我是专注于AI应用落地的技术博主。在探索如何将大语言模型（LLM）真正融入生产系统的过程中，我们常常会遇到一个核心矛盾：模型的知识是静态的，而世界是动态的。传统的RAG（检索增强生成）系统虽然能接入外部知识库，但其“检索-生成”的流程相对固定，面对复杂、多步骤的查询时往往力不从心。今天，我们就来深入探讨如何构建一个工程化、具备Agent（智能体）能力的RAG系统，让它不仅能查询本地文档，还能像人类一样思考、规划、调用工具（如Google搜索），并最终交付一个可信、可观测、可维护的生产级AI应用。

本文将从零开始，手把手带你搭建一个Agentic RAG系统。我们将覆盖从核心概念、架构设计、代码实现到生产环境部署的全流程。无论你是想了解Agentic RAG前沿动态的开发者，还是正面临如何将AI原型转化为稳定服务的工程师，这篇文章都将提供一套完整的闭环解决方案。

1. 背景与核心概念：从RAG到Agentic RAG

在深入代码之前，我们必须厘清几个关键概念，理解为什么需要Agentic RAG。

1.1 传统RAG的局限性传统RAG的工作流程可以简化为：用户提问 -> 将问题向量化 -> 从向量数据库中检索最相关的N个文档片段 -> 将问题和片段一起交给LLM生成答案。这个流程存在几个明显短板：

• 被动检索：它只能从预设的、静态的知识库中寻找答案。如果知识库中没有相关信息，系统就会“胡说八道”或表示不知道，无法主动去外部寻找。
• 缺乏规划：对于需要多步推理或分解的复杂问题（例如：“对比一下LangChain和LlamaIndex的最新版本特性，并给出项目选型建议”），简单的检索-生成模式难以胜任。
• 上下文僵化：检索到的片段直接拼接到提示词中，如果片段过多或无关信息干扰，会严重影响生成质量。

1.2 什么是AI Agent？AI Agent（智能体）是一个能够感知环境、进行决策并执行行动以实现目标的系统。在LLM语境下，一个Agent通常由以下几部分组成：

• 规划（Planning）：将复杂目标分解为可执行的子任务序列。
• 记忆（Memory）：存储过去的交互、工具调用结果和知识，用于后续决策。
• 工具使用（Tool Use）：调用外部API、函数或服务来获取信息或执行操作（如计算、搜索、写数据库）。
• 行动（Action）：执行规划好的步骤。

1.3 Agentic RAG：两者的融合Agentic RAG就是将Agent的规划、决策和工具调用能力赋予RAG系统。它不再是被动地检索固定知识库，而是像一个“研究助理”：

1. 理解意图：分析用户问题的深层需求。
2. 制定计划：决定是否需要搜索外部信息、查询内部知识库、进行多轮对话或计算。
3. 执行工具：按计划调用相应的工具（如Google搜索API、内部数据库查询、代码执行器）。
4. 合成与验证：将多个工具返回的结果进行综合、去重、验证，最终生成一个准确、全面、可追溯的答案。

1.4 为什么强调“工程化”与“可信”？构建一个在实验室能跑的Agent原型不难，但要将其部署到生产环境，面临诸多挑战：

• 可靠性：工具调用可能失败，网络可能超时，LLM可能生成错误格式。
• 可观测性：我们需要清晰地知道Agent在每一步做了什么决策、调用了什么工具、得到了什么结果，以便调试和审计。
• 成本控制：每一次工具调用和LLM调用都可能产生费用，需要优化流程，避免不必要的调用。
• 安全性：限制Agent可调用的工具范围，防止其执行危险操作或访问敏感数据。

接下来，我们将围绕这些挑战，构建一个生产导向的Agentic RAG系统。

2. 环境准备与版本说明

我们将使用Python作为开发语言，并依托于几个成熟的框架来加速开发。请注意，AI领域迭代迅速，以下版本是一个稳定的组合，你可以根据实际情况调整。

操作系统: Ubuntu 20.04+/macOS Monterey+/Windows 10+ (WSL2推荐)Python: 3.10 或 3.11 (强烈推荐，兼容性最佳)核心框架与库:

• langchain==0.1.0： 用于构建Agent和链的核心框架。注意，LangChain版本更新频繁，API变化较大，本文基于相对稳定的0.1.x版本。
• langchain-community==0.0.10： 包含社区维护的各种工具和集成。
• langchain-openai==0.0.5： OpenAI模型的LangChain集成。
• openai==1.6.1： OpenAI官方SDK。
• chromadb==0.4.22： 轻量级向量数据库，用于存储和检索本地知识。
• tiktoken==0.5.2： 用于计算Token，管理成本。
• python-dotenv==1.0.0： 管理环境变量。
• httpx==0.25.2： 用于异步HTTP请求（某些工具需要）。

外部服务API Key:

• OpenAI API Key: 用于调用GPT-4或GPT-3.5-Turbo作为Agent的“大脑”。
• Google Custom Search JSON API Key & Search Engine ID: 用于实现Google搜索工具。你需要在Google Cloud Console创建项目并启用Custom Search API来获取。

项目结构预览:

agentic_rag_project/ ├── .env # 存储API密钥等敏感信息 ├── requirements.txt # 项目依赖 ├── app.py # 主应用入口 ├── core/ # 核心模块 │ ├── __init__.py │ ├── agent_builder.py # Agent构建逻辑 │ ├── tools.py # 自定义工具定义 │ └── memory.py # 记忆管理 ├── knowledge_base/ # 本地知识库管理 │ ├── __init__.py │ ├── loader.py # 文档加载 │ ├── splitter.py # 文本分割 │ └── vector_store.py # 向量库初始化与检索 └── utils/ # 工具函数 ├── __init__.py ├── callback.py # 回调函数，用于日志和观测 └── safety.py # 安全校验

首先，创建虚拟环境并安装依赖：

# 创建并激活虚拟环境 python -m venv venv source venv/bin/activate # Linux/macOS # venv\Scripts\activate # Windows # 安装依赖 pip install langchain==0.1.0 langchain-community==0.0.10 langchain-openai==0.0.5 openai==1.6.1 pip install chromadb==0.4.22 tiktoken==0.5.2 python-dotenv==1.0.0 httpx==0.25.2

创建.env文件，填入你的密钥：

# .env OPENAI_API_KEY=sk-your-openai-key-here GOOGLE_API_KEY=your-google-custom-search-api-key GOOGLE_CSE_ID=your-search-engine-id

3. 核心组件拆解：工具、记忆与规划

Agentic RAG系统的核心是让LLM学会使用工具。我们首先来定义几个关键工具。

3.1 构建工具（Tools）工具是Agent与外界交互的接口。每个工具都是一个函数，具有清晰的描述，供LLM理解其用途。

# core/tools.py import os from typing import Type, Optional from datetime import datetime from langchain.tools import BaseTool, Tool from langchain_community.utilities import GoogleSearchAPIWrapper from pydantic import BaseModel, Field import httpx class GoogleSearchInput(BaseModel): """Google搜索工具的输入模型。""" query: str = Field(description="用于搜索的查询字符串") class GoogleSearchTool(BaseTool): name: str = "google_search" description: str = ( "一个用于搜索互联网最新信息的工具。" "当问题涉及实时事件、新闻、最新技术动态或不在本地知识库中的公开信息时使用此工具。" "输入应为明确的搜索查询词。" ) args_schema: Type[BaseModel] = GoogleSearchInput search_wrapper: GoogleSearchAPIWrapper = None def __init__(self): super().__init__() # 初始化Google搜索包装器 self.search_wrapper = GoogleSearchAPIWrapper( google_api_key=os.getenv("GOOGLE_API_KEY"), google_cse_id=os.getenv("GOOGLE_CSE_ID"), k=5 # 返回5条结果 ) def _run(self, query: str) -> str: """执行同步搜索。""" try: results = self.search_wrapper.run(query) # 对结果进行精简和格式化 return f"【Google搜索】关于 '{query}' 的结果：\n{results[:1500]}" # 限制长度 except Exception as e: return f"搜索执行失败：{str(e)}" async def _arun(self, query: str) -> str: """异步搜索（可选）。""" return self._run(query) class KnowledgeBaseSearchInput(BaseModel): """知识库检索工具的输入模型。""" question: str = Field(description="需要从内部知识库中查找答案的问题") def get_knowledge_base_tool(vector_store): """创建知识库检索工具。""" from langchain.chains import RetrievalQA from langchain_openai import ChatOpenAI llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0) qa_chain = RetrievalQA.from_chain_type( llm=llm, chain_type="stuff", retriever=vector_store.as_retriever(search_kwargs={"k": 3}), return_source_documents=True ) def search_knowledge_base(question: str) -> str: """查询内部知识库。适用于公司文档、产品手册、历史对话等内部信息。""" result = qa_chain.invoke({"query": question}) answer = result.get("result", "未找到答案。") sources = result.get("source_documents", []) source_info = "\n".join([f"- {doc.metadata.get('source', '未知')}" for doc in sources[:2]]) return f"【内部知识库】答案：{answer}\n来源：{source_info}" return Tool( name="knowledge_base_search", func=search_knowledge_base, description="用于查询内部私有知识库的工具。当你需要获取公司内部文档、产品规格、流程指南等非公开信息时使用此工具。" ) class CalculatorInput(BaseModel): """计算器工具的输入模型。""" expression: str = Field(description="一个有效的数学表达式，例如 '3 + 5 * 2'") class CalculatorTool(BaseTool): name: str = "calculator" description: str = "用于计算数学表达式。仅支持基本算术（+， -， *， /， **）和括号。" args_schema: Type[BaseModel] = CalculatorInput def _run(self, expression: str) -> str: """计算表达式。警告：使用eval有安全风险，生产环境需替换为安全库如`ast.literal_eval`或自定义解析器。""" try: # ！！！生产环境切勿直接使用eval，此处仅为演示！！！ # 应使用安全计算库，如 `numexpr` 或严格限制的解析器 allowed_chars = set("0123456789+-*/.() ") if not all(c in allowed_chars for c in expression): return "错误：表达式包含非法字符。" result = eval(expression) return f"计算结果：{expression} = {result}" except Exception as e: return f"计算失败：{str(e)}"

关键点解析：

1. 输入模式（args_schema）：使用Pydantic模型定义工具输入，这能帮助LLM更准确地生成调用参数。
2. 描述（description）：必须清晰、具体。LLM根据描述决定是否以及如何使用该工具。好的描述应包含使用场景和输入格式。
3. 错误处理：工具内部必须包含try-except，返回友好的错误信息，避免整个Agent因单个工具失败而崩溃。
4. 安全警告：CalculatorTool中的eval是极不安全的，仅用于演示。真实生产环境必须使用安全的数学表达式解析库（如numexpr、ast.literal_eval配合严格检查）。

3.2 设计记忆（Memory）记忆让Agent拥有上下文感知能力。我们使用ConversationBufferWindowMemory来保存最近几轮对话。

# core/memory.py from langchain.memory import ConversationBufferWindowMemory from langchain.schema import BaseMessage from typing import List class ManagedMemory: def __init__(self, k=5): """ 初始化记忆管理器。 Args: k: 保留最近k轮对话。 """ self.memory = ConversationBufferWindowMemory( memory_key="chat_history", return_messages=True, k=k ) # 可扩展：在此添加长期记忆（如向量存储）的接口 def save_context(self, user_input: str, agent_output: str): """保存一轮对话的上下文。""" self.memory.save_context({"input": user_input}, {"output": agent_output}) def load_memory_variables(self, inputs: dict) -> dict: """加载记忆变量，通常用于构建提示词。""" return self.memory.load_memory_variables(inputs) def clear(self): """清空记忆。""" self.memory.clear()

3.3 规划与执行：构建Agent ExecutorLangChain提供了多种Agent类型。我们选择OPENAI_FUNCTIONSAgent，因为它与OpenAI的Function Calling特性结合紧密，能可靠地解析工具调用。

# core/agent_builder.py import os from langchain.agents import AgentExecutor, create_openai_functions_agent from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder from core.tools import GoogleSearchTool, get_knowledge_base_tool, CalculatorTool from core.memory import ManagedMemory def build_agent_executor(vector_store=None): """ 构建并返回一个配置好的Agent执行器。 Args: vector_store: 初始化好的向量数据库检索器，用于知识库工具。 Returns: AgentExecutor实例。 """ # 1. 初始化LLM llm = ChatOpenAI( model="gpt-4-1106-preview", # 或使用 "gpt-3.5-turbo-1106"，GPT-4规划能力更强 temperature=0, # 降低随机性，使工具调用更稳定 streaming=False, # 如需流式输出可设为True并配置回调 api_key=os.getenv("OPENAI_API_KEY") ) # 2. 准备工具列表 tools = [] # 添加Google搜索工具 tools.append(GoogleSearchTool()) # 添加计算器工具 tools.append(CalculatorTool()) # 如果提供了向量库，添加知识库检索工具 if vector_store: tools.append(get_knowledge_base_tool(vector_store)) # 3. 构建提示词模板 # 系统消息定义了Agent的角色和行为准则 system_message = """你是一个专业、可靠且高效的AI助手。你的核心能力是使用工具来获取信息并解决问题。 请遵循以下准则： 1. **充分规划**：在回答前，先思考用户问题的本质，判断是否需要以及需要哪些工具。 2. **按需调用**：优先使用内部知识库（如果可用）回答内部问题。对于实时、公开或未知信息，使用Google搜索。 3. **精确简洁**：工具调用时，查询词应具体、明确。整合多个工具的结果时，需注明来源。 4. **诚实可信**：如果工具无法提供答案或信息矛盾，如实告知用户，不要捏造信息。 5. **安全边界**：你只能使用上述提供的工具，不能执行任何未授权的操作。 """ prompt = ChatPromptTemplate.from_messages([ ("system", system_message), MessagesPlaceholder(variable_name="chat_history"), # 注入对话历史 ("human", "{input}"), # 用户当前输入 MessagesPlaceholder(variable_name="agent_scratchpad"), # Agent思考过程 ]) # 4. 创建Agent agent = create_openai_functions_agent(llm=llm, tools=tools, prompt=prompt) # 5. 初始化记忆 memory = ManagedMemory(k=5) # 6. 创建执行器 # `verbose=True` 会在控制台输出详细的推理步骤，生产环境应设为False # `handle_parsing_errors=True` 能优雅处理LLM输出格式错误 executor = AgentExecutor( agent=agent, tools=tools, memory=memory.memory, # 将LangChain memory对象传入 verbose=True, handle_parsing_errors=True, max_iterations=5, # 限制最大迭代次数，防止死循环 early_stopping_method="generate" # 当Agent认为已完成时停止 ) return executor, memory

代码解释：

• create_openai_functions_agent: 这是构建Agent的核心函数，它创建了一个懂得根据提示词和工具描述来规划并调用OpenAI格式函数的Agent。
• AgentExecutor: 这是驱动Agent运行的实际引擎。它负责管理Agent的思考循环：调用LLM -> 解析输出 -> 执行工具 -> 将结果返回给LLM -> 继续，直到LLM返回最终答案或达到max_iterations。
• max_iterations:至关重要的生产环境参数。必须设置上限，防止Agent陷入无限循环或因复杂问题消耗过多资源。

4. 完整实战案例：构建并运行一个多功能Agent

现在，我们将所有组件串联起来，创建一个具备Google搜索、内部知识库查询和计算能力的Agent。

4.1 初始化本地知识库首先，我们准备一些本地文档（例如公司产品手册的TXT文件），将其存入向量数据库。

# knowledge_base/vector_store.py from langchain_community.document_loaders import TextLoader, DirectoryLoader from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain_openai import OpenAIEmbeddings from langchain_community.vectorstores import Chroma import os def init_vector_store(knowledge_dir: str, persist_directory: str = "./chroma_db"): """ 初始化或加载向量数据库。 Args: knowledge_dir: 存放知识文档的目录。 persist_directory: 向量数据库持久化路径。 Returns: Chroma向量存储对象。 """ embeddings = OpenAIEmbeddings(model="text-embedding-3-small") if os.path.exists(persist_directory) and os.listdir(persist_directory): # 如果已存在持久化数据，则直接加载 print(f"从 {persist_directory} 加载已有向量库...") vector_store = Chroma( persist_directory=persist_directory, embedding_function=embeddings ) else: # 否则，从文档创建 print(f"从 {knowledge_dir} 创建新的向量库...") # 加载文档 loader = DirectoryLoader(knowledge_dir, glob="**/*.txt", loader_cls=TextLoader) documents = loader.load() if not documents: print("警告：未加载到任何文档。知识库工具将不可用。") return None # 分割文本 text_splitter = RecursiveCharacterTextSplitter( chunk_size=500, chunk_overlap=50, separators=["\n\n", "\n", "。", "！", "？", "；"] ) splits = text_splitter.split_documents(documents) print(f"共加载 {len(documents)} 个文档，分割为 {len(splits)} 个片段。") # 创建向量存储并持久化 vector_store = Chroma.from_documents( documents=splits, embedding=embeddings, persist_directory=persist_directory ) vector_store.persist() print(f"向量库已创建并保存至 {persist_directory}") return vector_store

4.2 主应用入口创建一个简单的交互式命令行应用来测试我们的Agent。

# app.py import os from dotenv import load_dotenv from core.agent_builder import build_agent_executor from knowledge_base.vector_store import init_vector_store # 加载环境变量 load_dotenv() def main(): print("正在初始化Agentic RAG系统...") # 1. 初始化知识库（可选） vector_store = None knowledge_dir = "./knowledge_docs" # 你的文档目录 if os.path.exists(knowledge_dir): vector_store = init_vector_store(knowledge_dir) else: print(f"知识库目录 '{knowledge_dir}' 不存在，将仅使用搜索和计算工具。") # 2. 构建Agent执行器 agent_executor, memory_manager = build_agent_executor(vector_store) print("\n" + "="*50) print("Agent已就绪。输入您的问题（输入 'quit' 或 'exit' 退出）：") print("="*50) # 3. 交互循环 while True: try: user_input = input("\n>>> 您: ").strip() if user_input.lower() in ['quit', 'exit', 'q']: print("再见！") break if not user_input: continue # 调用Agent response = agent_executor.invoke({"input": user_input}) answer = response.get("output", "抱歉，我没有得到有效回复。") # 保存本轮对话到记忆 memory_manager.save_context(user_input, answer) # 打印最终答案 print(f"\n>>> AI: {answer}") except KeyboardInterrupt: print("\n\n程序被中断。") break except Exception as e: print(f"\n>>> 系统错误: {str(e)}") # 可以选择记录日志 if __name__ == "__main__": main()

4.3 运行与验证

1. 在项目根目录创建knowledge_docs文件夹，并放入一些.txt格式的文档（例如product_manual.txt）。
2. 确保.env文件已正确配置。
3. 运行程序：python app.py

测试用例：

>>> 您: 今天北京的天气怎么样？

• 预期行为：Agent应识别这是一个实时信息问题，调用google_search工具，搜索“北京 今天 天气”，并返回摘要。

>>> 您: 我们公司产品的退货政策是什么？

• 预期行为：如果product_manual.txt中包含了退货政策，Agent应优先调用knowledge_base_search工具，从本地知识库中寻找答案。

>>> 您: 请计算 (15 + 7) * 3 / 2 的值，然后搜索一下LangChain最新版本的主要更新。

• 预期行为：Agent应规划两个子任务。首先调用calculator工具计算表达式，然后调用google_search工具搜索“LangChain latest version updates”。最后将两个结果整合成一个连贯的回答。

通过观察控制台verbose=True的输出，你可以清晰地看到Agent的思考链（Reasoning Chain）：

> Entering new AgentExecutor chain... 思考：用户问了两个问题，一个计算，一个搜索。我需要按顺序使用计算器和搜索工具。 行动：调用计算器工具。 行动输入：{"expression": "(15 + 7) * 3 / 2"} 观察：计算结果：(15 + 7) * 3 / 2 = 33.0 思考：计算完成。现在需要搜索LangChain更新。 行动：调用google_search工具。 行动输入：{"query": "LangChain latest version updates 2024"} 观察：【Google搜索】关于 'LangChain latest version updates 2024' 的结果：... 思考：我已获得计算结果和搜索信息，可以合成最终答案。 最终答案：计算结果为33。关于LangChain最新版本... > Finished chain.

5. 生产级考量：可观测性、安全与成本控制

一个原型能跑起来只是第一步。要将其投入生产，必须解决可靠性、可观测性和成本问题。

5.1 实现可观测性（Observability）我们需要记录Agent的每一步决策和工具调用结果，用于监控、调试和审计。

# utils/callback.py from langchain.callbacks.base import BaseCallbackHandler from typing import Any, Dict, List import json import logging from datetime import datetime class AgentMonitorCallback(BaseCallbackHandler): """自定义回调处理器，用于记录Agent执行详情。""" def __init__(self): self.logger = logging.getLogger("agent_monitor") handler = logging.FileHandler('agent_execution.log', encoding='utf-8') formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) self.logger.addHandler(handler) self.logger.setLevel(logging.INFO) def on_agent_action(self, action, **kwargs): """当Agent决定调用一个工具时触发。""" tool_name = action.tool tool_input = json.dumps(action.tool_input, ensure_ascii=False) log_msg = f"AGENT_ACTION - 调用工具: {tool_name}, 输入: {tool_input}" self.logger.info(log_msg) print(f"[监控] {log_msg}") # 也可输出到控制台 def on_tool_end(self, output: str, **kwargs): """当工具执行结束时触发。""" # 注意：输出可能很长，生产环境可能需要截断或采样 output_preview = (output[:200] + '...') if len(output) > 200 else output log_msg = f"TOOL_END - 工具输出预览: {output_preview}" self.logger.info(log_msg) def on_agent_finish(self, finish, **kwargs): """当Agent完成一轮推理时触发。""" final_output = finish.return_values.get('output', '') log_msg = f"AGENT_FINISH - 最终输出长度: {len(final_output)} 字符" self.logger.info(log_msg) # 可以记录更详细的结果到结构化存储（如数据库） # 在构建执行器时注入回调 def build_agent_executor(vector_store=None): # ... 前面的代码 ... callbacks = [AgentMonitorCallback()] # 可以添加多个回调 executor = AgentExecutor( agent=agent, tools=tools, memory=memory.memory, verbose=False, # 生产环境关闭verbose，用自定义回调记录 callbacks=callbacks, # 注入回调 handle_parsing_errors=True, max_iterations=5, ) return executor, memory

5.2 增强安全性

1. 工具权限控制：为不同用户或场景的Agent配置不同的工具集。例如，客服Agent可能不需要计算器。
2. 输入输出过滤：对用户输入和工具输出进行内容安全过滤，防止注入攻击或不当内容。
3. 沙箱环境：对于执行代码或访问敏感系统的工具，必须在严格的沙箱环境中运行。
4. 替换不安全的eval：如前所述，使用numexpr等安全库。

# utils/safety.py import re def sanitize_input(user_input: str) -> tuple[bool, str]: """ 简单的输入清洗与安全检查。 Returns: (是否安全, 清洗后的输入或错误信息) """ # 1. 长度限制 if len(user_input) > 2000: return False, "输入过长，请精简您的问题。" # 2. 简单关键词过滤（示例） dangerous_patterns = [r"sudo", r"rm -rf", r"drop database", r"<script>"] # 根据需求扩展 for pattern in dangerous_patterns: if re.search(pattern, user_input, re.IGNORECASE): return False, "输入包含潜在危险指令。" # 3. 去除首尾空白 sanitized = user_input.strip() if not sanitized: return False, "输入不能为空。" return True, sanitized

5.3 成本控制与优化

1. 设置预算与熔断：为API调用设置月度或单次会话预算，超出后自动降级或拒绝服务。
2. 缓存策略：对频繁查询的、结果不变的工具调用（如某些知识库查询、特定计算）进行缓存。
3. 优化提示词：精简系统提示词和上下文，减少不必要的Token消耗。
4. 选择合适模型：对于简单工具调用，使用gpt-3.5-turbo；对于复杂规划，使用gpt-4。可以通过一个路由逻辑动态选择。
5. 限制迭代次数：max_iterations是控制单次调用成本的最有效手段。

6. 常见问题与排查思路

在开发和部署Agentic RAG系统时，你可能会遇到以下典型问题：

7. 最佳实践与工程建议

1. 提示词工程是核心：Agent的表现极大程度上依赖于系统提示词。迭代优化你的提示词，使其清晰、具体，并包含角色定义、行为约束和输出格式要求。可以将提示词模板化，便于A/B测试和管理。
2. 工具设计原则：
   • 单一职责：每个工具只做一件事，并做好。
   • 健壮性：工具必须包含全面的错误处理，返回结构化的结果（成功/失败+数据/错误信息）。
   • 可观测性：为工具调用添加唯一的请求ID，便于全链路追踪。
3. 实施分层记忆系统：
   • 短期记忆：ConversationBufferWindowMemory，用于维持对话流畅性。
   • 长期记忆：将重要的用户信息、对话摘要或事实存入向量数据库，供未来检索。
   • 外部记忆：与用户数据库、CRM等系统连接，实现个性化服务。
4. 建立评估体系：定义一组测试用例（单元测试和集成测试），定期运行以评估Agent的准确性、可靠性和成本。监控关键指标：平均响应时间、工具调用成功率、LLM Token消耗、用户满意度。
5. 渐进式部署：
   • 先从封闭领域、低风险的场景开始（如内部知识问答）。
   • 引入人工审核环节，对Agent的决策进行复核。
   • 逐步开放更复杂的工具和场景，并密切监控。
6. 版本化与回滚：对Agent的配置（提示词、工具列表、模型版本、参数）进行版本控制。当新版本出现问题时，能快速回滚到稳定版本。

构建工程化的Agentic RAG系统是一个持续迭代的过程。从简单的工具调用开始，逐步引入更复杂的规划逻辑（如ReAct模式）、子Agent协作、以及从失败中学习的机制。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度