引言：为什么要学习 Agentic AI 编程？

在 AI 技术爆发的今天，“编程” 的定义正在被重塑 —— 传统编程依赖人类编写每一行代码、处理每一个逻辑，而AI 编程则通过大语言模型（LLM）辅助生成、调试、优化代码；更进一步，Agentic AI（智能体 AI） 则让 AI 具备了 “自主规划、自主执行、自主反馈” 的能力，能独立完成复杂编程任务（如全流程开发一个小应用）。

本教程将从基础概念出发，结合大量可运行代码、Mermaid 流程图和Prompt 示例，带您掌握：

1. Agentic AI 的核心原理与传统 AI 的差异
2. 主流 AI 编程工具的使用方法
3. 如何用 LangChain 等框架自定义编程 Agent
4. 多 Agent 协作完成完整项目开发

无论您是零基础编程新手，还是想提升效率的资深开发者，都能通过本教程入门 Agentic AI 编程，实现 “让 AI 帮你写代码” 的目标。

第一部分：基础概念篇 —— 读懂 Agentic AI 与 AI 编程

在动手实践前，我们需要先理清核心概念，避免后续操作中 “知其然不知其所以然”。

1.1 什么是 Agentic AI？核心特征解析

Agentic AI（智能体 AI） 是指具备 “自主智能体” 属性的 AI 系统，它能基于目标主动规划步骤、调用工具、处理反馈，无需人类逐步指导。

Agentic AI 的核心特征（4 个关键能力）

特征	定义	编程场景示例
目标导向	明确理解任务目标，并围绕目标制定行动计划	接收 “开发 Todo 应用” 指令后，规划 “需求分析→代码生成→测试” 步骤
工具调用	自主调用外部工具（如代码库、API、调试工具）解决问题	生成代码后，自动调用 Pylint 检查语法错误
记忆能力	存储历史交互信息（短期记忆）和领域知识（长期记忆），辅助决策	记住用户之前要求 “使用 Flask 框架”，后续代码不切换框架
反馈迭代	分析执行结果，发现问题后调整方案，持续优化直到完成目标	测试发现 “添加 Todo 失败”，自动定位数据库连接 bug 并修复

Agentic AI vs 传统 AI：编程场景的本质差异

很多人会混淆 “传统 AI 辅助编程”（如 Copilot 基础功能）和 “Agentic AI 编程”，两者的核心差异在于 “自主性”：

flowchart LR
    A[人类需求] --> B[传统AI（如Copilot基础版）]
    B --> C[生成单段代码片段]
    C --> D[人类手动整合/调试/测试]
    D --> E[完成项目]

    A --> F[Agentic AI（如自定义编程Agent）]
    F --> G[自主规划任务流程]
    G --> H[调用工具生成完整代码]
    H --> I[自动调试+测试]
    I --> J[反馈迭代优化]
    J --> E

通俗举例：

• 传统 AI：你说 “写一个 Python 函数计算斐波那契数列”，它返回一个函数代码（需你自己判断是否正确、是否符合项目需求）。
• Agentic AI：你说 “用 Python 写一个斐波那契数列工具，要求支持输入数字范围、输出 CSV 文件”，它会先规划 “函数设计→文件写入→异常处理”，然后生成完整代码，甚至自动测试输入10是否能输出正确 CSV。

1.2 AI 编程入门：核心工具与适用场景

在 Agentic AI 编程前，先掌握主流 AI 编程工具的基础用法，这些工具是后续自定义 Agent 的 “基础组件”。

主流 AI 编程工具对比表

工具名称	核心特点	适用人群	支持语言 / 框架	免费 / 付费模式
GitHub Copilot	与 IDE 深度集成（VS Code/IntelliJ）、实时补全	全阶段开发者	几乎所有主流语言（Python/Java/JS 等）	付费（$19.99 / 月），学生免费
CodeLlama	Meta 开源、可本地部署、支持长代码	需本地隐私部署的团队	Python/C++/Java/JS 等	完全开源免费
Amazon CodeWhisperer	支持 AWS 服务集成、多 IDE 支持	用 AWS 生态的开发者	主流语言	基础功能免费，高级功能付费
ChatGPT（Code 模式）	支持自然语言转代码、代码解释	新手 / 需快速验证逻辑的开发者	主流语言	免费版有限，Plus 版（$20 / 月）

