在大语言模型（LLM）应用落地过程中，Agent 是核心方向之一 —— 它能像人类一样思考、决策、执行任务，而非单纯的文本生成。本文以「Python 代码生成与验证」为场景，从零拆解一个基于 ReAct 框架的 Code Agent，展示如何将 LLM 与工具链结合，实现自动化的代码生成、语法校验、执行验证全流程。

一、Agent 核心思想：ReAct 框架

在开始代码实战前，先理解本次实现的核心框架 ——ReAct（Reason + Action）。它的核心逻辑是让 LLM 遵循「思考→行动→观察→再思考」的循环，而非直接生成最终结果，这也是 Agent 区别于普通 LLM 调用的关键：

1. 思考（Reason）

   基于当前任务目标和状态，决定下一步要执行的动作；

2. 行动（Act）

   调用工具（如代码语法检查、代码执行）完成该动作；

3. 观察（Observe）

   获取工具执行结果，更新当前状态；

4. 循环

   重复上述步骤，直到任务完成（或触发最大步数限制）。

对于代码生成场景，我们将 ReAct 流程具象化为：

• 初始状态：生成满足需求的核心代码；
• 验证状态：调用工具检查代码语法，生成测试用例并执行；
• 结束状态：测试通过后输出总结，任务完成；
• 异常处理：任何环节出错时终止并反馈错误信息。

二、基础组件拆解：从简单工具到 LLM 调用

在构建完整 Agent 前，先实现两个基础组件 —— 工具链（代码校验 / 执行）和 LLM 调用模块，这是 Agent 能「做事」的基础。

2.1 工具链：代码校验与执行

Agent 本身不直接完成「语法检查」「代码运行」这类具体操作，而是调用专门的工具。我们封装 CodeToolManager 类，包含两个核心静态方法：

（1）代码语法校验

该方法负责清理用户 / LLM 生成的代码（去除 markdown 格式符），并通过 Python 内置的 compile 函数做语法校验，确保生成的代码无基础语法错误：

import re
import sys
import subprocess
class CodeToolManager:
@staticmethod
def generate_code(code_content: str) -> str:
"""生成代码并检查语法"""
try:
clean_code = code_content.strip()
clean_code = re.sub(r'```python|```', '', clean_code)  # 清理markdown代码块格式
if not clean_code:
return "错误：代码为空"
compile(clean_code, '<string>', 'exec')  # 语法校验核心逻辑
return f"✅ 代码生成成功（语法检查通过）\n生成的代码：\n{clean_code}"
except SyntaxError as e:
clean_code = CodeToolManager.clean_code_func(code_content)
return f"❌ 语法错误：{str(e)}\n清理后的代码：\n{clean_code}\n原始代码：\n{code_content}"

（2）代码执行验证

语法正确不代表逻辑正确，因此需要执行测试代码验证结果。该方法将核心代码与测试代码拼接，写入临时文件后通过 subprocess 执行，捕获输出和错误信息：

@staticmethod
def execute_code(code_content: str, context_code: str = "") -> str:
"""执行测试代码"""
temp_file = "temp_code_run.py"
try:
# 清理代码格式，拼接核心代码和测试代码
context_code = re.sub(r'```python|```', '', context_code).strip()
code_content = re.sub(r'```python|```', '', code_content).strip()
full_code = f"{context_code}\n\n{code_content}"
# 写入临时文件执行
with open(temp_file, "w", encoding="utf-8") as f:
f.write(full_code)
result = subprocess.run(
[sys.executable, temp_file],
capture_output=True,
text=False,
timeout=10
)
# 解码输出（兼容GBK/UTF-8编码）
stdout = result.stdout.decode("gbk", errors="ignore") if result.stdout else ""
stderr = result.stderr.decode("gbk", errors="ignore") if result.stderr else ""
if result.returncode == 0:
return f"✅ 执行成功\n输出：\n{stdout}"
else:
return f"❌ 执行失败\n错误：\n{stderr}"
except Exception as e:
return f"❌ 执行异常：{str(e)}"

2.2 LLM 调用模块：与大模型的交互层

工具链是「手脚」，LLM 是「大脑」。我们封装 LLM 类，简化与 Ollama 本地大模型的交互，确保能稳定获取代码生成的思考结果：

import ollama
class LLM:
@staticmethod
def chat(question: str, prompt: str = "") -> str:
return LLM._ollama_chat(question, prompt)
@staticmethod
def _ollama_chat(question, prompt):
try:
msg_to_ai = f"{question} {prompt}"
response = ollama.chat(
model='qwen3-coder:480b-cloud',  # 代码生成专用模型
messages=[{'role': 'user', 'content': msg_to_ai}],
stream=False,
options={
"temperature": 0.1,  # 低温度保证代码稳定性
"num_predict": 1000  # 足够容纳代码生成的token
}
)
llm_output = response.message.content
llm_output = llm_output.replace("\\n", "\n")
return llm_output
except Exception as e:
return f"Action: Error[LLM调用失败：{str(e)}]"

