Agent - 介绍

1.问题优化

• 时间优化：今天、本周、上个月、去年等，能够提炼出准确的时间范围。易错12/29、跨月的本周上周。

• 人员信息优化：姓名重名时的处理方式，

  提取人员信息 可能形式 姓名、工号，如果是姓名+工号的 也要拆开成两个 比如 韩立9910001  识别为 ["韩立","9910001"]
  如果涉及"我" 则使用 {{#currentUser#}}

优化结果示例

用户: xxx
时间范围: xxx
目的: xxx
条件: 状态条件=、人员条件=、时间范围等
返回数据格式:

2.问题分类

• 调用Skill
• 调用MCP
• 调用Tool

3.领域关键词提取

• 对于特定的状态、属性值等，能够准确分析并提取

4.会话历史管理

• 用户持续的对话，怎么控制上下文的大小，拾取有效信息

5.决策机制

• 决定历史会话记录哪些是和本次对话有效的
• 在执行前验证带执行的sql

总结输出

6.循环控制

• 避免

Agent方案

记忆与学习机制

ReAct（Reasoning + Acting）是当前最流行的Agent推理模式之一。与传统大模型对话不同，ReAct通过“思考-行动-观察”的循环机制，让AI像人类一样工作：先分析问题，选择合适的工具执行，观察结果后继续推理。

1. Thought（思考）：用户想要什么，需要调用那个工具？
2. Action（行动）：执行工具，LLM生成？
3. Observation（观察）：工具返回了什么？
4. Answer（回答）：基于结果回答用户

Agent

• 决策机制
• 记忆与学习机制
• 工具调用协议
• 闭环反馈机制 (执行监控与错误恢复)
• 状态管理与循环控制

五、Agent是如何思考的

5.1 ReAct模式：推理与行动循环

ReAct（Reasoning + Acting）是现代Agent的核心模式，它将Agent的执行分为三个环节：

1. Reasoning（推理）：分析当前状态，理解任务，决定下一步行动
2. Acting（行动）：执行选定的工具
3. Observing（观察）：收集工具执行结果，更新状态

这三个环节循环往复，直到任务完成。

实现机制

async def step(self) -> str:
    should_act = await self.think()  # 思考：分析并决策
    if not should_act:
        return "Thinking complete - no action needed"
    return await self.act()  # 行动：执行工具

这种设计的优势：

• 可解释性：每一步的思考过程都记录在对话历史中
• 可控性：可以在思考阶段进行干预和调整
• 可扩展性：可以轻松添加新的思考策略

5.2 LLM驱动的决策机制

提示词工程

Agent的思考能力主要依赖于精心设计的提示词：

System Prompt：定义Agent的角色和能力边界

SYSTEM_PROMPT = (
    "You are OpenManus, an all-capable AI assistant, aimed at solving any task "
    "presented by the user. You have various tools at your disposal that you can "
    "call upon to efficiently complete complex requests. Whether it's programming, "
    "information retrieval, file processing, web browsing, or human interaction "
    "(only for extreme cases), you can handle it all."
    "The initial directory is: {directory}"
)

Next Step Prompt：指导Agent如何选择工具

NEXT_STEP_PROMPT = """
Based on user needs, proactively select the most appropriate tool or combination
of tools. For complex tasks, you can break down the problem and use different tools
step by step to solve it. After using each tool, clearly explain the execution
results and suggest the next steps.

If you want to stop the interaction at any point, use the `terminate` tool/function call.
"""

工具描述：每个工具的name、description、parameters共同构成LLM决策的依据

LLM的function calling能力使得Agent能够进行结构化决策：

response = await self.llm.ask_tool(
    messages=self.messages,  # 完整的对话历史
    system_msgs=[Message.system_message(self.system_prompt)],
    tools=self.available_tools.to_params(),  # 工具schema列表
    tool_choice=self.tool_choices,  # 选择策略
)

LLM的处理过程：

1. 理解上下文：分析对话历史，理解当前任务状态
2. 评估工具：根据工具描述，评估哪些工具适合当前任务
3. 生成调用：生成结构化的工具调用，包含工具名称和参数
4. 参数验证：参数必须符合JSON Schema定义

LLM返回的格式：

{
    "content": "我需要先查看文件内容，然后进行编辑",  # 思考过程
    "tool_calls": [
        {
            "id": "call_abc123",
            "type": "function",
            "function": {
                "name": "str_replace_editor",
                "arguments": '{"command": "view", "path": "/path/to/file"}'
            }
        }
    ]
}

5.3 状态管理与循环控制

Agent的状态转换遵循明确的状态机：

class AgentState(str, Enum):
    IDLE = "IDLE"      # 空闲，等待任务
    RUNNING = "RUNNING"  # 执行中
    FINISHED = "FINISHED"  # 任务完成
    ERROR = "ERROR"    # 发生错误

状态转换通过上下文管理器安全控制：

@asynccontextmanager
async def state_context(self, new_state: AgentState):
    previous_state = self.state
    self.state = new_state
    try:
        yield
    except Exception as e:
        self.state = AgentState.ERROR
        raise e
    finally:
        self.state = previous_state

while (
    self.current_step < self.max_steps and
    self.state != AgentState.FINISHED
):
    self.current_step += 1
    step_result = await self.step()

    # 卡死检测
    if self.is_stuck():
        self.handle_stuck_state()

卡死检测机制：

def is_stuck(self) -> bool:
    """检测Agent是否陷入循环"""
    if len(self.memory.messages) < 2:
        return False

    last_message = self.memory.messages[-1]
    if not last_message.content:
        return False

    # 检查是否有重复的assistant消息
    duplicate_count = sum(
        1 for msg in reversed(self.memory.messages[:-1])
        if msg.role == "assistant" and msg.content == last_message.content
    )

    return duplicate_count >= self.duplicate_threshold

当检测到卡死时，Agent会添加提示词引导改变策略：

def handle_stuck_state(self):
    stuck_prompt = (
        "Observed duplicate responses. Consider new strategies and avoid "
        "repeating ineffective paths already attempted."
    )
    self.next_step_prompt = f"{stuck_prompt}\\n{self.next_step_prompt}"

特殊工具处理

某些工具具有特殊语义，如Terminate工具会终止Agent执行：

async def _handle_special_tool(self, name: str, result: Any, **kwargs):
    if not self._is_special_tool(name):
        return

    if self._should_finish_execution(name=name, result=result, **kwargs):
        logger.info(f"Special tool '{name}' has completed the task!")
        self.state = AgentState.FINISHED

5.4 上下文感知与记忆管理

Memory机制

Memory类维护完整的对话历史：

class Memory(BaseModel):
    messages: List[Message] = Field(default_factory=list)
    max_messages: int = Field(default=100)

    def add_message(self, message: Message) -> None:
        self.messages.append(message)
        # 限制消息数量，保留最近的
        if len(self.messages) > self.max_messages:
            self.messages = self.messages[-self.max_messages:]

对话历史包含完整的交互序列：

User: "帮我创建一个Python脚本"
Assistant: [思考过程] [tool_calls: python_execute]
Tool: [执行结果]
Assistant: [分析结果] [tool_calls: str_replace_editor]
Tool: [文件创建结果]
Assistant: "脚本已创建完成"

上下文构建

Agent的上下文由三部分构成：

1. 系统提示词：定义Agent的能力边界和角色
2. 对话历史：包含用户请求、Agent思考、工具调用、工具结果
3. 动态提示词：根据当前状态调整（如浏览器使用时的上下文）

async def think(self) -> bool:
    # 检查是否在使用浏览器
    browser_in_use = any(
        tc.function.name == BrowserUseTool().name
        for msg in recent_messages
        if msg.tool_calls
        for tc in msg.tool_calls
    )

    # 如果使用浏览器，添加浏览器上下文
    if browser_in_use:
        self.next_step_prompt = (
            await self.browser_context_helper.format_next_step_prompt()
        )

    return await super().think()

这种动态上下文调整使得Agent能够根据当前任务状态，提供更精准的决策。

base.run()
  step()
  
react.step()
  think()
  act() //如果有工具
  
toolcall.think(self)
  llm  //调用大模型，
  解析工具调用 //检查llm response.tool_calls 是否有值

为什么temperature设为0？

在推理场景中，我们希望Agent的输出更加确定和可控。temperature参数控制模型输出的随机性：

temperature=0：模型选择概率最高的token，输出最确定 temperature=0.7：增加一些随机性，适合创意任务 temperature=1.0+：高度随机，适合生成多样化内容 在ReAct Agent中，我们使用temperature=0，原因如下：

工具调用需要精确匹配：工具名称和参数必须完全正确 减少幻觉：避免Agent编造不存在的工具 提高稳定性：相同输入产生相同输出，便于调试 temperature选择指南

消息列表的作用

_messages维护了完整的对话历史，包括：

system消息：定义Agent的角色和行为准则 user消息：用户的输入 assistant消息：Agent的回复 这个历史会在每次API调用时完整传递给大模型，让Agent能够理解上下文。

对话历史管理策略

随着对话进行，消息列表会越来越长，导致：

API调用变慢 Token成本增加 可能超出模型上下文限制

max_history的选择

• 简单任务：5-10条消息足够
• 复杂任务：10-20条消息
• 长期对话：考虑实现摘要机制

工具函数集合

Agent需要工具来执行具体操作。我们定义两个简单工具：计算器和水果价格查询。

ReAct执行引擎 整个系统的核心部分，驱动“思考-行动-观察”循环。

3.1 Prompt设计 Prompt的质量直接决定Agent的表现。一个好的Prompt需要清晰定义执行流程、可用工具和输出格式。

Prompt设计核心原则

1. 明确执行流程

Agent需要知道每一步该做什么。我们使用"Thought → Action → PAUSE → Observation → Answer"的循环模式。为什么需要PAUSE？

PAUSE是一个明确的信号，告诉执行引擎"我已经完成思考，等待观察结果"。如果没有PAUSE，Agent可能会继续输出，导致解析失败。

2. 提供完整示例

示例比抽象描述更有效。一个好的示例应该展示完整的执行流程，包括思考、行动、观察和最终答案。

示例设计技巧

1. 完整流程：展示从问题到答案的完整路径
2. 真实场景：使用实际会遇到的场景
3. 格式统一：确保示例格式与要求一致
4. 多角度覆盖：提供不同类型的示例

3. 格式标准化

Action使用固定格式，便于正则匹配。我们选择"Action: 工具名: 参数"的格式。

为什么选择这种格式？

• 冒号分隔清晰易读
• 工具名和参数分开，便于解析
• 与其他输出格式区分明显

4. 工具描述清晰

每个工具都需要清晰的说明，包括功能、参数和返回值。

工具描述要素

1. 工具名称：清晰易懂的名称
2. 使用示例：展示如何调用
3. 功能说明：描述工具的作用
4. 注意事项：特殊情况的说明

Prompt优化技巧

技巧1：Few-shot Learning

提供多个示例，覆盖不同场景。

技巧2：明确边界条件

告诉Agent在什么情况下停止推理。

技巧3：错误处理指导

告诉Agent遇到错误时如何处理。

技巧4：输出格式约束

明确答案的格式要求。

完整Prompt示例

执行引擎实现

执行流程解析 用一个实际例子说明整个流程：

问题：计算3kg苹果和2kg香蕉的总价

第1轮：

Agent思考：需要先查询苹果单价 Action: ask_fruit_unit_price: apple Observation: Apple unit price is 10/kg 第2轮：

Agent思考：现在需要查询香蕉单价 Action: ask_fruit_unit_price: banana Observation: Banana unit price is 6/kg 第3轮：

Agent思考：现在可以计算总价了 Action: calculate: 3 * 10 + 2 * 6 Observation: 42 第4轮：

Agent思考：已经得到结果，输出答案 Answer: The total price is 42

———————————————— 版权声明：本文为CSDN博主「大模型微调专家」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/weixin_55154866/article/details/157031106

ReAct模式深度解析 4.1 为什么需要ReAct？ 传统的AI对话是"一问一答"模式，大模型直接根据问题生成答案。这种方式在简单场景下够用，但在复杂任务中会遇到明显问题：

问题1：知识截止问题

问：“今天北京的天气怎么样？” 答：“我无法获取实时天气信息。”

大模型的知识截止到训练时间，无法获取最新数据。

问题2：计算不准确

问：“12345 × 67890 = ？” 答：“838102050”

实际答案是838102050，但大模型经常在复杂计算中出错。

ReAct如何解决这些问题？

ReAct通过"思考-行动-观察"的循环，让AI学会：

先思考需要什么信息 选择合适的工具获取信息 观察工具返回的结果 基于真实结果继续推理 这样，AI不再依赖"记忆"和"猜测"，而是通过工具获取真实数据，大大提高了准确性。

4.2 ReAct与其他模式对比 模式 工作原理 优点 缺点 适用场景 直接回答 直接根据问题生成答案 简单快速，成本低 容易产生幻觉，无法获取实时信息 简单问答、创意写作 CoT（Chain of Thought） 让模型逐步思考推理过程 提高复杂问题的准确性 仍然依赖模型知识，无法获取外部信息 数学推理、逻辑分析 ReAct 思考→行动→观察的循环 可获取真实数据，可扩展性强 实现复杂，成本较高 需要外部信息的复杂任务 Plan-and-Solve 先制定计划，再逐步执行 结构清晰，可控性强 计划可能不完善，需要调整 多步骤任务、工作流自动化 实际选择建议

从我实际项目经验来看：

简单问答：直接用大模型，ReAct反而增加复杂度 需要外部信息：必须用ReAct，比如查询数据库、调用API 复杂推理：ReAct + CoT组合效果最好 实时任务：ReAct是唯一选择，比如监控告警、实时决策 4.3 ReAct模式的优势 相比直接让大模型回答问题，ReAct模式有几个明显优势：

可追溯性：每一步思考都明确记录，便于调试 可扩展性：通过添加工具扩展能力，无需重新训练模型 准确性：工具执行的结果是精确的，避免了幻觉问题 可控性：可以限制工具的使用范围，提高安全性 4.4 技术要点总结 正则表达式的作用

action_re = re.compile(r'^Action: (\w+): (.*)$')

这个正则负责从Agent的输出中提取Action指令。两个捕获组分别对应工具名称和参数。

max_turns的作用

限制最大推理轮次，防止Agent陷入无限循环。实际应用中可以根据任务复杂度调整。

为什么需要max_turns？

在实际应用中，Agent可能会遇到以下情况：

陷入死循环：反复调用同一个工具，无法获得有用信息 无法收敛：不断尝试不同的工具组合，但始终无法得到答案 成本失控：每轮调用都需要消耗API费用，无限循环会导致成本爆炸 max_turns的选择策略

简单任务（单步或两步推理）max_turns = 3# 中等复杂度任务（需要查询多个信息）max_turns = 5# 复杂任务（多步骤推理）max_turns = 10# 超复杂任务（需要多次迭代）max_turns = 20

一键获取完整项目代码 plaintext 1 实际案例

案例1：简单任务react(query="What is 5 * 6?", max_turns=3)# 实际使用：1轮# 结果：30# 案例2：中等复杂度任务react(query="What is the total price of 3kg apple and 2kg banana?", max_turns=5)# 实际使用：3轮# - 第1轮：查询apple价格# - 第2轮：查询banana价格# - 第3轮：计算总价# 结果：42# 案例3：复杂任务react(query="Compare the total cost of buying 5kg apple vs 3kg banana + 2kg orange", max_turns=10)# 实际使用：5轮# - 第1轮：查询apple价格# - 第2轮：查询banana价格# - 第3轮：查询orange价格# - 第4轮：计算apple总价# - 第5轮：计算banana+orange总价# 结果：Apple is cheaper

一键获取完整项目代码 plaintext 1 max_turns设置不当的后果

设置过小max_turns = 2react(query="What is the total price of 3kg apple and 2kg banana?")# 问题：只够查询apple价格，无法完成计算# 结果：Agent无法给出完整答案# 设置过大max_turns = 100react(query="What is 5 * 6?")# 问题：浪费资源，实际只需要1轮# 结果：成本增加，但结果相同

一键获取完整项目代码 plaintext 1 最佳实践

def react(query: str, max_turns: int = 5, timeout: int = 60): """ 改进的ReAct执行引擎 Args: query: 用户问题 max_turns: 最大推理轮次 timeout: 超时时间（秒） """ agent = Agent(system_prompt=react_prompt) question = query import time start_time = time.time() for turn in range(max_turns): # 检查超时 if time.time() - start_time > timeout: print("Timeout reached") return result = agent.invoke(question) actions = [action_re.match(a) for a in result.split('\n') if action_re.match(a)] ifnot actions: print("Finish") return tool, params = actions[0].groups() if tool notin known_tools: print(f"Unknown tool: {tool}") return observation = known_toolstool question = f"Observation: {observation}\n\n" print(f"Reached max_turns ({max_turns}) without finishing") 一键获取完整项目代码 plaintext 1 max_turns vs 超时机制

两种保护机制各有优劣：

机制 优点 缺点 适用场景 max_turns 简单直接，易于理解 无法处理单轮耗时过长的情况 快速任务 超时机制 灵活，适应不同任务复杂度 实现复杂，可能中断正在执行的工具 慢速任务 两者结合 最全面的保护 增加代码复杂度 生产环境 建议：生产环境同时使用max_turns和timeout机制。

为什么需要PAUSE？

PAUSE作为明确的停止信号，告诉执行引擎“我已经完成思考，等待观察结果”。缺少这个信号，Agent可能会继续输出，导致解析失败。

4.4 常见问题 Q1：Agent不按格式输出怎么办？

A：优化Prompt，增加更多示例。也可以在代码中添加容错机制，处理格式不规范的情况。

Q2：工具调用失败如何处理？

A：在工具函数中添加try-except，返回友好的错误信息。Agent会根据错误信息调整策略。

Q3：如何添加新工具？

A：三步走：

在tools.py中定义工具函数 在known_tools中注册 在Prompt中添加工具说明 五、实战经验与踩坑记录 5.1 实际开发中的常见问题 问题1：Agent不按格式输出

现象：Agent输出"Action: calculate 3 * 5"而不是"Action: calculate: 3 * 5"，导致正则匹配失败。

原因：Prompt不够明确，Agent没有严格遵循格式。

解决方案：

在Prompt中增加更多格式示例 使用few-shot learning，提供3-5个完整示例 在代码中添加容错机制，处理格式不规范的情况

改进后的正则匹配，容错处理def parse_action(result: str): patterns = [ r'^Action: (\w+): (.)$', # 标准格式 r'^Action: (\w+)\s+(.)$', # 容错格式 r'^(\w+):\s*(.*)$', # 简化格式 ] for pattern in patterns: match = re.search(pattern, result, re.MULTILINE) if match: return match.groups() return None

一键获取完整项目代码 plaintext 1 问题2：工具调用失败导致无限循环

现象：Agent一直调用同一个工具，但工具返回错误，导致无限循环。

原因：缺少错误处理机制，Agent无法从错误中学习。

解决方案：

在工具函数中添加try-except 返回友好的错误信息，让Agent理解问题 设置max_turns，防止无限循环 def calculate(expression: str) -> str: try: result = eval(expression) return str(result) except Exception as e: return f"Error: {str(e)}. Please check your expression." 一键获取完整项目代码 plaintext 1 问题3：温度设置不当导致工具调用失败

现象：temperature=0.7时，Agent经常输出错误的工具名称或参数。

解决方案：推理场景统一使用temperature=0，保证输出的确定性。关于temperature参数的详细说明见第一章「1.2 设计要点」。

问题4：对话历史过长导致性能下降

现象：随着推理轮次增加，API调用越来越慢，成本也越来越高。

解决方案：实现对话历史压缩，具体方案见第一章「对话历史管理策略」。

5.2 性能优化建议 优化1：工具调用缓存

对于重复的工具调用，可以缓存结果避免重复计算。

from functools import lru_cache@lru_cache(maxsize=100)def calculate(expression: str) -> str: return str(eval(expression)) 一键获取完整项目代码 plaintext 1 优化2：并行工具调用

如果多个工具调用之间没有依赖关系，可以并行执行。

import concurrent.futuresdef parallel_tool_calls(tools_and_params): with concurrent.futures.ThreadPoolExecutor() as executor: futures = [] for tool_name, params in tools_and_params: future = executor.submit(known_tools[tool_name], params) futures.append(future) results = [] for future in concurrent.futures.as_completed(futures): results.append(future.result()) return results 一键获取完整项目代码 plaintext 1 优化3：Prompt模板化

将Prompt中不变的部分提取为模板，减少每次构造Prompt的开销。

from string import TemplateREACT_TEMPLATE = Template("""You run in a loop of Thought, Action, PAUSE, Observation.At the end of the loop you output an AnswerAvailable actions:$toolsExample session:$example""")def build_prompt(tools, example): return REACT_TEMPLATE.substitute( tools="\n".join(tools), example=example ) 一键获取完整项目代码 plaintext 1 5.3 调试技巧 技巧1：打印完整推理过程

在开发阶段，打印每一步的思考过程，便于调试。

def react(query: str, max_turns: int = 5, debug=False): agent = Agent(system_prompt=react_prompt) question = query for turn in range(max_turns): result = agent.invoke(question) if debug: print(f"\n=== Turn {turn + 1} ===") print(f"Question: {question}") print(f"Agent Output:\n{result}") actions = [action_re.match(a) for a in result.split('\n') if action_re.match(a)] ifnot actions: break tool, params = actions[0].groups() observation = known_toolstool if debug: print(f"Tool: {tool}") print(f"Params: {params}") print(f"Observation: {observation}") question = f"Observation: {observation}\n\n" 一键获取完整项目代码 plaintext 1 技巧2：保存对话历史

将推理过程保存到文件，便于后续分析。

import jsonfrom datetime import datetimedef save_conversation(messages, filename=None): if filename is None: filename = f"conversation_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json" with open(filename, 'w', encoding='utf-8') as f: json.dump(messages, f, ensure_ascii=False, indent=2) print(f"Conversation saved to {filename}") 一键获取完整项目代码 plaintext 1 技巧3：使用日志系统

用logging替代print，便于管理日志级别。

import logginglogging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')logger = logging.getLogger(name)def react(query: str, max_turns: int = 5): logger.info(f"Starting ReAct with query: {query}") for turn in range(max_turns): result = agent.invoke(question) logger.debug(f"Turn {turn}: {result}") actions = [action_re.match(a) for a in result.split('\n') if action_re.match(a)] ifnot actions: logger.info("No more actions, finishing") break tool, params = actions[0].groups() logger.info(f"Calling tool: {tool} with params: {params}") observation = known_toolstool logger.info(f"Observation: {observation}") question = f"Observation: {observation}\n\n" 一键获取完整项目代码 plaintext 1 5.4 最佳实践 实践1：工具函数设计原则

单一职责：每个工具只做一件事 参数简单：避免复杂参数结构 返回明确：返回值要清晰易懂 错误处理：捕获异常并返回友好信息 文档完善：添加详细的docstring def search_database(query: str, limit: int = 10) -> str: """ 在数据库中搜索数据 Args: query: 搜索关键词 limit: 返回结果数量限制，默认10 Returns: 搜索结果的JSON字符串，格式为： { "total": 总数量, "results": [结果列表] } Raises: ValueError: 当query为空时 """ ifnot query: raise ValueError("Query cannot be empty") try: results = db.search(query, limit=limit) return json.dumps({ "total": len(results), "results": results }) except Exception as e: return json.dumps({ "error": str(e), "message": "Database search failed" }) 一键获取完整项目代码 plaintext 1 实践2：Prompt设计原则

明确指令：用祈使句，清晰表达期望 提供示例：用few-shot learning提高理解 格式统一：使用固定的输出格式 边界说明：明确工具的能力边界 错误提示：告诉Agent遇到错误怎么办 实践3：安全考虑

输入验证：验证工具参数的合法性 权限控制：限制工具的访问范围 审计日志：记录所有工具调用 沙箱执行：危险操作在隔离环境执行 import subprocessdef execute_command(command: str) -> str: """ 执行系统命令（沙箱环境） Args: command: 要执行的命令 Returns: 命令执行结果 Raises: ValueError: 当命令包含危险操作时 """ dangerous_commands = ['rm', 'format', 'del', 'shutdown'] if any(cmd in command for cmd in dangerous_commands): raise ValueError("Dangerous command detected") try: result = subprocess.run( command, shell=True, capture_output=True, text=True, timeout=30# 防止长时间运行 ) return result.stdout except subprocess.TimeoutExpired: return"Command execution timeout" 一键获取完整项目代码 plaintext 1 六、扩展方向 这个基础实现还有很多可以优化的地方：

工具描述优化：为每个工具添加详细的描述，帮助Agent更好地理解工具用途 多工具并行：支持同时调用多个工具，提高效率 记忆机制：添加长期记忆，跨会话保持信息 错误恢复：工具调用失败时的自动重试和降级策略 可视化：展示推理链路，方便调试和展示 七、环境配置 依赖安装 pip install openai python-dotenv 一键获取完整项目代码 plaintext 1 Python版本要求 Python >= 3.8 环境变量配置 在项目根目录创建.env文件：

OPENAI_API_KEY=your_api_keyOPENAI_API_BASE=https://api.deepseek.com/v1AI_MODEL=deepseek-chat 一键获取完整项目代码 plaintext 1 结语 抛开LangChain等框架，用更底层的方式实现了一个基于ReAct框架的Agent。整个过程中，我们看到了如何编写ReAct提示词，让大模型通过思考（Thought）、行动（Action）、观察（Observation）来完成更多的工作。

在这个实现中：

规划：通过ReAct提示词完成 记忆：通过聊天历史实现 动作：通过一个一个的函数实现

https://segmentfault.com/a/1190000047571605

https://blog.csdn.net/weixin_55154866/article/details/157031106

https://www.cnblogs.com/dayang12525/p/19572817

https://juejin.cn/post/7596478936387108906