新手推荐：优先使用「GitHub Copilot + VS Code」，因为集成度最高、上手最快；若需本地部署，选择「CodeLlama + Ollama」（Ollama 可简化 CodeLlama 的部署流程）。

第二部分：实战入门篇 ——AI 编程基础操作（含代码与 Prompt）

本部分将从 “零门槛” 开始，带您用 AI 工具完成 “生成代码→调试代码→优化代码” 的全流程，掌握 AI 编程的核心 Prompt 技巧。

2.1 实战 1：用 Copilot 生成简单 Python 计算器（附 Prompt）

目标：生成一个支持 “加减乘除” 的 Python 计算器，要求：

1. 接收用户输入的两个数字和运算符
2. 处理 “除数为 0” 等异常情况
3. 输出清晰的计算结果

操作步骤：

1. 打开 VS Code，新建文件calculator.py
2. 在文件顶部输入Prompt 注释（AI 会识别注释中的需求）：

   python

   运行

   # 需求：Python计算器程序
   # 功能：
   # 1. 接收用户输入的两个数字（支持整数和小数）
   # 2. 接收用户输入的运算符（+、-、*、/）
   # 3. 执行计算并输出结果
   # 4. 异常处理：除数为0时提示错误，输入非数字时提示错误
   # 5. 计算完成后询问用户是否继续使用
   

3. 按下Enter，Copilot 会自动生成完整代码，生成后无需修改即可运行。

生成的完整代码（可直接复制运行）：

python

运行

# 需求：Python计算器程序
# 功能：
# 1. 接收用户输入的两个数字（支持整数和小数）
# 2. 接收用户输入的运算符（+、-、*、/）
# 3. 执行计算并输出结果
# 4. 异常处理：除数为0时提示错误，输入非数字时提示错误
# 5. 计算完成后询问用户是否继续使用

def get_valid_number(prompt):
    """获取用户输入的有效数字（支持整数和小数）"""
    while True:
        try:
            number = float(input(prompt))
            return number
        except ValueError:
            print("输入错误！请输入有效的数字（如10、3.14）。")

def get_valid_operator():
    """获取用户输入的有效运算符（+、-、*、/）"""
    operators = ['+', '-', '*', '/']
    while True:
        operator = input("请输入运算符（+、-、*、/）：")
        if operator in operators:
            return operator
        print("输入错误！请输入正确的运算符（+、-、*、/）。")

def calculate(num1, num2, operator):
    """执行计算并返回结果，处理异常情况"""
    try:
        if operator == '+':
            return num1 + num2
        elif operator == '-':
            return num1 - num2
        elif operator == '*':
            return num1 * num2
        elif operator == '/':
            if num2 == 0:
                raise ZeroDivisionError("除数不能为0！")
            return num1 / num2
    except ZeroDivisionError as e:
        return str(e)

def main():
    print("=== Python AI计算器 ===")
    while True:
        # 获取用户输入
        num1 = get_valid_number("请输入第一个数字：")
        num2 = get_valid_number("请输入第二个数字：")
        operator = get_valid_operator()
        
        # 执行计算
        result = calculate(num1, num2, operator)
        
        # 输出结果
        if isinstance(result, str):
            print(f"计算失败：{result}")
        else:
            print(f"计算结果：{num1} {operator} {num2} = {result}")
        
        # 询问是否继续
        continue_flag = input("是否继续计算？（y/n）：").lower()
        if continue_flag != 'y':
            print("感谢使用，再见！")
            break

if __name__ == "__main__":
    main()

运行结果示例：

plaintext

=== Python AI计算器 ===
请输入第一个数字：10
请输入第二个数字：3
请输入运算符（+、-、*、/）：/
计算结果：10.0 / 3.0 = 3.3333333333333335
是否继续计算？（y/n）：n
感谢使用，再见！

关键 Prompt 技巧：

• 明确功能清单：用 “1. 2. 3.” 列出具体需求，避免 AI 遗漏功能（如本示例中的 “异常处理” 和 “继续使用”）。
• 指定技术细节：若有框架 / 语法要求（如 “用 Python 3.9+”“不使用第三方库”），需明确写入 Prompt。