三、组装完整 Agent：ReAct 流程落地

有了工具链和 LLM 大脑，接下来将两者结合，实现遵循 ReAct 流程的 CodeReActAgent 类，这是整个项目的核心。

3.1 Agent 初始化：定义流程与约束

在初始化方法中，我们明确任务目标、初始状态，并制定严格的系统提示词 —— 这是约束 LLM 按 ReAct 流程思考的关键：

import re
from typing import Tuple, Optional
class CodeReActAgent:
def __init__(self, goal: str):
self.goal = goal  # 任务目标（如「生成计算偶数平方和的函数」）
self.current_state = "初始状态：待生成代码"
self.core_code = ""  # 保存已生成的核心代码
self.llm = LLM()
self.code_tools = CodeToolManager()
# 系统提示词：明确ReAct流程和输出格式
self.system_prompt = f"""
你是严格遵循ReAct流程的Python代码助手，必须按以下逻辑执行：
1. 初始状态：生成满足需求的核心函数代码 → Action: GenerateCode[代码]
2. 当看到「✅ 代码生成成功」时：立即生成测试用例代码 → Action: ExecuteCode[测试代码]
3. 当看到「✅ 执行成功」时：结束任务 → Action: Finish[任务完成总结]
4. 任何错误：输出Action: Error[错误信息]
输出格式（仅允许以下格式，无任何额外内容）：
Action: 类型[内容]
当前任务：{self.goal}
约束：
- 核心函数要处理空列表、负数、零等边界情况
- 测试用例必须覆盖：空列表、负数偶数、正常数字、无偶数场景
- 测试代码要直接打印结果，无需额外函数
- 不要重复生成相同代码，一步完成一个行动
- 测试函数应该在 if __name__ =='__main__'中
"""

3.2 核心方法：解析动作与运行循环

（1）动作解析：提取 LLM 决策

LLM 输出的结果需要解析为「动作类型」和「动作内容」，确保 Agent 能正确识别下一步要做什么：

def _parse_action(self, thought: str) -> Tuple[str, str]:
"""解析Action指令"""
action_match = re.search(r'Action:\s*(\w+)\[(.*)\]', thought, re.DOTALL)
if action_match:
action_type = action_match.group(1).strip()
action_content = action_match.group(2).strip()
# 清理代码格式，保证执行时无冗余内容
action_content = re.sub(r'```python|```|\n{3,}', '\n', action_content)
action_content = re.sub(r'\n{2,}', '\n', action_content)
action_content = action_content.strip('\n')
return action_type, action_content
else:
return "Unknown", thought

（2）运行循环：ReAct 流程落地

这是 Agent 的核心执行逻辑，通过循环实现「思考→行动→观察」的闭环，直到任务完成或达到最大步数：

MAX_STEPS=10  # 防止无限循环
def run(self) -> str:
"""运行修复后的ReAct循环"""
print(f"=== 修复版代码ReAct Agent（Ollama） ===\n目标：{self.goal}\n\n")
for step in range(1, MAX_STEPS + 1):
print(f"\n==== 第 {step} 步 ====")
# 1. 思考：调用LLM，基于当前状态决策下一步
print("🔍 思考阶段：调用Ollama...")
llm_question = f"""
当前状态：{self.current_state}
请严格按流程执行下一步行动，仅输出Action指令：
- 若未生成代码：生成核心函数
- 若代码已生成：生成测试用例
- 若测试通过：结束任务
"""
thought = self.llm.chat(question=llm_question, prompt=self.system_prompt)
print(f"Ollama输出：\n{thought}")
# 2. 行动：解析并执行LLM指定的动作
action_type, action_content = self._parse_action(thought)
print(f"\n🚀 行动阶段：执行 {action_type}...")
# 3. 观察：获取动作结果，更新状态
if action_type == "GenerateCode":
observation = self.code_tools.generate_code(action_content)
self.core_code = action_content  # 保存核心代码
elif action_type == "ExecuteCode":
observation = self.code_tools.execute_code(action_content, self.core_code)
elif action_type == "Finish":
observation = action_content
print(f"\n📌 观察阶段：\n{observation}")
break
elif action_type == "Error":
observation = f"错误：{action_content}"
else:
observation = f"⚠️ 未知行动：{action_type}，请检查Ollama输出格式"
# 更新状态，为下一步思考做准备
self.current_state = observation
print(f"\n📌 观察阶段：\n{observation}")
# 终止条件：任务完成/出错时退出
if action_type in ["Finish", "Error"] or (action_type == "ExecuteCode" and "✅ 执行成功" in observation):
break
# 生成最终报告
final_report = f"""
=== 任务完成报告 ===
目标：{self.goal}
核心代码：
{self.core_code}
执行结果：
{self.current_state}
"""
return final_report

