React智能体系统摘要
React智能体系统是一个基于**推理+行动（Reasoning + Acting）**模式构建的AI智能体，能够自主分析复杂问题、制定执行计划、智能选择工具并迭代优化解决方案，直至生成高质量的最终答案。
该案例展示了现代AI智能体的典型架构，通过结合大语言模型的推理能力和实用工具的执行能力，能够有效处理各种复杂任务。
这是一个基于React模式(Reasoning + Acting)的LangGraph案例，展示如何构建一个能够进行复杂推理和行动的智能体系统，
具备以下核心功能：
- 任务理解与分解 - 将复杂问题分解为可执行的子任务
- 推理与规划 - 制定解决问题的策略和执行计划
- 工具选择与执行 - 智能选择合适的工具来执行具体任务
- 结果观察与分析 - 分析工具执行结果，判断是否达到目标
- 迭代优化 - 根据结果调整策略，持续优化解决方案
React模式核心：
Think（思考）：分析当前状况，规划下一步行动Act（行动）：使用工具执行具体操作Observe（观察）：分析行动结果，获取新信息循环迭代：直到问题完全解决
支持的工具：
- 网络搜索：获取实时信息
- 计算器：进行数学计算
- 文件操作：读写分析文件
- 代码执行：运行Python代码
- 数据分析：处理和分析数据
代码结构
代码主要包含以下模块：
1. 配置与初始化
Config 类：集中管理 API 配置、模型参数和 React 循环参数initialize_llm() 函数：初始化大语言模型（支持 OpenAI 兼容接口）
2. 状态管理
ReactAgentState（TypedDict）：定义智能体运行过程中的完整状态，包括任务信息、消息历史、工具使用记录、知识积累等SimpleMessage类：简化消息表示，支持角色和内容管理add_messages()函数：安全地添加新消息到状态
3. 工具系统
定义并实现了 5 种核心工具：
web_search_tool：模拟网络搜索（支持关键词匹配）calculator_tool：安全执行数学表达式计算code_executor_tool：在临时文件中运行 Python 代码file_operation_tool：支持读、写、列出文件/目录data_analysis_tool：支持统计数据和文本分析
所有工具统一封装在 TOOLS_MAP 中，便于动态调用。
4. React 循环节点
实现了 React 模式的 6 个核心节点：
task_analysis_node：分析用户任务，识别任务类型、复杂度、所需工具planning_node：制定详细执行计划，分解任务步骤thinking_node：推理当前状态，决定下一步行动（使用工具或结束）action_node：执行选定工具，记录结果observation_node：分析行动结果，更新知识库和任务进度final_answer_node：整合所有信息，生成自然语言最终答案
5. 流程控制
should_continue_react_loop()函数：基于任务完成标志、迭代次数、置信度分数决定是否继续循环
6. 简化工作流执行器
SimpleReactAgent类：串行执行各节点，模拟 LangGraph 的工作流调度
7. 演示与可视化
run_react_agent()函数：接收用户查询，运行完整流程，输出结果和统计demo_react_agent()函数：运行 5 个典型测试用例，展示系统能力visualize_react_graph()函数：生成并保存文本格式的工作流图show_react_architecture()函数：打印系统架构和技术优势说明
核心特性
- 真实 LLM 集成：支持 OpenAI 兼容接口，进行任务分析、推理、观察和答案生成
- 类型安全：使用 TypedDict 和类型注解，减少运行时错误
- 详细日志：每个步骤都有丰富的调试输出，便于追踪和排错
- 安全机制：
- 数学表达式过滤，防止非法代码执行
- 代码执行使用子进程和超时限制
- JSON 解析失败时有默认值保障流程不中断
- 模块化设计：每个节点职责单一，易于扩展和维护
- 异常处理：广泛捕获异常，记录错误信息，确保系统稳定运行
python
import os
import json
import math
import re
import subprocess
import requests
from typing import Dict, List, TypedDict, Literal, Optional, Union, Any
from datetime import datetime
import tempfileLangChain 核心组件
python
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.tools import Tool
from langchain_core.output_parsers import JsonOutputParser, StrOutputParser由于langgraph包的安装问题，我们使用简化版本实现React智能体
python
from langgraph.graph import StateGraph, END
from langgraph.graph.message import add_messages添加图形可视化所需的导入
python
try:
from IPython.display import Image, display
IPYTHON_AVAILABLE = True
except ImportError:
IPYTHON_AVAILABLE = False
print("📝 注意：IPython 不可用，将保存图片到文件")LLM 配置
python
try:
from langchain_openai import ChatOpenAI
LLM_AVAILABLE = "openai"
except ImportError:
LLM_AVAILABLE = None简化版本的消息和状态管理
python
class SimpleMessage:
def __init__(self, content: str, role: str = "user"):
self.content = content
self.role = role
def __str__(self):
return f"{self.role}: {self.content}"
def add_messages(existing_messages: List, new_messages: List):
"""简单的消息添加函数"""
if isinstance(new_messages, list):
return existing_messages + new_messages
else:
return existing_messages + [new_messages]safe_json_parse 是一个**"容错+日志"**版的 JSON 提取器：
无论输入里混杂多少 Markdown 代码块、换行或多余字符，它都尽力清洗并返回可用的 dict ；若彻底失败则空 dict 兜底 ，且全程打印调试信息，方便快速定位问题。
实现要点
-
多级清洗
- 去首尾空白
- 剥掉 ````````json ... ````或````` ```... ````包裹
-
多策略提取
① 直接当 JSON 试解
② 逐行找"单行 JSON"
③ 截取首个
{到最后一个}再试 -
逐级试解+日志
每轮尝试都带方法名、前 100 字符、错误行列号，失败继续下一策略。
-
安全兜底
全部策略失效 → 返回
{}，保证调用方无需额外异常处理。
使用场景
- LLM 返回内容常被 ```json 包裹或夹杂解释文字
- 需要"尽量解、不报错、好调试"的 JSON 解析场合
python
def safe_json_parse(content: str, context: str = "") -> dict:
"""安全的JSON解析函数，增加详细日志"""
print(f" 🔍 [DEBUG] 开始解析JSON - 上下文: {context}")
print(f" 🔍 [DEBUG] 原始内容长度: {len(content)}")
print(f" 🔍 [DEBUG] 原始内容前200字符: {repr(content[:200])}")
# 清理内容
original_content = content
content = content.strip()
# 移除代码块标记
if content.startswith('```json'):
content = content.replace('```json', '').replace('```', '').strip()
print(f" 🔍 [DEBUG] 移除了```json标记")
elif content.startswith('```'):
content = content.replace('```', '').strip()
print(f" 🔍 [DEBUG] 移除了```标记")
print(f" 🔍 [DEBUG] 清理后内容: {repr(content)}")
# 尝试找到JSON对象
json_candidates = []
# 方法1：直接解析整个内容
json_candidates.append(("完整内容", content))
# 方法2：按行查找JSON
lines = content.split('\n')
for i, line in enumerate(lines):
line = line.strip()
if line.startswith('{') and line.endswith('}'):
json_candidates.append((f"行{i+1}", line))
# 方法3：查找第一个{到最后一个}
start_idx = content.find('{')
end_idx = content.rfind('}')
if start_idx != -1 and end_idx != -1 and start_idx < end_idx:
json_part = content[start_idx:end_idx+1]
json_candidates.append(("大括号范围", json_part))
print(f" 🔍 [DEBUG] 找到 {len(json_candidates)} 个JSON候选")
# 尝试解析每个候选
for method, candidate in json_candidates:
try:
print(f" 🔍 [DEBUG] 尝试解析({method}): {repr(candidate[:100])}...")
result = json.loads(candidate)
print(f" ✅ [DEBUG] JSON解析成功 - 方法: {method}")
print(f" 🔍 [DEBUG] 解析结果: {result}")
return result
except json.JSONDecodeError as e:
print(f" ❌ [DEBUG] JSON解析失败({method}): {e}")
print(f" 🔍 [DEBUG] 错误位置: 第{e.lineno}行, 第{e.colno}列")
continue
# 所有方法都失败，返回默认值
print(f" ❌ [DEBUG] 所有JSON解析方法都失败")
print(f" 🔍 [DEBUG] 将返回默认值")
return {}配置和初始化
python
class Config:
"""配置类"""
# API配置 - DeepSeek 模型配置
OPENAI_API_KEY = "85b57e4d-c111111111-dfb00db"
OPENAI_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3"
# 模型配置
MODEL_NAME = "deepseek-v3-250324"
TEMPERATURE = 0.7
MAX_TOKENS = 2000
# React配置
MAX_ITERATIONS = 8 # 最大迭代次数
MIN_CONFIDENCE_SCORE = 0.8 # 最小置信度分数
def initialize_llm():
"""初始化大语言模型"""
if LLM_AVAILABLE == "openai":
return ChatOpenAI(
model=Config.MODEL_NAME,
temperature=Config.TEMPERATURE,
max_tokens=Config.MAX_TOKENS,
openai_api_key=Config.OPENAI_API_KEY,
openai_api_base=Config.OPENAI_BASE_URL
)
else:
raise RuntimeError("未找到可用的LLM库，请安装langchain-openai: pip install langchain-openai")状态定义
python
class ReactAgentState(TypedDict):
"""React智能体状态定义"""
# 基本信息
session_id: str # 会话ID
user_query: str # 用户查询
messages: List[SimpleMessage] # 消息历史
# 任务分析
task_analysis: Dict # 任务分析结果
sub_tasks: List[str] # 子任务列表
current_plan: List[str] # 当前执行计划
# React循环状态
iteration_count: int # 当前迭代次数
current_thought: str # 当前思考内容
selected_action: Dict # 选择的行动
action_result: str # 行动结果
observation: str # 观察结果
# 工具相关
available_tools: List[str] # 可用工具列表
tool_usage_history: List[Dict] # 工具使用历史
accumulated_knowledge: List[str] # 累积知识
# 决策相关
is_task_complete: bool # 任务是否完成
confidence_score: float # 置信度分数
final_answer: str # 最终答案
# 元数据
processing_steps: List[str] # 处理步骤记录
debug_info: List[Dict] # 调试信息工具定义与实现
python
def web_search_tool(query: str) -> str:
"""网络搜索工具"""
print(f" 🌐 执行网络搜索：{query}")
# 模拟搜索结果 - 实际应用中可以集成真实的搜索API
mock_search_results = {
"python": [
"Python是一种解释型、面向对象、动态数据类型的高级程序设计语言。",
"Python具有简洁明了的语法，强大的标准库和第三方库生态。",
"Python广泛应用于Web开发、数据科学、人工智能、自动化等领域。"
],
"机器学习": [
"机器学习是人工智能的一个分支，通过算法使计算机从数据中学习。",
"主要包括监督学习、无监督学习、强化学习等方法。",
"常用框架包括TensorFlow、PyTorch、scikit-learn等。"
],
"react": [
"React是一个用于构建用户界面的JavaScript库。",
"React采用组件化的开发模式，具有虚拟DOM等特性。",
"React由Facebook开发，在前端开发中广泛使用。"
]
}
# 简单的关键词匹配
for keyword, results in mock_search_results.items():
if keyword.lower() in query.lower():
result = "搜索结果：\n" + "\n".join(f"- {result}" for result in results)
print(f" ✅ 搜索完成，找到 {len(results)} 条结果")
return result
# 默认结果
result = f"关于'{query}'的搜索结果：找到了一些相关信息，但需要更具体的搜索关键词。"
print(f" ⚠️ 搜索完成，结果有限")
return result
def extract_math_expression(text: str) -> str:
"""从文本中提取数学表达式"""
print(f" 🔍 [DEBUG] 从文本中提取数学表达式: {repr(text)}")
# 常见的数学表达式模式
import re
# 模式1: 直接的数学表达式
math_patterns = [
r'(\(?\d+(?:\.\d+)?\s*[+\-*/]\s*\d+(?:\.\d+)?\)?(?:\s*[+\-*/]\s*\d+(?:\.\d+)?)*)',
r'(\d+(?:\.\d+)?\s*[+\-*/]\s*\d+(?:\.\d+)?(?:\s*[+\-*/]\s*\d+(?:\.\d+)?)*)',
r'(\([^)]+\)\s*[+\-*/]\s*\d+(?:\.\d+)?)',
r'(\d+(?:\.\d+)?\s*[+\-*/]\s*\([^)]+\))',
]
for pattern in math_patterns:
matches = re.findall(pattern, text)
if matches:
expression = matches[0]
print(f" ✅ [DEBUG] 找到数学表达式: {expression}")
return expression.strip()
# 模式2: 查找括号内的表达式
bracket_pattern = r'\(([^)]*[+\-*/][^)]*)\)'
bracket_matches = re.findall(bracket_pattern, text)
if bracket_matches:
expression = f"({bracket_matches[0]})"
print(f" ✅ [DEBUG] 找到括号表达式: {expression}")
return expression
# 模式3: 提取所有数字和运算符
numbers_and_ops = re.findall(r'[\d+\-*/().]+', text)
if numbers_and_ops:
# 连接所有匹配的部分
expression = ''.join(numbers_and_ops)
# 清理表达式
expression = re.sub(r'[^0-9+\-*/().]', '', expression)
if any(op in expression for op in ['+', '-', '*', '/']):
print(f" ✅ [DEBUG] 拼接得到表达式: {expression}")
return expression
# 如果都没找到，返回原文本
print(f" ⚠️ [DEBUG] 未找到明确的数学表达式，返回原文本")
return text
def calculator_tool(expression: str) -> str:
"""计算器工具"""
print(f" 🧮 执行数学计算：{expression}")
print(f" 🔍 [DEBUG] 原始输入: {repr(expression)}")
# 如果输入看起来不像数学表达式，尝试提取
if not any(op in expression for op in ['+', '-', '*', '/']):
print(f" 🔍 [DEBUG] 输入不包含运算符，尝试提取数学表达式")
expression = extract_math_expression(expression)
try:
# 安全的数学表达式计算
# 只允许基本的数学运算
allowed_chars = set('0123456789+-*/().^ ')
print(f" 🔍 [DEBUG] 清理前表达式: {repr(expression)}")
# 清理表达式，只保留数字和运算符
clean_expression = ''.join(c for c in expression if c in allowed_chars)
print(f" 🔍 [DEBUG] 清理后表达式: {repr(clean_expression)}")
if not clean_expression or not any(op in clean_expression for op in ['+', '-', '*', '/']):
print(f" ❌ [DEBUG] 表达式无效或不包含运算符")
return f"错误：无法识别有效的数学表达式：{expression}"
# 替换一些常见的数学表示
safe_expression = clean_expression.replace('^', '**').replace(' ', '')
print(f" 🔍 [DEBUG] 最终表达式: {repr(safe_expression)}")
# 验证表达式安全性
if not all(c in '0123456789+-*/().' for c in safe_expression):
print(f" ❌ [DEBUG] 表达式包含不安全字符")
return "错误：包含不安全的字符"
# 使用eval计算（在生产环境中应该使用更安全的方法）
result = eval(safe_expression)
print(f" ✅ [DEBUG] 计算成功：{safe_expression} = {result}")
return f"计算结果：{safe_expression} = {result}"
except ZeroDivisionError:
error_msg = "计算错误：除零错误"
print(f" ❌ [DEBUG] {error_msg}")
return error_msg
except SyntaxError as e:
error_msg = f"计算错误：语法错误 - {str(e)}"
print(f" ❌ [DEBUG] {error_msg}")
return error_msg
except Exception as e:
error_msg = f"计算错误：{str(e)}"
print(f" ❌ [DEBUG] {error_msg}")
return error_msg
def code_executor_tool(code: str) -> str:
"""代码执行工具（Python）"""
print(f" 💻 执行Python代码：")
print(f" {code[:100]}{'...' if len(code) > 100 else ''}")
try:
# 创建临时文件执行代码
with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
f.write(code)
temp_file = f.name
# 执行代码并捕获输出
result = subprocess.run(
['python', temp_file],
capture_output=True,
text=True,
timeout=10
)
# 清理临时文件
os.unlink(temp_file)
if result.returncode == 0:
output = result.stdout.strip()
print(f" ✅ 代码执行成功")
return f"代码执行结果：\n{output}"
else:
error = result.stderr.strip()
print(f" ❌ 代码执行失败：{error}")
return f"代码执行错误：\n{error}"
except subprocess.TimeoutExpired:
error_msg = "代码执行超时"
print(f" ⏰ {error_msg}")
return error_msg
except Exception as e:
error_msg = f"代码执行异常：{str(e)}"
print(f" ❌ {error_msg}")
return error_msg
def file_operation_tool(operation: str, filename: str, content: str = "") -> str:
"""文件操作工具"""
print(f" 📁 执行文件操作：{operation} - {filename}")
try:
if operation == "read":
if os.path.exists(filename):
with open(filename, 'r', encoding='utf-8') as f:
file_content = f.read()
print(f" ✅ 文件读取成功，长度：{len(file_content)} 字符")
return f"文件内容：\n{file_content[:1000]}{'...' if len(file_content) > 1000 else ''}"
else:
return f"错误：文件 {filename} 不存在"
elif operation == "write":
with open(filename, 'w', encoding='utf-8') as f:
f.write(content)
print(f" ✅ 文件写入成功")
return f"成功写入文件：{filename}"
elif operation == "list":
if os.path.exists(filename):
files = os.listdir(filename)
print(f" ✅ 目录列表获取成功，包含 {len(files)} 个项目")
return f"目录内容：\n" + "\n".join(files[:20]) # 限制显示前20个
else:
return f"错误：目录 {filename} 不存在"
else:
return f"错误：不支持的操作 {operation}"
except Exception as e:
error_msg = f"文件操作错误：{str(e)}"
print(f" ❌ {error_msg}")
return error_msg
def data_analysis_tool(data_type: str, data: str) -> str:
"""数据分析工具"""
print(f" 📊 执行数据分析：{data_type}")
try:
if data_type == "statistics":
# 解析数值数据
numbers = []
for item in data.split(','):
try:
numbers.append(float(item.strip()))
except ValueError:
continue
if numbers:
avg = sum(numbers) / len(numbers)
min_val = min(numbers)
max_val = max(numbers)
result = f"""数据统计分析：
- 数据量：{len(numbers)}
- 平均值：{avg:.2f}
- 最小值：{min_val}
- 最大值：{max_val}
- 总和：{sum(numbers)}"""
print(f" ✅ 统计分析完成，分析了 {len(numbers)} 个数据点")
return result
else:
return "错误：未找到有效的数值数据"
elif data_type == "text_analysis":
# 文本分析
words = data.split()
char_count = len(data)
word_count = len(words)
result = f"""文本分析结果：
- 字符数：{char_count}
- 单词数：{word_count}
- 平均单词长度：{char_count/word_count:.1f}"""
print(f" ✅ 文本分析完成")
return result
else:
return f"错误：不支持的分析类型 {data_type}"
except Exception as e:
error_msg = f"数据分析错误：{str(e)}"
print(f" ❌ {error_msg}")
return error_msg创建工具映射
python
TOOLS_MAP = {
"web_search": web_search_tool,
"calculator": calculator_tool,
"code_executor": code_executor_tool,
"file_operation": file_operation_tool,
"data_analysis": data_analysis_tool
}工具描述
python
TOOLS_DESCRIPTIONS = {
"web_search": "网络搜索工具，用于获取实时信息和资料",
"calculator": "计算器工具，用于进行数学计算",
"code_executor": "代码执行工具，用于运行Python代码",
"file_operation": "文件操作工具，用于读写和管理文件",
"data_analysis": "数据分析工具，用于处理和分析数据"
}节点函数定义
任务分析节点
python
def task_analysis_node(state: ReactAgentState) -> ReactAgentState:
"""任务分析节点 - 理解和分解用户任务"""
print("🔍 正在分析用户任务...")
llm = initialize_llm()
user_query = state["user_query"]
# 任务分析提示词
analysis_prompt = ChatPromptTemplate.from_messages([
("system", """你是一个专业的任务分析专家。请分析用户的查询，并确定：
1. 任务类型（数学计算、信息查询、数据处理、代码执行、文件操作等）
2. 复杂程度（simple/medium/complex）
3. 所需工具（从以下工具中选择）：
- web_search: 网络搜索
- calculator: 数学计算
- code_executor: Python代码执行
- file_operation: 文件操作
- data_analysis: 数据分析
4. 子任务分解
5. 预估复杂度（0-1之间的数值）
请严格按照以下JSON格式返回结果，不要添加任何其他文字：
返回包含task_type（任务类型），complexity（复杂程度），required_tools（工具列表），sub_tasks（子任务列表），confidence（置信度）的JSON对象。
输出纯JSON格式，无其他内容。"""),
("user", "用户查询：{query}")
])
try:
print(f" 🔍 [DEBUG] 开始调用LLM进行任务分析")
print(f" 🔍 [DEBUG] 用户查询: {user_query}")
response = llm.invoke(analysis_prompt.format_messages(query=user_query))
# 获取响应内容
content = response.content.strip()
print(f" 🔍 [DEBUG] LLM响应类型: {type(response)}")
print(f" 🔍 [DEBUG] LLM响应对象: {response}")
print(f" 🔍 [DEBUG] LLM响应内容: {repr(content)}")
# 使用安全JSON解析
task_analysis = safe_json_parse(content, "任务分析")
if not task_analysis:
print(f" ⚠️ [DEBUG] JSON解析返回空字典，使用默认分析")
task_analysis = {
"task_type": "通用查询",
"complexity": "medium",
"required_tools": ["web_search"],
"sub_tasks": ["理解查询", "获取信息", "生成答案"],
"confidence": 0.5
}
else:
print(f" ✅ [DEBUG] 任务分析成功：{task_analysis}")
except Exception as e:
print(f" ❌ [DEBUG] 任务分析异常：{type(e).__name__}: {str(e)}")
import traceback
print(f" 🔍 [DEBUG] 错误堆栈:\n{traceback.format_exc()}")
# 使用默认分析结果
task_analysis = {
"task_type": "通用查询",
"complexity": "medium",
"required_tools": ["web_search"],
"sub_tasks": ["理解查询", "获取信息", "生成答案"],
"confidence": 0.3
}
# 更新状态
state["task_analysis"] = task_analysis
state["sub_tasks"] = task_analysis.get("sub_tasks", [])
state["available_tools"] = task_analysis.get("required_tools", ["web_search"])
state["processing_steps"].append(f"任务分析：{task_analysis.get('task_type')}")
state["messages"].append(SimpleMessage(
content=f"任务已分析：{task_analysis.get('task_type')}，需要工具：{', '.join(task_analysis.get('required_tools', []))}",
role="system"
))
print(f" ✅ 任务类型：{task_analysis.get('task_type')}")
print(f" ✅ 复杂程度：{task_analysis.get('complexity')}")
print(f" ✅ 所需工具：{task_analysis.get('required_tools')}")
print(f" ✅ 子任务：{task_analysis.get('sub_tasks')}")
return state规划节点
python
def planning_node(state: ReactAgentState) -> ReactAgentState:
"""规划节点 - 制定执行计划"""
print("📋 正在制定执行计划...")
llm = initialize_llm()
user_query = state["user_query"]
task_analysis = state["task_analysis"]
available_tools = state["available_tools"]
# 构建规划提示词内容
planning_system_content = f"""你是一个智能规划专家。基于任务分析结果，制定详细的执行计划。
任务信息：
- 用户查询：{user_query}
- 任务类型：{task_analysis.get('task_type', '未知')}
- 可用工具：{', '.join(available_tools)}
- 子任务：{task_analysis.get('sub_tasks', [])}
请制定一个分步骤的执行计划，每个步骤应该包含具体的行动。
请严格按照以下JSON格式返回结果，不要添加任何其他文字：
返回包含plan（步骤列表），estimated_steps（预估步骤数），confidence（置信度）的JSON对象。
输出纯JSON格式，无其他内容。"""
planning_prompt = ChatPromptTemplate.from_messages([
("system", planning_system_content),
("user", "请为以下任务制定执行计划：{query}")
])
try:
print(f" 🔍 [DEBUG] 开始调用LLM制定计划")
response = llm.invoke(planning_prompt.format_messages(query=user_query))
content = response.content.strip()
print(f" 🔍 [DEBUG] LLM响应内容: {repr(content)}")
# 使用安全JSON解析
plan_result = safe_json_parse(content, "计划制定")
if not plan_result:
print(f" ⚠️ [DEBUG] JSON解析返回空字典，使用默认计划")
plan_result = {
"plan": ["分析问题", "选择工具", "执行操作", "生成答案"],
"estimated_steps": 4,
"confidence": 0.5
}
else:
print(f" ✅ [DEBUG] 计划制定成功：{plan_result}")
except Exception as e:
print(f" ❌ [DEBUG] 计划制定异常：{type(e).__name__}: {str(e)}")
import traceback
print(f" 🔍 [DEBUG] 错误堆栈:\n{traceback.format_exc()}")
plan_result = {
"plan": ["分析问题", "选择工具", "执行操作", "生成答案"],
"estimated_steps": 4,
"confidence": 0.3
}
# 更新状态
state["current_plan"] = plan_result.get("plan", [])
state["processing_steps"].append("制定执行计划")
state["messages"].append(SimpleMessage(
content=f"执行计划已制定，包含 {len(state['current_plan'])} 个步骤",
role="system"
))
print(f" ✅ 计划步骤：")
for i, step in enumerate(state["current_plan"], 1):
print(f" {i}. {step}")
return state思考节点
python
def thinking_node(state: ReactAgentState) -> ReactAgentState:
"""思考节点 - React循环中的Think步骤"""
print(f"🤔 正在思考下一步行动（第 {state['iteration_count'] + 1} 轮）...")
llm = initialize_llm()
user_query = state["user_query"]
current_plan = state["current_plan"]
tool_usage_history = state["tool_usage_history"]
accumulated_knowledge = state["accumulated_knowledge"]
available_tools = state["available_tools"]
# 构建历史信息
history_info = ""
if tool_usage_history:
history_info = "已执行的操作：\n"
for i, usage in enumerate(tool_usage_history, 1):
history_info += f"{i}. {usage.get('tool_name', '未知')}：{usage.get('result', '无结果')[:100]}...\n"
knowledge_info = ""
if accumulated_knowledge:
knowledge_info = "已获得的知识：\n" + "\n".join(f"- {knowledge}" for knowledge in accumulated_knowledge[-3:]) # 最近3条
# 安全地构建计划字符串，避免格式化冲突
import re
plan_str = re.sub(r'[{}\'\"]+', ' ', str(current_plan))
history_str = re.sub(r'[{}\'\"]+', ' ', history_info) if history_info else ""
knowledge_str = re.sub(r'[{}\'\"]+', ' ', knowledge_info) if knowledge_info else ""
# 构建思考提示词内容
thinking_system_content = f"""你是一个React智能体的思考模块。基于当前情况，分析下一步应该采取什么行动。
当前任务：{user_query}
执行计划：{plan_str}
可用工具：{', '.join(available_tools)}
{history_str}
{knowledge_str}
可用工具说明：
- web_search：网络搜索，输入搜索关键词
- calculator：数学计算，输入数学表达式
- code_executor：执行Python代码，输入代码字符串
- file_operation：文件操作，需要操作类型、文件名、内容（可选）
- data_analysis：数据分析，需要分析类型和数据
请分析当前情况并决定下一步行动。如果任务已经完成，请设置is_final为true。
请严格按照以下JSON格式返回结果，不要添加任何其他文字：
使用工具时返回这种格式：
action为use_tool，tool_name为具体工具名，tool_input为工具输入，reasoning为推理过程，is_final为false
任务完成时返回这种格式：
action为final_answer，reasoning为任务完成的推理，is_final为true
输出纯JSON格式，无其他内容。"""
thinking_prompt = ChatPromptTemplate.from_messages([
("system", thinking_system_content),
("user", "请基于当前情况思考下一步行动")
])
try:
print(f" 🔍 [DEBUG] 开始调用LLM进行思考")
response = llm.invoke(thinking_prompt.format_messages())
content = response.content.strip()
print(f" 🔍 [DEBUG] LLM响应内容: {repr(content)}")
# 使用安全JSON解析
thinking_result = safe_json_parse(content, "思考分析")
if not thinking_result:
print(f" ⚠️ [DEBUG] JSON解析返回空字典，使用默认行动")
thinking_result = {
"action": "use_tool",
"tool_name": available_tools[0] if available_tools else "web_search",
"tool_input": user_query,
"reasoning": "默认行动",
"is_final": False
}
else:
print(f" ✅ [DEBUG] 思考完成：{thinking_result}")
except Exception as e:
print(f" ❌ [DEBUG] 思考异常：{type(e).__name__}: {str(e)}")
import traceback
print(f" 🔍 [DEBUG] 错误堆栈:\n{traceback.format_exc()}")
thinking_result = {
"action": "use_tool",
"tool_name": available_tools[0] if available_tools else "web_search",
"tool_input": user_query,
"reasoning": "异常处理",
"is_final": False
}
# 更新状态
state["current_thought"] = thinking_result.get("reasoning", "")
state["selected_action"] = thinking_result
state["processing_steps"].append(f"思考阶段 - {thinking_result.get('action')}")
# 如果是最终答案，标记任务完成
if thinking_result.get("is_final", False):
state["is_task_complete"] = True
print(f" ✅ 推理过程：{thinking_result.get('reasoning', '')}")
print(f" ✅ 选择行动：{thinking_result.get('action')}")
if thinking_result.get("tool_name"):
print(f" ✅ 使用工具：{thinking_result.get('tool_name')}")
print(f" ✅ 工具输入：{thinking_result.get('tool_input', '')}")
return state行动节点
python
def action_node(state: ReactAgentState) -> ReactAgentState:
"""行动节点 - React循环中的Act步骤"""
print("⚡ 正在执行行动...")
selected_action = state["selected_action"]
action_type = selected_action.get("action", "")
if action_type == "use_tool":
tool_name = selected_action.get("tool_name", "")
tool_input = selected_action.get("tool_input", "")
print(f" 使用工具：{tool_name}")
print(f" 工具输入：{tool_input}")
# 执行工具
if tool_name in TOOLS_MAP:
try:
# 根据工具类型处理输入
if tool_name == "file_operation":
# 文件操作需要特殊处理
parts = tool_input.split("|") if "|" in tool_input else [tool_input, "", ""]
operation = parts[0] if len(parts) > 0 else "read"
filename = parts[1] if len(parts) > 1 else "test.txt"
content = parts[2] if len(parts) > 2 else ""
result = TOOLS_MAP[tool_name](operation, filename, content)
elif tool_name == "data_analysis":
# 数据分析需要特殊处理
parts = tool_input.split("|") if "|" in tool_input else ["statistics", tool_input]
data_type = parts[0] if len(parts) > 0 else "statistics"
data = parts[1] if len(parts) > 1 else tool_input
result = TOOLS_MAP[tool_name](data_type, data)
else:
result = TOOLS_MAP[tool_name](tool_input)
print(f" ✅ 工具执行成功")
except Exception as e:
result = f"工具执行失败：{str(e)}"
print(f" ❌ 工具执行失败：{e}")
else:
result = f"未知工具：{tool_name}"
print(f" ❌ 未知工具：{tool_name}")
# 记录工具使用
tool_usage = {
"tool_name": tool_name,
"input": tool_input,
"result": result,
"timestamp": datetime.now().isoformat()
}
state["tool_usage_history"].append(tool_usage)
elif action_type == "final_answer":
result = "准备生成最终答案"
print(f" 📝 {result}")
state["is_task_complete"] = True
else:
result = f"未知行动类型：{action_type}"
print(f" ❌ {result}")
# 更新状态
state["action_result"] = result
state["processing_steps"].append(f"执行行动 - {action_type}")
state["messages"].append(SimpleMessage(content=f"执行了行动：{action_type}", role="system"))
return state观察节点
python
def observation_node(state: ReactAgentState) -> ReactAgentState:
"""观察节点 - React循环中的Observe步骤"""
print("👁️ 正在观察和分析结果...")
llm = initialize_llm()
action_result = state["action_result"]
user_query = state["user_query"]
selected_action = state["selected_action"]
# 安全地构建字符串，避免格式化冲突
import re
action_str = re.sub(r'[{}\'\"]+', ' ', str(selected_action))
result_str = re.sub(r'[{}\'\"]+', ' ', str(action_result))
# 构建观察提示词内容
observation_system_content = f"""你是一个React智能体的观察模块。请分析刚才执行的行动结果，判断：
1. 行动是否成功
2. 获得了什么新信息或知识
3. 是否解决了用户的问题
4. 下一步应该怎么做
原始任务：{user_query}
执行的行动：{action_str}
行动结果：{result_str}
请严格按照以下JSON格式返回结果，不要添加任何其他文字：
返回包含evaluation（结果评估），new_knowledge（知识点列表），task_progress（0到1的进度），is_complete（是否完成），next_suggestion（下一步建议）的JSON对象。
输出纯JSON格式，无其他内容。"""
observation_prompt = ChatPromptTemplate.from_messages([
("system", observation_system_content),
("user", "请观察和分析上述行动的结果")
])
try:
print(f" 🔍 [DEBUG] 开始调用LLM进行观察分析")
response = llm.invoke(observation_prompt.format_messages())
content = response.content.strip()
print(f" 🔍 [DEBUG] LLM响应内容: {repr(content)}")
# 使用安全JSON解析
observation_result = safe_json_parse(content, "观察分析")
if not observation_result:
print(f" ⚠️ [DEBUG] JSON解析返回空字典，使用默认观察")
observation_result = {
"evaluation": "行动已执行",
"new_knowledge": [action_result[:100]] if action_result else [],
"task_progress": 0.5,
"is_complete": False,
"next_suggestion": "继续下一步"
}
else:
print(f" ✅ [DEBUG] 观察分析完成：{observation_result}")
except Exception as e:
print(f" ❌ [DEBUG] 观察分析异常：{type(e).__name__}: {str(e)}")
import traceback
print(f" 🔍 [DEBUG] 错误堆栈:\n{traceback.format_exc()}")
observation_result = {
"evaluation": "观察失败",
"new_knowledge": [],
"task_progress": 0.3,
"is_complete": False,
"next_suggestion": "重新尝试"
}
# 更新状态
state["observation"] = observation_result.get("evaluation", "")
# 添加新知识
new_knowledge = observation_result.get("new_knowledge", [])
state["accumulated_knowledge"].extend(new_knowledge)
# 更新置信度
state["confidence_score"] = observation_result.get("task_progress", 0.5)
# 判断是否完成
if observation_result.get("is_complete", False) or state["confidence_score"] >= Config.MIN_CONFIDENCE_SCORE:
state["is_task_complete"] = True
# 增加迭代计数
state["iteration_count"] += 1
# 更新处理步骤
state["processing_steps"].append("观察分析结果")
print(f" ✅ 评估结果：{observation_result.get('evaluation', '')}")
print(f" ✅ 任务进度：{state['confidence_score']:.2f}")
print(f" ✅ 新知识：{new_knowledge}")
print(f" ✅ 是否完成：{state['is_task_complete']}")
return state最终答案生成节点
python
def final_answer_node(state: ReactAgentState) -> ReactAgentState:
"""最终答案生成节点"""
print("📝 正在生成最终答案...")
llm = initialize_llm()
user_query = state["user_query"]
accumulated_knowledge = state["accumulated_knowledge"]
tool_usage_history = state["tool_usage_history"]
processing_steps = state["processing_steps"]
print(f" 🔍 [DEBUG] 用户查询: {user_query}")
print(f" 🔍 [DEBUG] 累积知识数量: {len(accumulated_knowledge)}")
print(f" 🔍 [DEBUG] 工具使用历史数量: {len(tool_usage_history)}")
print(f" 🔍 [DEBUG] 处理步骤数量: {len(processing_steps)}")
# 构建知识摘要
knowledge_summary = ""
if accumulated_knowledge:
knowledge_summary = "获得的信息：\n" + "\n".join(f"- {knowledge}" for knowledge in accumulated_knowledge)
print(f" 🔍 [DEBUG] 知识摘要: {knowledge_summary[:200]}...")
# 构建操作历史
operations_summary = ""
if tool_usage_history:
operations_summary = "执行的操作：\n"
for i, usage in enumerate(tool_usage_history, 1):
tool_result = usage.get('result', '无结果')
operations_summary += f"{i}. 使用{usage['tool_name']}：{tool_result[:200]}...\n"
print(f" 🔍 [DEBUG] 操作摘要: {operations_summary[:300]}...")
# 构建最终答案提示词内容
final_system_content = f"""你是一个React智能体的最终答案生成模块。基于所有收集的信息和执行的操作，为用户生成一个完整、准确、有用的最终答案。
用户原始问题：{user_query}
{knowledge_summary}
{operations_summary}
处理步骤：{' -> '.join(processing_steps)}
请生成一个综合的、有价值的答案，要求：
1. 直接回答用户的问题
2. 整合所有相关信息
3. 提供具体的结果或建议
4. 语言清晰易懂
5. 必要时提供进一步的建议
不需要使用JSON格式，直接返回自然语言答案。"""
final_prompt = ChatPromptTemplate.from_messages([
("system", final_system_content),
("user", "请基于以上信息生成最终答案")
])
try:
print(f" 🔍 [DEBUG] 开始调用LLM生成最终答案")
response = llm.invoke(final_prompt.format_messages())
final_answer = response.content.strip()
print(f" ✅ [DEBUG] 最终答案生成成功，长度：{len(final_answer)} 字符")
print(f" 🔍 [DEBUG] 最终答案前200字符: {repr(final_answer[:200])}")
except Exception as e:
print(f" ❌ [DEBUG] 最终答案生成失败：{type(e).__name__}: {str(e)}")
import traceback
print(f" 🔍 [DEBUG] 错误堆栈:\n{traceback.format_exc()}")
# 生成简单的总结答案
final_answer = f"""基于分析和执行的操作，针对您的问题「{user_query}」，我已经进行了以下处理：
{operations_summary if operations_summary else '执行了相关分析和查询'}
{knowledge_summary if knowledge_summary else '收集了相关信息'}
如需要更详细的信息或有其他问题，请随时告诉我。"""
print(f" ✅ [DEBUG] 使用备用答案，长度：{len(final_answer)} 字符")
# 更新状态
state["final_answer"] = final_answer
state["is_task_complete"] = True
state["processing_steps"].append("生成最终答案")
state["messages"].append(SimpleMessage(content=final_answer, role="assistant"))
print(f" ✅ 最终答案预览：{final_answer[:200]}...")
return state条件判断函数
python
def should_continue_react_loop(state: ReactAgentState) -> Literal["continue_thinking", "generate_final_answer"]:
"""判断是否继续React循环"""
# 检查完成条件
if state.get("is_task_complete", False):
print(" ✅ 任务已完成，生成最终答案")
return "generate_final_answer"
# 检查迭代次数限制
if state["iteration_count"] >= Config.MAX_ITERATIONS:
print(f" ⏰ 达到最大迭代次数 ({Config.MAX_ITERATIONS})，生成最终答案")
state["is_task_complete"] = True
return "generate_final_answer"
# 检查置信度
if state.get("confidence_score", 0) >= Config.MIN_CONFIDENCE_SCORE:
print(f" 📈 置信度达到要求 ({state['confidence_score']:.2f} >= {Config.MIN_CONFIDENCE_SCORE})，生成最终答案")
state["is_task_complete"] = True
return "generate_final_answer"
print(f" 🔄 继续React循环 (第 {state['iteration_count'] + 1} 轮)")
return "continue_thinking"工作流构建
python
class SimpleReactAgent:
"""简化版本的React智能体"""
def __init__(self):
self.nodes = {
"analyze_task": task_analysis_node,
"make_plan": planning_node,
"think": thinking_node,
"act": action_node,
"observe": observation_node,
"generate_final_answer": final_answer_node
}
def invoke(self, initial_state: ReactAgentState) -> ReactAgentState:
"""执行React智能体工作流"""
state = initial_state.copy()
# 步骤1：分析任务
print("🔍 步骤1：分析任务")
state = self.nodes["analyze_task"](state)
# 步骤2：制定计划
print("📋 步骤2：制定计划")
state = self.nodes["make_plan"](state)
# React循环
while not state.get("is_task_complete", False) and state["iteration_count"] < Config.MAX_ITERATIONS:
# 思考
print(f"🤔 React循环 - 思考阶段 (第{state['iteration_count'] + 1}轮)")
state = self.nodes["think"](state)
# 如果决定结束，直接跳出循环
if state.get("is_task_complete", False):
break
# 行动
print("⚡ React循环 - 行动阶段")
state = self.nodes["act"](state)
# 观察
print("👁️ React循环 - 观察阶段")
state = self.nodes["observe"](state)
# 生成最终答案
print("📝 步骤3：生成最终答案")
state = self.nodes["generate_final_answer"](state)
return state
def create_react_agent_graph():
"""创建React智能体工作流图"""
print("🏗️ 正在构建React智能体工作流...")
# 使用简化版本的React智能体
app = SimpleReactAgent()
print("✅ React智能体工作流构建完成！")
return app主函数和演示
运行React智能体
python
def run_react_agent(user_query: str) -> ReactAgentState:
"""运行React智能体"""
print(f"\n{'='*60}")
print(f"🤖 React智能体开始工作")
print(f"{'='*60}")
# 创建应用
app = create_react_agent_graph()
# 初始化状态
session_id = f"react_session_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
initial_state = ReactAgentState(
session_id=session_id,
user_query=user_query,
messages=[SimpleMessage(content=user_query, role="user")],
task_analysis={},
sub_tasks=[],
current_plan=[],
iteration_count=0,
current_thought="",
selected_action={},
action_result="",
observation="",
available_tools=[],
tool_usage_history=[],
accumulated_knowledge=[],
is_task_complete=False,
confidence_score=0.0,
final_answer="",
processing_steps=[],
debug_info=[]
)
print(f"\n📥 收到用户查询：{user_query}")
print(f"🆔 会话ID：{session_id}")
# 执行工作流
result = app.invoke(initial_state)
# 输出结果
print(f"\n{'='*60}")
print(f"📤 React智能体最终答案：")
print(f"{'='*60}")
print(result["final_answer"])
# 输出执行统计
print(f"\n📊 执行统计：")
print(f" - 总迭代次数：{result['iteration_count']}")
print(f" - 使用工具数：{len(result['tool_usage_history'])}")
print(f" - 置信度分数：{result['confidence_score']:.2f}")
print(f" - 任务类型：{result['task_analysis'].get('task_type', '未知')}")
print(f" - 获得知识数：{len(result['accumulated_knowledge'])}")
print(f" - 处理步骤：{len(result['processing_steps'])} 步")
# 详细的执行历史
print(f"\n🔍 详细执行历史：")
for i, step in enumerate(result["processing_steps"], 1):
print(f" {i}. {step}")
if result["tool_usage_history"]:
print(f"\n🛠️ 工具使用历史：")
for i, usage in enumerate(result["tool_usage_history"], 1):
print(f" {i}. {usage['tool_name']}：{usage['result'][:100]}...")
return result演示React智能体系统
python
def demo_react_agent():
"""演示React智能体系统"""
print("🚀 React智能体演示开始")
print("=" * 80)
# 测试用例 - 涵盖不同类型的任务
test_cases = [
{
"query": "帮我计算 (25 + 37) * 8 / 4 的结果",
"description": "数学计算任务 - 测试计算器工具"
},
{
"query": "搜索Python编程语言的相关信息",
"description": "信息查询任务 - 测试搜索工具"
},
{
"query": "编写一个Python代码来生成斐波那契数列的前10个数",
"description": "代码生成任务 - 测试代码执行工具"
},
{
"query": "分析这些数据：1,2,3,4,5,6,7,8,9,10",
"description": "数据分析任务 - 测试数据分析工具"
},
{
"query": "帮我查找关于机器学习的信息，并计算如果一个模型准确率是85%，在1000个样本中预期正确预测多少个",
"description": "复合任务 - 测试多工具协作"
}
]
for i, test_case in enumerate(test_cases, 1):
print(f"\n🔹 测试案例 {i}: {test_case['description']}")
print("-" * 60)
result = run_react_agent(test_case["query"])
# 添加分隔线
if i < len(test_cases):
print("\n" + "=" * 80)可视化React智能体工作流图
python
def visualize_react_graph():
"""可视化React智能体工作流图"""
print(f"\n{'='*60}")
print("🎨 正在生成React智能体工作流文本图...")
print(f"{'='*60}")
# 由于不使用LangGraph，我们生成文本形式的工作流图
workflow_text = """
React智能体工作流程图：
┌─────────────────┐
│ 用户输入 │
└─────┬───────────┘
│
▼
┌─────────────────┐
│ 任务分析 │ ← 理解问题，识别所需工具
└─────┬───────────┘
│
▼
┌─────────────────┐
│ 制定计划 │ ← 分解任务，制定执行策略
└─────┬───────────┘
│
▼
┌─────────────────┐
│ React循环开始 │
└─────┬───────────┘
│
▼
┌─────────────────┐
│ Think (思考) │ ← 分析当前状况，决定下一步行动
└─────┬───────────┘
│
▼
┌─────────────────┐
│ Act (行动) │ ← 执行具体工具，获取信息
└─────┬───────────┘
│
▼
┌─────────────────┐
│ Observe (观察) │ ← 分析结果，判断是否完成
└─────┬───────────┘
│
▼
┌─────────────────┐
│ 任务完成？ │
└─────┬───────────┘
│
是│ 否
│ │
│ └─────┐
│ │
▼ ▼
┌─────────────────┐ │
│ 生成最终答案 │ │
└─────────────────┘ │
│
└──→ 返回Think (思考)
"""
print(workflow_text)
# 保存文本图到文件
try:
with open("react_agent_workflow.txt", "w", encoding="utf-8") as f:
f.write(workflow_text)
print("✅ 工作流程图已保存到 react_agent_workflow.txt")
except Exception as e:
print(f"⚠️ 保存文件失败：{e}")
print("✅ React智能体可视化完成")显示React智能体架构信息
python
def show_react_architecture():
"""显示React智能体架构信息"""
print("""
🏛️ React智能体系统架构：
┌─────────────────────────────────────────────────────────────┐
│ React智能体工作流 │
├─────────────────────────────────────────────────────────────┤
│ 用户输入 │
│ ↓ │
│ 1. 任务分析 ← 理解问题，识别所需工具 │
│ ↓ │
│ 2. 制定计划 ← 分解任务，制定执行策略 │
│ ↓ │
│ 3. React循环： │
│ ┌─ Think (思考) ← 分析当前状况，决定下一步行动 │
│ │ ↓ │
│ │ Act (行动) ← 执行具体工具，获取信息 │
│ │ ↓ │
│ │ Observe(观察)← 分析结果，判断是否完成 │
│ └─────↑ (循环直到任务完成) │
│ ↓ │
│ 4. 生成最终答案 ← 整合所有信息，生成综合回答 │
└─────────────────────────────────────────────────────────────┘
🛠️ 工具生态系统：
• 网络搜索 (web_search) ← 获取实时信息和资料
• 计算器 (calculator) ← 执行数学计算
• 代码执行 (code_executor) ← 运行Python代码
• 文件操作 (file_operation) ← 读写和管理文件
• 数据分析 (data_analysis) ← 处理和分析数据
🧠 React模式核心思想：
• Think: 基于当前状态进行推理，制定行动计划
• Act: 使用合适的工具执行具体操作
• Observe: 观察行动结果，评估任务完成度
• 迭代优化: 根据观察结果调整策略，直到问题解决
🎯 核心特性：
• 自主推理：能够独立分析问题和制定解决方案
• 工具集成：支持多种工具的智能选择和使用
• 状态管理：完整追踪整个推理和执行过程
• 错误处理：具备异常处理和恢复能力
• 可扩展性：易于添加新工具和功能
🔧 技术优势：
• 真实LLM集成：使用真实大语言模型进行推理
• 详细日志：每个步骤都有完整的日志记录
• 类型安全：使用TypedDict确保状态类型安全
• 模块化设计：每个节点功能独立，易于维护
• 可视化支持：支持工作流图形化展示
💡 应用场景：
• 复杂问题求解：需要多步推理的问题
• 数据分析任务：涉及计算和分析的工作
• 代码生成和执行：编程相关的任务
• 信息收集整合：需要搜索和整理信息
• 混合任务处理：结合多种工具的复杂任务
""")
if __name__ == "__main__":
"""主函数"""
# 显示系统架构信息
show_react_architecture()
# 检查LLM可用性
print(f"🔧 LLM状态：{LLM_AVAILABLE or '未安装'}")
if not LLM_AVAILABLE:
print("❌ 错误：未检测到可用的LLM库")
print("💡 请安装langchain-openai：pip install langchain-openai")
print("💡 然后重新运行程序")
exit(1)
print(f"\n🛠️ 可用工具：")
for tool_name, description in TOOLS_DESCRIPTIONS.items():
print(f" • {tool_name}: {description}")
print("\n" + "="*80)
# 运行演示
demo_react_agent()
print("\n🎉 React智能体演示完成！")
print("\n💡 使用建议：")
print("1. 配置真实的LLM API密钥以获得更好的推理效果")
print("2. 可以修改测试用例来测试不同类型的任务")
print("3. 可以扩展工具集合以支持更多功能")
print("4. 可以调整迭代次数和置信度阈值")
print("5. 观察日志输出了解React智能体的推理过程")
# 生成可视化图
visualize_react_graph() 内容总结
一个基于React模式（推理+行动）的AI智能体系统实现，核心内容可概括为：
1. 核心目标
构建一个能自主分析任务、调用工具、迭代推理并解决复杂问题的AI智能体，模拟人类"思考→行动→观察"的认知循环。
2. 架构与流程
- React循环 ：
任务分析 → 制定计划 → 循环（思考→行动→观察）→ 生成最终答案 - 状态驱动 ：
用ReactAgentState（TypedDict）全程跟踪任务、工具、知识、置信度等状态。 - 节点化设计 ：
6个核心节点（分析、规划、思考、行动、观察、总结），低耦合、易扩展。
3. 工具箱
内置5种可插拔工具：
- 网络搜索（mock）
- 数学计算器（安全表达式求值）
- Python代码执行（子进程+超时保护）
- 文件读写
- 数据分析（统计、文本）
4. 关键实现
- LLM集成 ：
通过OpenAI兼容接口完成任务分析、推理决策、结果观察、最终答案生成。 - 安全机制 ：
表达式过滤、JSON容错、异常捕获、超时控制，确保系统鲁棒。 - 日志与调试 ：
每一步均输出详细DEBUG信息，方便追踪与复盘。
5. 演示与可视化
- 提供5个测试用例（数学、搜索、代码、数据、混合任务）一键演示。
- 生成文本版工作流程图 与系统架构图，直观展示React循环。