2.2 实战 2：用 ChatGPT Debug JavaScript 数组排序 bug（附 Prompt）

问题场景：

以下 JavaScript 代码意图对 “学生成绩数组” 按 “分数降序” 排序，但运行后结果错误，请用 AI 定位并修复。

javascript

运行

// 学生成绩数组：姓名+分数
const students = [
    { name: "张三", score: 85 },
    { name: "李四", score: 92 },
    { name: "王五", score: 78 }
];

// 按分数降序排序
students.sort((a, b) => a.score - b.score);

// 输出排序结果
console.log("按分数降序排序：", students);

向 ChatGPT 提交的 Prompt：

plaintext

请帮我Debug以下JavaScript代码：
1. 代码功能：对学生成绩数组按分数降序排序
2. 问题：运行后输出的是升序（78→85→92），而非预期的降序（92→85→78）
3. 要求：
   - 指出bug所在位置
   - 解释bug原因
   - 提供修复后的完整代码
   - 说明修复原理

ChatGPT 的回复（核心内容）：

1. bug 位置：students.sort((a, b) => a.score - b.score);
2. bug 原因：JavaScript 的sort()方法中，回调函数返回值的含义是：
   • 返回负数：a 排在 b 前面（升序）
   • 返回正数：b 排在 a 前面（降序）
   • 返回0：顺序不变当前代码a.score - b.score会返回正数（如 92-85=7）时，a（李四，92）排在 b（张三，85）前面，实际是升序。
3. 修复后代码：

   javascript

   运行

   const students = [
       { name: "张三", score: 85 },
       { name: "李四", score: 92 },
       { name: "王五", score: 78 }
   ];
   
   // 修复：将a.score - b.score 改为 b.score - a.score
   students.sort((a, b) => b.score - a.score);
   
   console.log("按分数降序排序：", students);
   

4. 修复原理：b.score - a.score中，当 b 的分数更高时（如李四 92 vs 张三 85），返回92-85=7（正数），此时 b（李四）排在 a（张三）前面，实现降序。

运行修复后代码的结果：

plaintext

按分数降序排序： [
  { name: '李四', score: 92 },
  { name: '张三', score: 85 },
  { name: '王五', score: 78 }
]

关键 Prompt 技巧：

• 提供上下文：明确 “代码功能” 和 “当前问题”，避免 AI 误解需求。
• 指定输出格式：要求 AI“指出位置→解释原因→提供代码→说明原理”，让回复更结构化，便于理解。

2.3 实战 3：用 CodeLlama 优化 Python 代码（附 Prompt）

原始代码：

以下 Python 代码功能是 “统计文本中每个单词的出现次数”，但代码冗余、效率低，请用 AI 优化。

python

运行

# 统计文本中单词出现次数
text = "I love AI I love programming AI is interesting"

# 步骤1：将文本转为小写
text_lower = text.lower()

# 步骤2：分割成单词（按空格）
words = text_lower.split(" ")

# 步骤3：统计次数
count_dict = {}
for word in words:
    if word in count_dict:
        count_dict[word] = count_dict[word] + 1
    else:
        count_dict[word] = 1

# 步骤4：输出结果
print("单词出现次数：", count_dict)

向 CodeLlama 提交的 Prompt（通过 Ollama 本地调用）：

plaintext

优化以下Python代码，要求：
1. 功能不变：统计文本中每个单词的出现次数（忽略大小写）
2. 优化方向：
   - 减少代码行数，提高简洁性
   - 提高执行效率（尤其处理长文本时）
   - 兼容文本中的标点符号（如原始文本若有"I love AI!"，需排除"!"）
3. 输出：
   - 优化后的代码
   - 优化点说明

CodeLlama 的优化结果：

python

运行

from collections import Counter
import re

def count_word_frequency(text):
    """统计文本中单词出现次数（忽略大小写、排除标点符号）"""
    # 1. 转为小写+用正则提取所有单词（排除标点，仅保留字母）
    words = re.findall(r'\b[a-zA-Z]+\b', text.lower())
    # 2. 用Counter快速统计次数（比手动循环更高效）
    return dict(Counter(words))

# 测试
text = "I love AI I love programming AI is interesting"
print("单词出现次数：", count_word_frequency(text))