四、实战运行：生成「偶数平方和」函数

我们以「编写 Python 函数，输入数字列表输出所有偶数的平方和」为任务目标，运行 Agent 看完整流程：

4.1 运行代码

if __name__ == "__main__":
# 定义任务目标
task_goal = """
编写一个Python函数，输入一个数字列表，输出列表中所有偶数的平方和。
要求：
1. 处理空列表、负数、零等边界情况；
2. 生成测试用例验证函数正确性；
3. 确保代码可直接运行，无语法错误。
"""
# 创建并运行Agent
agent = CodeReActAgent(goal=task_goal)
final_result = agent.run()
# 输出最终结果
print("\n" + "="*50)
print(final_result)

4.2 运行流程解析

1. 第 1 步（思考 + 行动）

   LLM 生成核心函数代码，工具链校验语法通过；

2. 第 2 步（思考 + 行动）

   LLM 基于「语法校验成功」的状态，生成测试用例代码；

3. 第 3 步（执行 + 观察）

   工具链执行测试代码，验证函数逻辑正确；

4. 终止

   测试通过，Agent 输出总结报告，任务完成。

最终生成的核心代码示例：

def sum_of_squares_of_evens(numbers):
"""
计算列表中所有偶数的平方和
Args:
numbers: 数字列表
Returns:
int: 偶数的平方和
"""
return sum(num ** 2 for num in numbers if num % 2 == 0)

测试代码示例：

def test_sum_of_squares_of_evens():
# 测试空列表
assert sum_of_squares_of_evens([]) == 0, "空列表测试失败"
# 测试包含正偶数
assert sum_of_squares_of_evens([1, 2, 3, 4]) == 20, "正偶数测试失败"
# 测试包含负数偶数
assert sum_of_squares_of_evens([-2, -4, 1, 3]) == 20, "负数偶数测试失败"
# 测试包含零
assert sum_of_squares_of_evens([0, 1, 3]) == 0, "零测试失败"
# 测试无偶数
assert sum_of_squares_of_evens([1, 3, 5]) == 0, "无偶数测试失败"
# 测试全为偶数
assert sum_of_squares_of_evens([2, 4, 6]) == 56, "全偶数测试失败"
print("所有测试用例通过")
if __name__ == '__main__':
test_sum_of_squares_of_evens()

五、总结：Agent 构建的核心思路

本文从 ReAct 框架原理出发，先实现基础的工具链和 LLM 调用模块，再组装成完整的 Code Agent，核心思路可总结为：

1. 分层设计

将「思考（LLM）」和「执行（工具）」解耦，Agent 只负责决策，具体操作交给专用工具；

1. 流程约束

   通过系统提示词严格定义 ReAct 循环，确保 LLM 按既定逻辑思考，而非自由生成；

2. 状态闭环

   每一步行动的结果都更新为「当前状态」，作为下一步思考的依据，形成闭环；

3. 容错控制

   设置最大步数、错误处理逻辑，避免 Agent 无限循环或执行异常。

这个简单的 Code Agent 展示了 LLM Agent 的核心范式 —— 不是让大模型「凭空生成」结果，而是让它作为「决策者」，结合专业工具完成复杂任务。

学AI大模型的正确顺序，千万不要搞错了

🤔2026年AI风口已来！各行各业的AI渗透肉眼可见，超多公司要么转型做AI相关产品，要么高薪挖AI技术人才，机遇直接摆在眼前！

有往AI方向发展，或者本身有后端编程基础的朋友，直接冲AI大模型应用开发转岗超合适！

就算暂时不打算转岗，了解大模型、RAG、Prompt、Agent这些热门概念，能上手做简单项目，也绝对是求职加分王🔋

📝给大家整理了超全最新的AI大模型应用开发学习清单和资料，手把手帮你快速入门！👇👇

学习路线:

✅大模型基础认知—大模型核心原理、发展历程、主流模型（GPT、文心一言等）特点解析
✅核心技术模块—RAG检索增强生成、Prompt工程实战、Agent智能体开发逻辑
✅开发基础能力—Python进阶、API接口调用、大模型开发框架（LangChain等）实操
✅应用场景开发—智能问答系统、企业知识库、AIGC内容生成工具、行业定制化大模型应用
✅项目落地流程—需求拆解、技术选型、模型调优、测试上线、运维迭代
✅面试求职冲刺—岗位JD解析、简历AI项目包装、高频面试题汇总、模拟面经

以上6大模块，看似清晰好上手，实则每个部分都有扎实的核心内容需要吃透！

我把大模型的学习全流程已经整理📚好了！抓住AI时代风口，轻松解锁职业新可能，希望大家都能把握机遇，实现薪资/职业跃迁～

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】