优化点说明（CodeLlama 输出）：

1. 效率提升：用collections.Counter替代手动for循环，Counter 是 Python 内置的高效计数工具，底层用哈希表实现，比手动判断更快。
2. 兼容性提升：用re.findall(r'\b[a-zA-Z]+\b', text.lower())提取单词，可自动排除标点符号（如 "I love AI!" 会提取为 ["i", "love", "ai"]）。
3. 可复用性提升：封装为函数count_word_frequency，支持传入任意文本，便于后续调用。
4. 代码简洁：从 15 行精简到 8 行（核心逻辑仅 2 行），可读性更高。

运行结果：

plaintext

单词出现次数： {'i': 2, 'love': 2, 'ai': 2, 'programming': 1, 'is': 1, 'interesting': 1}

第三部分：Agentic AI 进阶篇 —— 自定义编程 Agent（LangChain 实战）

掌握基础 AI 编程后，我们进入核心环节：自定义 Agentic AI 编程智能体。本节将用「LangChain」框架（最流行的 Agent 开发框架）搭建一个 “代码审查 Agent”，让 AI 自主完成代码质量检查。

3.1 核心准备：环境搭建

1. 安装依赖包

打开终端，执行以下命令安装 LangChain、OpenAI SDK（用于调用 GPT-4）、代码检查工具：

bash

# 安装LangChain核心包
pip install langchain==0.2.5
# 安装OpenAI SDK（用于调用GPT模型）
pip install openai==1.30.5
# 安装代码检查工具（pylint用于Python代码检查）
pip install pylint==3.2.2
# 安装环境变量管理工具（python-dotenv，用于存储API密钥）
pip install python-dotenv==1.0.1

2. 配置 OpenAI API 密钥

1. 前往OpenAI 官网注册账号，获取 API 密钥（需绑定信用卡，有免费额度）。
2. 在项目文件夹中新建.env文件，写入：

   env

   OPENAI_API_KEY=你的API密钥（如sk-xxxxxx）
   

3.2 实战：搭建 “代码审查 Agent”（完整代码 + 流程图）

Agent 目标：

接收 Python 代码，自主完成以下任务：

1. 检查代码语法错误（调用 pylint 工具）
2. 分析代码可读性（变量命名、注释完整性）
3. 识别性能问题（如低效循环、冗余代码）
4. 生成结构化审查报告（含问题列表 + 修复建议）

代码实现（含详细注释）：

python

运行

# 1. 导入所需模块
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import ShellTool  # 用于调用系统命令（如pylint）
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from dotenv import load_dotenv
import os

# 2. 加载环境变量（读取OpenAI API密钥）
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

# 3. 初始化核心组件
# 3.1 初始化LLM模型（用GPT-4，性能优于GPT-3.5）
llm = ChatOpenAI(
    model="gpt-4o-mini",  # 推荐新手用gpt-4o-mini（成本低、速度快）
    api_key=api_key,
    temperature=0.3  # 温度越低，输出越严谨（代码审查需低温度）
)

# 3.2 定义工具：ShellTool（用于调用pylint检查代码）
tools = [ShellTool()]  # ShellTool允许Agent执行系统命令

# 3.3 定义Agent Prompt（核心：告诉Agent“你是谁、要做什么、怎么用工具”）
prompt = ChatPromptTemplate.from_messages([
    # 1. Agent身份与目标
    ("system", """
    你是一个专业的Python代码审查Agent，你的任务是：
    - 接收用户提供的Python代码，全面检查代码质量
    - 必须先调用ShellTool执行`pylint`命令检查语法错误（命令格式：pylint --errors-only 代码文件路径）
    - 再分析代码的可读性（变量命名是否规范、注释是否完整）
    - 最后识别性能问题（如手动循环替代Counter、未使用列表推导式等）
    - 生成结构化审查报告，包含：
      1. 语法错误列表（若有）
      2. 可读性问题列表（若有）
      3. 性能优化建议（若有）
      4. 修复后的完整代码（仅修复已发现的问题）
    
    注意事项：
    - 若用户未提供代码文件，先询问用户“请提供Python代码文件的路径”
    - 执行pylint命令时，确保文件路径正确（如用户提供的是./test.py，直接使用该路径）
    - 若pylint无错误输出，在报告中注明“未发现语法错误”
    """),
    # 2. 历史交互记忆（让Agent记住之前的对话）
    MessagesPlaceholder(variable_name="chat_history"),
    # 3. 用户输入
    ("user", "{input}"),
    # 4. 工具调用记录（让Agent知道已调用的工具结果）
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# 4. 创建Agent与Agent执行器
# 4.1 创建工具调用Agent（根据Prompt和工具生成Agent）
agent = create_tool_calling_agent(llm, tools, prompt)

# 4.2 创建Agent执行器（负责运行Agent、处理工具调用、迭代反馈）
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,  # 开启详细日志（便于查看Agent的思考过程）
    handle_parsing_errors=True  # 自动处理工具调用格式错误
)

# 5. 定义用户交互函数（让用户输入代码文件路径）
def run_code_review_agent():
    print("=== Python代码审查Agent ===")
    code_file_path = input("请提供Python代码文件的路径（如./bad_code.py）：")
    
    # 6. 运行Agent（传入用户输入，执行代码审查）
    result = agent_executor.invoke({
        "input": f"请审查以下Python代码文件：{code_file_path}"
    })
    
    # 7. 输出审查结果
    print("\n=== 代码审查报告 ===")
    print(result["output"])

# 8. 启动Agent
if __name__ == "__main__":
    run_code_review_agent()

Agent 工作流程图（Mermaid）：

flowchart TD
    A[用户启动Agent] --> B[用户输入Python代码文件路径]
    B --> C[Agent接收输入，读取Prompt指令]
    C --> D[Agent调用ShellTool，执行pylint命令]
    D --> E{是否有语法错误？}
    E -- 是 --> F[记录语法错误列表]
    E -- 否 --> G[记录“未发现语法错误”]
    F & G --> H[Agent分析代码可读性（变量命名/注释）]
    H --> I[Agent识别性能问题（低效循环/冗余代码）]
    I --> J[Agent生成结构化审查报告（问题+修复建议+完整代码）]
    J --> K[输出报告给用户]

测试 Agent：用 “有问题的 Python 代码” 验证

1. 在项目文件夹中新建bad_code.py，写入有问题的代码：

   python

   运行

   # 有问题的代码：统计单词次数（无注释、低效循环、变量命名不规范）
   t = "I love AI I love programming AI is interesting"
   tl = t.lower()
   ws = tl.split(" ")
   cd = {}
   for w in ws:
       if w in cd:
           cd[w] = cd[w] + 1
       else:
           cd[w] = 1
   print(cd)
   

2. 运行代码审查 Agent，输入文件路径./bad_code.py，Agent 会输出以下报告（核心内容）：

   plaintext

   === 代码审查报告 ===
   1. 语法错误列表：未发现语法错误（pylint输出无错误）
   
   2. 可读性问题列表：
      - 变量命名不规范：t（应改为text）、tl（应改为text_lower）、ws（应改为words）、cd（应改为word_count）
      - 缺少注释：无函数注释、无关键步骤注释，不利于后续维护
   
   3. 性能优化建议：
      - 低效循环：手动for循环统计次数，可替换为collections.Counter（更高效）
      - 未处理标点符号：split(" ")仅按空格分割，若文本有标点（如"I love AI!"）会统计错误
   
   4. 修复后的完整代码：
      from collections import Counter
      import re
   
      def count_word_frequency(text):
          """
          统计文本中单词出现次数（忽略大小写、排除标点符号）
          参数：text - 输入文本（str）
          返回：word_count - 单词次数字典（dict）
          """
          # 提取单词（排除标点，仅保留字母）并转为小写
          words = re.findall(r'\b[a-zA-Z]+\b', text.lower())
          # 用Counter高效统计次数
          word_count = dict(Counter(words))
          return word_count
   
      # 测试
      text = "I love AI I love programming AI is interesting"
      word_count = count_word_frequency(text)
      print("单词出现次数：", word_count)
   

3.3 关键技术解析：Agent 为什么能自主工作？

1. Prompt 工程：Prompt 中明确了 Agent 的 “身份（代码审查专家）”“任务流程（先调用工具→再分析→最后生成报告）”“输出格式（结构化报告）”，这是 Agent 自主决策的基础。
2. 工具调用：通过ShellTool让 Agent 具备 “执行系统命令” 的能力，突破了 LLM “只能生成文本” 的限制，能与外部工具交互。
3. 记忆与迭代：MessagesPlaceholder(variable_name="chat_history")让 Agent 记住历史对话，agent_scratchpad记录工具调用结果，Agent 会基于这些信息调整后续步骤（如先看 pylint 结果，再分析可读性）。

第四部分：多 Agent 协作实战 —— 用 3 个 Agent 开发 Todo 应用

单一 Agent 适合完成单一任务（如代码审查），而复杂项目需要多 Agent 协作。本节将用 3 个 Agent（需求分析 Agent、开发 Agent、测试 Agent）协作开发一个 “Flask Todo 应用”，全程无需手动写代码。

4.1 多 Agent 分工设计（Mermaid 流程图）

flowchart TD
    A[项目启动：开发Flask Todo应用] --> B[需求分析Agent]
    B --> C[输出《需求文档》：功能清单+技术栈]
    C --> D[开发Agent]
    D --> E[基于需求文档生成完整代码：前端+后端+数据库]
    E --> F[测试Agent]
    F --> G[自动测试代码：功能测试+语法检查]
    G --> H{测试通过？}
    H -- 是 --> I[输出可运行的Todo应用]
    H -- 否 --> J[反馈问题给开发Agent，重新生成代码]
    J --> D

3 个 Agent 的核心职责：

Agent 名称	核心职责	依赖工具 / 框架
需求分析 Agent	接收用户模糊需求（如 “做一个能添加 / 删除 Todo 的应用”），生成详细需求文档	无（依赖 LLM 的需求分析能力）
开发 Agent	基于需求文档，生成 Flask 后端代码、HTML 前端代码、SQLite 数据库配置	LangChain + Flask + SQLite
测试 Agent	运行代码、检查语法错误、验证功能是否正常（如添加 Todo 后是否能显示）	ShellTool（pylint）+ Requests（接口测试）

4.2 完整实现代码（多 Agent 协作）

python

运行

# 多Agent协作开发Flask Todo应用
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import ShellTool, tool
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
from dotenv import load_dotenv
import os
import requests

# 1. 加载环境变量
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
llm = ChatOpenAI(model="gpt-4o-mini", api_key=api_key, temperature=0.2)

# 2. 自定义工具：Todo应用测试工具（检查应用是否能正常运行）
@tool
def test_todo_app(app_file_path: str) -> str:
    """
    测试Flask Todo应用是否正常运行，功能包括：
    1. 启动Flask应用（后台运行）
    2. 发送请求测试“添加Todo”“获取Todo列表”“删除Todo”功能
    3. 停止Flask应用
    4. 返回测试结果（成功/失败+原因）
    
    参数：app_file_path - Flask应用代码文件路径（如./todo_app.py）
    """
    import subprocess
    import time

    # 步骤1：启动Flask应用（后台运行）
    try:
        # 设置Flask环境变量
        env = os.environ.copy()
        env["FLASK_APP"] = app_file_path
        env["FLASK_ENV"] = "development"
        # 启动应用（后台进程）
        process = subprocess.Popen(
            ["flask", "run", "--port", "5000"],
            env=env,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
        )
        time.sleep(5)  # 等待应用启动
    except Exception as e:
        return f"启动应用失败：{str(e)}"

    # 步骤2：测试核心功能
    test_results = []
    base_url = "http://127.0.0.1:5000"

    # 测试1：添加Todo
    try:
        add_response = requests.post(f"{base_url}/add", json={"task": "测试Todo任务"})
        if add_response.status_code == 200 and "success" in add_response.json():
            test_results.append("✅ 添加Todo功能正常")
        else:
            test_results.append(f"❌ 添加Todo失败：{add_response.text}")
    except Exception as e:
        test_results.append(f"❌ 添加Todo报错：{str(e)}")

    # 测试2：获取Todo列表
    try:
        list_response = requests.get(f"{base_url}/list")
        if list_response.status_code == 200 and isinstance(list_response.json(), list):
            test_results.append("✅ 获取Todo列表功能正常")
            test_results.append(f"   当前Todo列表：{list_response.json()}")
        else:
            test_results.append(f"❌ 获取Todo列表失败：{list_response.text}")
    except Exception as e:
        test_results.append(f"❌ 获取Todo列表报错：{str(e)}")

    # 测试3：删除Todo（假设删除第一个Todo）
    try:
        delete_response = requests.post(f"{base_url}/delete", json={"id": 1})
        if delete_response.status_code == 200 and "success" in delete_response.json():
            test_results.append("✅ 删除Todo功能正常")
        else:
            test_results.append(f"❌ 删除Todo失败：{delete_response.text}")
    except Exception as e:
        test_results.append(f"❌ 删除Todo报错：{str(e)}")

    # 步骤3：停止Flask应用
    process.terminate()
    process.wait()
    test_results.append("✅ 应用已停止")

    # 步骤4：返回测试结果
    return "\n".join(test_results)

# 3. 定义3个Agent
## 3.1 需求分析Agent
def create_requirement_agent():
    prompt = ChatPromptTemplate.from_messages([
        ("system", """
        你是需求分析专家Agent，负责将用户模糊的应用需求转化为详细的技术需求文档。
        输入：用户对Todo应用的需求描述
        输出：《Todo应用需求文档》，包含：
        1. 核心功能清单（如添加/删除/查看Todo）
        2. 技术栈选择（后端：Flask；前端：HTML+CSS；数据库：SQLite；语言：Python）
        3. 接口设计（如/add接口：POST请求，参数task；/list接口：GET请求）
        4. 数据模型（如Todo表：id（主键）、task（任务内容）、created_at（创建时间））
        """),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])
    agent = create_tool_calling_agent(llm, [], prompt)  # 需求分析无需工具
    return AgentExecutor(agent=agent, tools=[], verbose=True, handle_parsing_errors=True)

## 3.2 开发Agent
def create_development_agent():
    tools = [ShellTool()]  # 用于生成文件
    prompt = ChatPromptTemplate.from_messages([
        ("system", """
        你是Flask开发专家Agent，负责基于需求文档生成完整的Todo应用代码。
        任务：
        1. 生成3个文件：
           - todo_app.py（Flask后端代码：路由+数据库操作）
           - templates/index.html（前端页面：Todo列表+添加/删除按钮）
           - schema.sql（数据库表结构）
        2. 代码要求：
           - 后端：使用Flask-SQLAlchemy操作SQLite数据库
           - 前端：简洁美观，使用基础CSS样式
           - 数据库：自动创建Todo表，支持增删查操作
           - 代码需包含注释，便于理解
        3. 生成后，用ShellTool执行`touch todo_app.py templates/index.html schema.sql`创建文件，再写入代码
        输入：《Todo应用需求文档》
        输出：代码生成完成的提示（告知用户文件路径）
        """),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])
    agent = create_tool_calling_agent(llm, tools, prompt)
    return AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

## 3.3 测试Agent
def create_test_agent():
    tools = [ShellTool(), test_todo_app]  # 包含自定义测试工具
    prompt = ChatPromptTemplate.from_messages([
        ("system", """
        你是软件测试专家Agent，负责测试Flask Todo应用的功能完整性。
        任务流程：
        1. 先用ShellTool执行`pylint todo_app.py`检查语法错误
        2. 再调用test_todo_app工具测试核心功能（添加/删除/查看）
        3. 生成测试报告：包含语法检查结果、功能测试结果、问题修复建议
        输入：Flask应用代码文件路径（如./todo_app.py）
        输出：《Todo应用测试报告》
        """),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])
    agent = create_tool_calling_agent(llm, tools, prompt)
    return AgentExecutor(agent=agent, tools=tools, verbose=True, handle_parsing_errors=True)

# 4. 多Agent协作流程
def run_multi_agent_todo_project():
    print("=== 多Agent协作开发Flask Todo应用 ===")
    
    # 步骤1：需求分析
    print("\n【步骤1：需求分析】")
    requirement_agent = create_requirement_agent()
    user_requirement = input("请输入Todo应用的需求（如“做一个能添加、删除、查看Todo的网页应用”）：")
    requirement_doc = requirement_agent.invoke({"input": user_requirement})["output"]
    print("\n生成的需求文档：")
    print(requirement_doc)

    # 步骤2：代码开发
    print("\n【步骤2：代码开发】")
    development_agent = create_development_agent()
    development_result = development_agent.invoke({"input": requirement_doc})["output"]
    print(development_result)

    # 步骤3：测试
    print("\n【步骤3：应用测试】")
    test_agent = create_test_agent()
    test_result = test_agent.invoke({"input": "./todo_app.py"})["output"]
    print("\n生成的测试报告：")
    print(test_result)

    # 步骤4：运行提示
    print("\n=== 项目完成 ===")
    print("运行命令启动应用：flask run --port 5000")
    print("访问 http://127.0.0.1:5000 即可使用Todo应用")

# 5. 启动多Agent项目
if __name__ == "__main__":
    # 确保templates文件夹存在（前端页面存放目录）
    if not os.path.exists("templates"):
        os.makedirs("templates")
    run_multi_agent_todo_project()

4.3 运行结果与验证

1. 运行代码后，输入用户需求：“做一个能添加、删除、查看 Todo 的网页应用，要求界面简洁，数据保存在本地”。
2. 多 Agent 会自动完成 “需求分析→代码生成→测试”，最终生成 3 个文件：
   • todo_app.py（后端代码）
   • templates/index.html（前端页面）
   • schema.sql（数据库表结构）
3. 执行flask run --port 5000，访问http://127.0.0.1:5000，即可使用 Todo 应用：
   • 输入任务内容，点击 “添加” 按钮，任务会显示在列表中。
   • 点击任务后的 “删除” 按钮，任务会从列表中移除。
   • 刷新页面，任务数据会保留（因为存在 SQLite 数据库中）。

第五部分：常见问题与进阶学习资源

5.1 Agentic AI 编程常见问题解决方案

问题类型	常见原因	解决方案
Agent 不调用工具	Prompt 中未明确 “必须调用工具”，或工具描述不清晰	在 Prompt 中加入 “必须调用 XX 工具完成 XX 步骤”，详细说明工具参数和使用场景
生成代码无法运行	LLM 版本过低（如 GPT-3.5）、需求描述模糊、未指定 Python 版本 / 框架	升级到 GPT-4o/GPT-4，在 Prompt 中明确 “使用 Python 3.10+”“用 Flask 2.0+”
Agent 陷入循环调用工具	工具返回结果不完整，或 Prompt 未明确 “何时停止调用工具”	优化工具返回格式（让结果更结构化），在 Prompt 中加入 “若工具返回 XX 结果，停止调用”
API 调用成本过高	频繁使用 GPT-4，或 Agent 迭代次数过多	先用 GPT-4o-mini 测试流程，优化 Prompt 减少迭代次数，设置 API 调用额度限制

5.2 进阶学习资源

1. 框架文档：
   • LangChain 官方文档：https://python.langchain.com/（最核心的 Agent 开发框架）
   • AutoGPT 文档：https://docs.agpt.co/（自主任务规划的 Agent 框架）
2. 课程：
   • Udemy《LangChain for LLM Application Development》（吴恩达推荐）
   • DeepLearning.AI《AI Agentic Design Patterns》（Agent 设计模式）
3. 社区：
   • LangChain Discord：https://discord.gg/langchain（获取最新开发技巧）
   • GitHub LangChain 示例库：https://github.com/langchain-ai/langchain/tree/master/examples（大量实战代码）

总结

本教程从基础概念出发，带您掌握了 Agentic AI 的核心原理、AI 编程工具的使用方法，并通过 “代码审查 Agent” 和 “多 Agent Todo 项目” 两个实战案例，展示了 Agentic AI 编程的完整流程。

Agentic AI 编程的核心不是 “让 AI 替代人类”，而是 “让 AI 成为人类的高效协作伙伴”—— 人类负责定义目标、把控方向，AI 负责执行繁琐的代码生成、调试、测试工作，最终实现 “1+1>2” 的开发效率提升。

随着 Agentic AI 技术的发展，未来会出现更多 “多 Agent 协作开发平台”“行业专用编程 Agent”（如 AI 生成区块链代码、AI 生成自动驾驶代码），掌握 Agentic AI 编程，将是未来开发者的核心竞争力之一。