feat: 添加智能编程导师毕业设计

Co-creation-projects/chen070808-ProgrammingTutor/.env.example

@@ -0,0 +1,14 @@
+# HelloAgents LLM配置
+
+# 模型名称
+LLM_MODEL_ID=Qwen/Qwen2.5-72B-Instruct
+
+# API密钥
+LLM_API_KEY=your_api_key_here
+
+# 服务地址
+LLM_BASE_URL=https://api-inference.modelscope.cn/v1
+
+# 超时时间(可选,默认60秒)
+LLM_TIMEOUT=60
+

Co-creation-projects/chen070808-ProgrammingTutor/README.md

@@ -0,0 +1,201 @@
+# 智能编程导师 (Intelligent Programming Tutor)
+
+一个基于 HelloAgents 框架的智能编程学习助手系统，提供个性化的编程学习体验。
+
+## 功能特点
+
+### 🎯 核心功能
+
+- **学习路径规划**：根据学习目标和当前水平，制定个性化的学习计划
+- **智能出题**：根据学习内容自动生成编程练习题
+- **代码评审**：对提交的代码进行专业评审，提供改进建议和最佳实践指导
+
+### 🤖 多智能体架构
+
+本项目采用多智能体协同工作模式，包含以下智能体：
+
+- **TutorAgent（导师）**：主协调智能体，负责理解用户需求并调用相应的子智能体
+- **PlannerAgent（规划师）**：制定个性化学习计划和路径
+- **ExerciseAgent（出题人）**：根据学习内容生成编程练习题
+- **ReviewerAgent（评审员）**：评审代码并提供专业反馈，支持代码执行测试
+
+## 项目结构
+
+```
+chen070808-ProgrammingTutor/
+├── src/
+│   ├── agents/          # 智能体定义
+│   │   ├── tutor.py     # 主导师智能体
+│   │   ├── planner.py   # 学习规划智能体
+│   │   ├── exercise.py  # 出题智能体
+│   │   └── reviewer.py  # 代码评审智能体
+│   └── tools/           # 工具定义
+│       ├── agent_tool.py    # A2A智能体工具包装
+│       └── code_runner.py   # 代码执行工具
+├── main.ipynb           # 示例演示 Notebook
+├── requirements.txt     # 项目依赖
+└── .env                 # 环境配置（需自行创建）
+```
+
+## 安装与配置
+
+### 1. 环境要求
+
+- Python 3.8+
+- HelloAgents 框架
+
+### 2. 安装依赖
+
+```bash
+pip install -r requirements.txt
+```
+
+### 3. 配置环境变量
+
+创建 `.env` 文件并配置以下参数：
+
+```bash
+# LLM 模型配置
+LLM_MODEL_ID=Qwen/Qwen2.5-72B-Instruct
+LLM_API_KEY=your_api_key_here
+LLM_BASE_URL=https://api-inference.modelscope.cn/v1
+LLM_TIMEOUT=60
+```
+
+参考 `.env.example` 文件了解完整配置选项。
+
+## 使用方法
+
+### 方式一：Jupyter Notebook
+
+打开 `main.ipynb` 并按顺序运行各个单元格，体验完整的学习流程：
+
+1. 学习路径规划
+2. 获取编程练习题
+3. 代码评审与反馈
+
+### 方式二：Python 代码
+
+```python
+from hello_agents import HelloAgentsLLM
+from src.agents.tutor import TutorAgent
+
+# 初始化 LLM
+llm = HelloAgentsLLM.from_env()
+
+# 创建导师智能体
+tutor = TutorAgent(llm)
+
+# 示例 1：请求学习计划
+response = tutor.run("我想学习 Python 中的列表推导式")
+print(response)
+
+# 示例 2：请求练习题
+response = tutor.run("请给我出一道关于列表推导式的练习题")
+print(response)
+
+# 示例 3：代码评审
+code = """
+numbers = [1, 2, 3, 4, 5]
+squares = []
+for n in numbers:
+    squares.append(n * n)
+"""
+response = tutor.run(f"请评审以下代码：{code}")
+print(response)
+```
+
+## 技术架构
+
+### 智能体协同机制
+
+- 采用 **Agent-to-Agent (A2A)** 工具调用模式
+- `TutorAgent` 通过工具接口调用子智能体：
+  - `call_planner(query)` - 调用学习规划师
+  - `call_exercise(query)` - 调用出题人
+  - `call_reviewer(query)` - 调用代码评审员
+
+### 代码执行能力
+
+`ReviewerAgent` 集成了 `CodeRunner` 工具，可以：
+- 安全执行用户提交的 Python 代码
+- 捕获运行时错误和异常
+- 基于执行结果提供更精准的反馈
+
+## 示例场景
+
+### 场景 1：学习路径规划
+
+**用户输入**：
+```
+我想学习 Python 中的装饰器，但我只了解基础的函数定义
+```
+
+**系统响应**：
+导师会调用 PlannerAgent，生成包含以下内容的学习计划：
+- 前置知识检查
+- 分阶段学习目标
+- 推荐学习资源
+- 实践项目建议
+
+### 场景 2：获取练习题
+
+**用户输入**：
+```
+请给我出一道关于装饰器的练习题
+```
+
+**系统响应**：
+ExerciseAgent 会生成一道练习题，包含：
+- 题目描述和要求
+- 输入输出示例
+- 难度级别
+- 考察知识点
+
+### 场景 3：代码评审
+
+**用户输入**：
+```python
+@decorator
+def greet(name):
+    print(f"Hello, {name}")
+```
+
+**系统响应**：
+ReviewerAgent 会：
+1. 执行代码检查语法和运行时错误
+2. 分析代码质量和最佳实践
+3. 提供改进建议
+4. 指出潜在问题
+
+## 开发与扩展
+
+### 添加新的智能体
+
+1. 在 `src/agents/` 目录下创建新的智能体类
+2. 继承 `SimpleAgent` 基类
+3. 在 `TutorAgent` 中注册新智能体工具
+
+### 自定义工具
+
+1. 在 `src/tools/` 目录下创建新工具类
+2. 继承 `Tool` 基类并实现 `run()` 方法
+3. 将工具注入到相应的智能体中
+
+## 注意事项
+
+- 确保 `.env` 文件配置正确，特别是 API 密钥
+- 代码执行功能默认启用沙箱模式，建议不要执行不可信代码
+- LLM 调用需要网络连接，请确保网络畅通
+
+## 贡献者
+
+- chen070808
+
+## 许可证
+
+本项目遵循 MIT 许可证。
+
+## 致谢
+
+本项目基于 [HelloAgents](https://github.com/datawhalechina/hello-agents) 框架开发。

Co-creation-projects/chen070808-ProgrammingTutor/main.ipynb

@@ -0,0 +1,534 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "252eb5a2",
+            "metadata": {},
+            "source": [
+                "# 智能编程导师 (Intelligent Programming Tutor)\n",
+                "\n",
+                "一个基于多智能体协作的个性化编程学习系统，展示了如何使用 `hello-agents` 框架构建复杂的 Agent-to-Agent (A2A) 协作系统。\n",
+                "\n",
+                "## 系统架构\n",
+                "\n",
+                "本系统采用分层智能体架构：\n",
+                "\n",
+                "- **Tutor（导师）**：主协调智能体，负责与用户交互并调度子智能体\n",
+                "- **Planner（规划师）**：分析用户需求，制定个性化学习计划\n",
+                "- **Exercise（出题人）**：根据学习内容生成针对性的编程练习题\n",
+                "- **Reviewer（评审员）**：评审用户代码，提供专业反馈和改进建议\n",
+                "\n",
+                "## 技术特点\n",
+                "\n",
+                "1. **多智能体协作**：使用 `AgentTool` 将子智能体封装为工具，实现 A2A 通信\n",
+                "2. **工具调用**：Reviewer 配备 `CodeRunner` 工具，可执行 Python 代码验证\n",
+                "3. **模块化设计**：每个智能体职责单一，易于维护和扩展\n",
+                "\n",
+                "## 演示说明\n",
+                "\n",
+                "本 notebook 包含三个完整的测试场景，展示了智能编程导师的核心功能。"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "setup_intro",
+            "metadata": {},
+            "source": [
+                "## 步骤 1：环境设置\n",
+                "\n",
+                "初始化 LLM 和环境配置。\n",
+                "\n",
+                "**关键组件**：\n",
+                "- `HelloAgentsLLM`：统一的 LLM 接口\n",
+                "- `.env` 文件：存储 API 密钥等敏感信息\n",
+                "- `src` 路径：包含自定义智能体和工具的实现"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "id": "3a142c96",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "✅ 环境配置完成\n",
+                        "✅ LLM 已初始化\n"
+                    ]
+                },
+                {
+                    "name": "stderr",
+                    "output_type": "stream",
+                    "text": [
+                        "/Users/chen/vs_code/hello_agent/hello-agents/.conda/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+                        "  from .autonotebook import tqdm as notebook_tqdm\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# 1. 环境设置\n",
+                "import os\n",
+                "import sys\n",
+                "from dotenv import load_dotenv\n",
+                "from hello_agents import HelloAgentsLLM\n",
+                "\n",
+                "load_dotenv()\n",
+                "\n",
+                "if \"src\" not in sys.path:\n",
+                "    sys.path.append(os.path.abspath(\"src\"))\n",
+                "\n",
+                "# 初始化 LLM\n",
+                "llm = HelloAgentsLLM()\n",
+                "\n",
+                "print(\"✅ 环境配置完成\")\n",
+                "print(\"✅ LLM 已初始化\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "tutor_init_intro",
+            "metadata": {},
+            "source": [
+                "## 步骤 2：初始化智能编程导师\n",
+                "\n",
+                "创建 `TutorAgent` 实例时，会自动：\n",
+                "1. 创建 Planner、Exercise、Reviewer 三个子智能体\n",
+                "2. 将子智能体封装为工具（`call_planner`、`call_exercise`、`call_reviewer`）\n",
+                "3. 注册 `CodeRunner` 工具给 Reviewer 使用\n",
+                "\n",
+                "**架构亮点**：\n",
+                "- 使用 `AgentTool` 实现 Agent-to-Agent 调用\n",
+                "- 每个子智能体有独立的 `system_prompt` 定义其专业领域\n",
+                "- Tutor 通过工具调用协调所有子智能体"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "7728b695",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "创建智能编程导师...\n",
+                        "✅ 工具 'code_runner' 已注册。\n",
+                        "✅ 工具 'call_planner' 已注册。\n",
+                        "✅ 工具 'call_exercise' 已注册。\n",
+                        "✅ 工具 'call_reviewer' 已注册。\n",
+                        "\n",
+                        "✅ Tutor 初始化完成！\n",
+                        "   - Planner（规划师）已就绪\n",
+                        "   - Exercise（出题人）已就绪\n",
+                        "   - Reviewer（评审员）已就绪\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# 2. 初始化 Tutor（自动创建所有子智能体）\n",
+                "from agents.tutor import TutorAgent\n",
+                "\n",
+                "print(\"创建智能编程导师...\")\n",
+                "tutor = TutorAgent(llm)\n",
+                "\n",
+                "print(\"\\n✅ Tutor 初始化完成！\")\n",
+                "print(\"   - Planner（规划师）已就绪\")\n",
+                "print(\"   - Exercise（出题人）已就绪\") \n",
+                "print(\"   - Reviewer（评审员）已就绪\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "072727a2",
+            "metadata": {},
+            "source": [
+                "---\n",
+                "\n",
+                "## 测试 1：请求学习计划\n",
+                "\n",
+                "演示 **Tutor → Planner** 的协作流程。\n",
+                "\n",
+                "**执行流程**：\n",
+                "1. 用户向 Tutor 表达学习目标\n",
+                "2. Tutor 识别意图并调用 `call_planner` 工具\n",
+                "3. Planner 分析需求，生成分模块的学习计划\n",
+                "4. Tutor 将学习计划友好地呈现给用户\n",
+                "\n",
+                "**期望输出**：包含多个学习模块、时间安排、学习建议的完整学习路径。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "id": "033dc763",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "用户目标: 我想学习 Python 中的列表推导式\n",
+                        "\n",
+                        "=== Tutor 回应 ===\n",
+                        "# Python列表推导式学习计划\n",
+                        "\n",
+                        "您好！很高兴为您制定Python列表推导式的学习计划。列表推导式是Python中一个强大而优雅的特性，能让您的代码更加简洁高效。\n",
+                        "\n",
+                        "## 学习目标\n",
+                        "掌握Python列表推导式的语法、应用场景和最佳实践，提升代码简洁性和可读性。\n",
+                        "\n",
+                        "## 详细学习路径\n",
+                        "\n",
+                        "### 模块1: 基础概念与语法 (2-3天)\n",
+                        "您将学习:\n",
+                        "- 列表推导式的基本语法结构 `[expression for item in iterable]`\n",
+                        "- 与传统for循环的对比\n",
+                        "- 理解表达式、迭代变量和可迭代对象的关系\n",
+                        "- 创建简单的数值列表\n",
+                        "- 字符串处理应用\n",
+                        "\n",
+                        "### 模块2: 条件过滤 (3-4天)\n",
+                        "您将学习:\n",
+                        "- 带条件的列表推导式 `[expression for item in iterable if condition]`\n",
+                        "- 单一条件过滤\n",
+                        "- 多条件组合 (and, or, not)\n",
+                        "- 实际应用场景：数据筛选、文本处理\n",
+                        "- 性能优势理解\n",
+                        "\n",
+                        "### 模块3: 复杂表达式与嵌套 (4-5天)\n",
+                        "您将学习:\n",
+                        "- 复杂表达式的构建\n",
+                        "- 嵌套列表推导式 `[[expression for item2 in iterable2] for item1 in iterable1]`\n",
+                        "- 处理二维列表和矩阵\n",
+                        "- 嵌套循环的简化\n",
+                        "- 可读性考虑\n",
+                        "\n",
+                        "### 模块4: 高级应用与其他推导式 (3-4天)\n",
+                        "您将学习:\n",
+                        "- 字典推导式 `{key_expr: value_expr for item in iterable}`\n",
+                        "- 集合推导式 `{expression for item in iterable}`\n",
+                        "- 生成器表达式 `(expression for item in iterable)`\n",
+                        "- 何时使用列表推导式 vs 其他方法\n",
+                        "- PEP 8规范和代码风格\n",
+                        "\n",
+                        "### 模块5: 实战项目与优化 (3-4天)\n",
+                        "您将学习:\n",
+                        "- 实际项目中的应用案例\n",
+                        "- 性能测试和比较\n",
+                        "- 代码重构练习\n",
+                        "- 常见陷阱和错误避免\n",
+                        "- 最佳实践总结\n",
+                        "\n",
+                        "## 学习建议\n",
+                        "- 每天编写至少3-5个练习代码\n",
+                        "- 结合实际数据处理场景练习\n",
+                        "- 注意代码可读性，避免过度复杂的推导式\n",
+                        "- 定期回顾和重构自己的代码\n",
+                        "\n",
+                        "**预计总时长:** 约2-3周 (根据个人基础调整)\n",
+                        "\n",
+                        "现在您想开始学习哪个模块呢？如果您需要相关的练习题来巩固所学知识，请随时告诉我！\n"
+                    ]
+                }
+            ],
+            "source": [
+                "user_goal = \"我想学习 Python 中的列表推导式\"\n",
+                "print(f\"用户目标: {user_goal}\\n\")\n",
+                "\n",
+                "# Tutor 会调用 call_planner 工具\n",
+                "response = tutor.run(f\"用户说：'{user_goal}'。请为用户制定学习计划。\")\n",
+                "\n",
+                "print(\"=== Tutor 回应 ===\")\n",
+                "print(response)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "test2_desc",
+            "metadata": {},
+            "source": [
+                "---\n",
+                "\n",
+                "## 测试 2：请求练习题\n",
+                "\n",
+                "演示 **Tutor → Exercise** 的协作流程。\n",
+                "\n",
+                "**执行流程**：\n",
+                "1. 用户向 Tutor 请求练习题\n",
+                "2. Tutor 调用 `call_exercise` 工具\n",
+                "3. Exercise 生成结构化的编程练习题\n",
+                "4. Tutor 返回包含题目描述、示例、约束条件的完整题目\n",
+                "\n",
+                "**期望输出**：一道高质量的编程练习题，包含：\n",
+                "- 题目描述\n",
+                "- 输入/输出示例\n",
+                "- 约束条件\n",
+                "- 函数签名"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "id": "6703c3c7",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "=== Tutor 回应 ===\n",
+                        "# Python 列表推导式练习题\n",
+                        "\n",
+                        "## 题目描述\n",
+                        "编写一个函数 `filter_and_square_numbers()`，该函数接收一个整数列表和一个阈值，返回一个新的列表，其中包含原列表中所有大于阈值的数字的平方。\n",
+                        "\n",
+                        "要求使用列表推导式来实现这个功能，而不是传统的for循环。\n",
+                        "\n",
+                        "## 示例\n",
+                        "\n",
+                        "**示例 1:**\n",
+                        "```python\n",
+                        "输入: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], threshold = 5\n",
+                        "输出: [36, 49, 64, 81, 100]\n",
+                        "解释: 大于5的数字是6,7,8,9,10，它们的平方分别是36,49,64,81,100\n",
+                        "```\n",
+                        "\n",
+                        "**示例 2:**\n",
+                        "```python\n",
+                        "输入: numbers = [-3, -1, 0, 2, 5, 8], threshold = 0\n",
+                        "输出: [4, 25, 64]\n",
+                        "解释: 大于0的数字是2,5,8，它们的平方分别是4,25,64\n",
+                        "```\n",
+                        "\n",
+                        "**示例 3:**\n",
+                        "```python\n",
+                        "输入: numbers = [1, 3, 5], threshold = 10\n",
+                        "输出: []\n",
+                        "解释: 没有数字大于10，所以返回空列表\n",
+                        "```\n",
+                        "\n",
+                        "## 约束条件\n",
+                        "- 输入列表可以包含正数、负数和零\n",
+                        "- 阈值可以是任意整数（正数、负数或零）\n",
+                        "- 必须使用列表推导式实现\n",
+                        "- 不允许使用传统的for循环或while循环\n",
+                        "- 函数应该能够处理空列表的情况\n",
+                        "\n",
+                        "## 函数签名\n",
+                        "```python\n",
+                        "def filter_and_square_numbers(numbers: list, threshold: int) -> list:\n",
+                        "    pass\n",
+                        "```\n",
+                        "\n",
+                        "---\n",
+                        "\n",
+                        "💡 **提示**: 列表推导式的基本语法是 `[expression for item in iterable if condition]`\n",
+                        "\n",
+                        "试着完成这个练习，如果您需要任何帮助或者想要我评审您的代码，请随时告诉我！\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# Tutor 会调用 call_exercise 工具\n",
+                "response = tutor.run(\"请给我出一道关于列表推导式的练习题。\")\n",
+                "\n",
+                "print(\"=== Tutor 回应 ===\")\n",
+                "print(response)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "test3_desc",
+            "metadata": {},
+            "source": [
+                "---\n",
+                "\n",
+                "## 测试 3：提交代码评审\n",
+                "\n",
+                "演示 **Tutor → Reviewer → CodeRunner** 的多层协作流程。\n",
+                "\n",
+                "**执行流程**：\n",
+                "1. 用户提交代码给 Tutor 评审\n",
+                "2. Tutor 调用 `call_reviewer` 工具\n",
+                "3. Reviewer 使用 `code_runner` 工具执行代码验证\n",
+                "4. Reviewer 分析代码逻辑、风格和性能\n",
+                "5. Tutor 返回详细的评审报告\n",
+                "\n",
+                "**技术亮点**：\n",
+                "- Reviewer 能够实际运行代码获取输出\n",
+                "- 提供结构化的评审反馈（优点、问题、改进建议）\n",
+                "- 支持代码片段和函数定义两种形式\n",
+                "\n",
+                "**测试代码说明**：\n",
+                "用户尝试解答测试 2 中的练习题（筛选正偶数并求平方），Reviewer 会验证代码的正确性。"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "f9019406",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "=== 用户代码 ===\n",
+                        "\n",
+                        "def filter_and_square_numbers(numbers):\n",
+                        "    return [n * n for n in numbers if n > 0 and n % 2 == 0]\n",
+                        "\n",
+                        "# 测试\n",
+                        "test_list = [1, 2, 3, 4, 5, 6, -2, -4, 0]\n",
+                        "result = filter_and_square_numbers(test_list)\n",
+                        "print(result)\n",
+                        "\n",
+                        "\n",
+                        "=== Tutor 回应 ===\n",
+                        "# 代码评审\n",
+                        "\n",
+                        "## 总体评价\n",
+                        "您的代码基本实现了筛选正偶数并求平方的功能，但存在一些与题目要求不符的地方。让我详细分析一下：\n",
+                        "\n",
+                        "## 发现的问题\n",
+                        "\n",
+                        "1. **函数签名不完整**: \n",
+                        "   - 题目要求函数接受两个参数(`numbers`和`threshold`)，但您的实现只接受一个参数\n",
+                        "   - 缺少阈值参数，无法满足题目的完整需求\n",
+                        "\n",
+                        "2. **逻辑不符合题目要求**:\n",
+                        "   - 题目示例显示应该筛选\"大于阈值\"的数字，但您的代码固定筛选\"大于0\"的数字\n",
+                        "   - 这使得函数不够通用，无法处理不同的阈值需求\n",
+                        "\n",
+                        "3. **硬编码条件**:\n",
+                        "   - 使用了固定的条件`n > 0`而不是基于传入的阈值参数\n",
+                        "\n",
+                        "## 改进建议\n",
+                        "\n",
+                        "```python\n",
+                        "def filter_and_square_numbers(numbers, threshold):\n",
+                        "    # 应该筛选大于threshold的数字，并返回它们的平方\n",
+                        "    return [n * n for n in numbers if n > threshold]\n",
+                        "\n",
+                        "# 或者如果确实只需要正偶数：\n",
+                        "def filter_positive_even_squares(numbers, threshold):\n",
+                        "    return [n * n for n in numbers if n > threshold and n > 0 and n % 2 == 0]\n",
+                        "```\n",
+                        "\n",
+                        "## 测试结果分析\n",
+                        "\n",
+                        "对于您的测试用例`[1, 2, 3, 4, 5, 6, -2, -4, 0]`：\n",
+                        "- 输出`[4, 16, 36]`是正确的(对应数字2, 4, 6)\n",
+                        "- 但如果threshold设置为3，则应返回`[16, 36]`(对应数字4, 6)\n",
+                        "\n",
+                        "## 评分\n",
+                        "- 功能正确性: ⭐⭐⭐☆☆ (部分正确)\n",
+                        "- 代码质量: ⭐⭐⭐⭐☆ (列表推导式使用恰当)\n",
+                        "- 符合要求: ⭐⭐☆☆☆ (未满足完整的题目要求)\n",
+                        "\n",
+                        "请根据上述建议修改代码以完全符合题目要求！\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# 用户尝试解答上面的练习题\n",
+                "user_code = \"\"\"\n",
+                "def filter_and_square_numbers(numbers):\n",
+                "    return [n * n for n in numbers if n > 0 and n % 2 == 0]\n",
+                "\n",
+                "# 测试\n",
+                "test_list = [1, 2, 3, 4, 5, 6, -2, -4, 0]\n",
+                "result = filter_and_square_numbers(test_list)\n",
+                "print(result)\n",
+                "\"\"\"\n",
+                "\n",
+                "print(f\"=== 用户代码 ===\\n{user_code}\\n\")\n",
+                "\n",
+                "# Tutor 会调用 call_reviewer 工具\n",
+                "response = tutor.run(f\"\"\"用户尝试解答前面的列表推导式练习题，请评审以下代码：\n",
+                "\n",
+                "{user_code}\n",
+                "\n",
+                "题目要求：筛选出正偶数并返回它们的平方。\"\"\")\n",
+                "\n",
+                "print(\"=== Tutor 回应 ===\")\n",
+                "print(response)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "conclusion",
+            "metadata": {},
+            "source": [
+                "---\n",
+                "\n",
+                "## 总结\n",
+                "\n",
+                "本演示展示了如何使用 `hello-agents` 框架构建多智能体协作系统。\n",
+                "\n",
+                "### 关键技术\n",
+                "\n",
+                "1. **AgentTool**：将智能体封装为工具，实现 A2A 调用\n",
+                "   ```python\n",
+                "   self.add_tool(AgentTool(\n",
+                "       self.planner,\n",
+                "       name=\"call_planner\",\n",
+                "       description=\"调用课程规划师\"\n",
+                "   ))\n",
+                "   ```\n",
+                "\n",
+                "2. **工具链**：Reviewer 使用 CodeRunner 执行代码\n",
+                "   ```python\n",
+                "   ReviewerAgent(llm, tools=[CodeRunner()])\n",
+                "   ```\n",
+                "\n",
+                "3. **System Prompt**：通过精心设计的提示词定义智能体行为\n",
+                "\n",
+                "### 扩展建议\n",
+                "\n",
+                "- 添加学习进度追踪功能\n",
+                "- 支持更多编程语言\n",
+                "- 集成代码风格检查工具（如 Pylint）\n",
+                "- 添加知识库检索增强（RAG）\n",
+                "\n",
+                "### 项目结构\n",
+                "\n",
+                "```\n",
+                "src/\n",
+                "├── agents/\n",
+                "│   ├── tutor.py      # 主协调智能体\n",
+                "│   ├── planner.py    # 学习计划制定\n",
+                "│   ├── exercise.py   # 练习题生成\n",
+                "│   └── reviewer.py   # 代码评审\n",
+                "└── tools/\n",
+                "    ├── agent_tool.py  # A2A 工具封装\n",
+                "    └── code_runner.py # 代码执行工具\n",
+                "```"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.12.12"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

Co-creation-projects/chen070808-ProgrammingTutor/requirements.txt

@@ -0,0 +1,3 @@
+hello-agents[all]>=0.2.7
+jupyterlab
+python-dotenv

Co-creation-projects/chen070808-ProgrammingTutor/src/agents/exercise.py

@@ -0,0 +1,32 @@
+from hello_agents import SimpleAgent, HelloAgentsLLM
+
+class ExerciseAgent(SimpleAgent):
+    """
+    负责生成编程练习的智能体。
+    """
+    
+    def __init__(self, llm: HelloAgentsLLM):
+        """
+        初始化 ExerciseAgent。
+        
+        Args:
+            llm: 用于生成练习的大语言模型实例。
+        """
+        system_prompt = """
+        你是一位富有创造力的编程练习生成器。
+        你的目标是创建测试特定概念的练习题。
+        
+        当生成练习时：
+        1. 你将获得一个主题（例如，"Python 列表"）和一个难度级别。
+        2. 创建题目描述。
+        3. 提供输入/输出示例。
+        4. 定义约束条件。
+        5. 最初不要向用户提供解决方案代码。
+        
+        清晰地格式化你的输出，以便展示给学生。
+        """
+        super().__init__(
+            name="Exercise",
+            llm=llm,
+            system_prompt=system_prompt
+        )

Co-creation-projects/chen070808-ProgrammingTutor/src/agents/planner.py

@@ -0,0 +1,33 @@
+from hello_agents import SimpleAgent, HelloAgentsLLM
+
+class PlannerAgent(SimpleAgent):
+    """
+    负责创建和更新学习路径的智能体。
+    """
+    
+    def __init__(self, llm: HelloAgentsLLM):
+        """
+        初始化 PlannerAgent。
+        
+        Args:
+            llm: 用于生成计划的大语言模型实例。
+        """
+        system_prompt = """
+        你是一位专业的计算机科学课程规划师。
+        你的工作是根据用户的目标和当前水平为他们创建个性化的学习路径。
+        
+        当被要求创建计划时：
+        1. 分析用户的目标（例如，"学习 Python 数据科学"）。
+        2. 将其分解为逻辑模块/里程碑。
+        3. 对于每个模块，列出要掌握的关键概念。
+        4. 以 Markdown 格式输出结构化的计划。
+        
+        当被要求更新计划时：
+        1. 回顾用户最近的表现。
+        2. 调整剩余模块的进度或深度。
+        """
+        super().__init__(
+            name="Planner",
+            llm=llm,
+            system_prompt=system_prompt
+        )

Co-creation-projects/chen070808-ProgrammingTutor/src/agents/reviewer.py

@@ -0,0 +1,54 @@
+from hello_agents import SimpleAgent, HelloAgentsLLM
+from hello_agents.tools import Tool
+from typing import List
+
+class ReviewerAgent(SimpleAgent):
+    """
+    负责评审代码的智能体。
+    它可以访问 CodeRunner 工具来执行代码。
+    """
+    
+    def __init__(self, llm: HelloAgentsLLM, tools: List[Tool] = None):
+        """
+        初始化 ReviewerAgent。
+        
+        Args:
+            llm: 用于评审代码的大语言模型实例。
+            tools: 智能体可用的工具列表（例如 CodeRunner）。
+        """
+        system_prompt = """
+        你是一位细致的编程代码评审员。
+        你的目标是分析用户代码的正确性、风格和效率。
+        
+        你配备了一个 'code_runner' 工具，可以用来执行 Python 代码。
+        
+        **重要：代码形式识别**
+        - 代码片段（Code Snippet）：可以直接运行的简短代码，如变量赋值、简单计算等
+        - 函数定义（Function）：以 def 开头，包含函数体的完整代码
+        - 不完整代码：缺少必要的语法元素（如未闭合的括号、缺少 return 等）
+        
+        **评审流程**：
+        1. **识别代码类型**：判断是代码片段还是函数定义
+        2. **运行代码**（推荐）：使用 'code_runner' 工具执行代码，验证是否能正常运行
+        3. **分析逻辑**：检查代码逻辑是否正确，是否达到预期目标
+        4. **检查风格**：评估代码风格（变量命名、PEP8规范）
+        5. **性能分析**：提出优化建议（时间/空间复杂度）
+        6. **建设性反馈**：指出优点和改进空间
+        
+        **评审原则**：
+        - ✅ 如果代码可以正常运行，不要说它"不完整"
+        - ✅ 针对实际代码逻辑进行评审，而不是臆测用户意图
+        - ✅ 区分"代码片段"和"需要函数封装"的建议
+        - ✅ 先肯定做得好的地方，再提出改进建议
+        
+        如果代码有错误，解释原因并提供修复提示，但不要直接给出完整的解决方案，除非用户多次尝试失败。
+        """
+        super().__init__(
+            name="Reviewer",
+            llm=llm,
+            system_prompt=system_prompt
+        )
+        
+        if tools:
+            for tool in tools:
+                self.add_tool(tool)

Co-creation-projects/chen070808-ProgrammingTutor/src/agents/tutor.py

@@ -0,0 +1,99 @@
+from hello_agents import SimpleAgent, HelloAgentsLLM
+from typing import Dict, Any
+
+class TutorAgent(SimpleAgent):
+    """
+    主要协调智能体，直接管理 Planner、Exercise 和 Reviewer 子智能体。
+    使用简单的直接调用模式，不依赖 A2A 协议。
+    """
+    
+    def __init__(self, llm: HelloAgentsLLM):
+        """
+        初始化 TutorAgent 和所有子智能体。
+        
+        Args:
+            llm: 用于所有 agents 的大语言模型实例。
+        """
+        # 导入放在这里避免循环导入
+        from agents.planner import PlannerAgent
+        from agents.exercise import ExerciseAgent
+        from agents.reviewer import ReviewerAgent
+        from tools.code_runner import CodeRunner
+        from tools.agent_tool import AgentTool
+        
+        # 创建子智能体实例
+        self.planner = PlannerAgent(llm)
+        self.exercise = ExerciseAgent(llm)
+        self.reviewer = ReviewerAgent(llm, tools=[CodeRunner()])
+        
+        # 定义系统提示词
+        system_prompt = """
+        你是一位智能编程导师 (Tutor)。你负责协调个性化的学习体验。
+        
+        你拥有以下专业助手（工具）：
+        - call_planner: 课程规划师，制定个性化学习计划
+        - call_exercise: 出题人，生成编程练习题
+        - call_reviewer: 评审员，评审代码并提供反馈
+        
+        **关键：你必须使用工具，不能自己完成这些任务！**
+        
+        工具调用格式（严格遵守此格式）：
+        [TOOL_CALL:工具名称:参数]
+        
+        具体示例：
+        
+        示例1 - 学习计划：
+        用户："我想学习Python中的列表推导式"
+        你的回答：[TOOL_CALL:call_planner:query=请为学习Python列表推导式制定学习计划]
+        
+        示例2 - 练习题：
+        用户："请给我出一道关于列表推导式的练习题"
+        你的回答：[TOOL_CALL:call_exercise:query=请出一道关于列表推导式的练习题]
+        
+        示例3 - 代码评审（最重要！）：
+        用户："请评审以下代码: numbers = [1, 2, 3]"
+        你的回答：[TOOL_CALL:call_reviewer:query=请评审以下代码: numbers = [1, 2, 3]]
+        
+        工作流程（必须严格遵守）：
+        1. 当用户表达学习目标时 → 立即调用 call_planner
+        2. 当用户请求练习时 → 立即调用 call_exercise  
+        3. 当用户提交代码或请求评审时 → 立即调用 call_reviewer
+        
+        **绝对禁止的行为**：
+        - ❌ 不要自己制定学习计划
+        - ❌ 不要自己出练习题
+        - ❌ 不要自己评审代码（即使代码很简单）
+        - ❌ 不要说"工具调用失败"然后自己完成任务
+        
+        正确的行为：
+        - ✅ 识别用户意图
+        - ✅ 立即生成工具调用（格式：[TOOL_CALL:工具名:query=...]）
+        - ✅ 等待工具返回结果
+        - ✅ 将结果友好地呈现给用户
+        """
+        
+        # 初始化父类
+        super().__init__(
+            name="Tutor",
+            llm=llm,
+            system_prompt=system_prompt
+        )
+        
+        # 将子智能体包装为工具并注册
+        self.add_tool(AgentTool(
+            self.planner,
+            name="call_planner",
+            description="调用课程规划师，为用户制定个性化的学习计划"
+        ))
+        
+        self.add_tool(AgentTool(
+            self.exercise,
+            name="call_exercise",
+            description="调用出题人，根据学习内容生成编程练习题"
+        ))
+        
+        self.add_tool(AgentTool(
+            self.reviewer,
+            name="call_reviewer",
+            description="调用评审员，对用户提交的代码进行评审和反馈"
+        ))

Co-creation-projects/chen070808-ProgrammingTutor/src/tools/agent_tool.py

@@ -0,0 +1,54 @@
+"""
+AgentTool: 将 SimpleAgent 包装为 Tool，实现直接调用
+这是比 A2A 协议更简单的多智能体模式
+"""
+from hello_agents import SimpleAgent
+from hello_agents.tools import Tool
+from typing import Dict, Any
+
+class AgentTool(Tool):
+    """将一个 SimpleAgent 包装为可被其他 Agent 调用的工具"""
+    
+    def __init__(self, agent: SimpleAgent, name: str, description: str):
+        """
+        Args:
+            agent: 要包装的 SimpleAgent 实例
+            name: 工具名称
+            description: 工具描述
+        """
+        self.agent = agent
+        self._name = name
+        self._description = description
+    
+    @property
+    def name(self) -> str:
+        return self._name
+    
+    @property
+    def description(self) -> str:
+        return self._description
+    
+    def get_parameters(self) -> list:
+        """定义工具参数"""
+        from hello_agents.tools.base import ToolParameter
+        return [
+            ToolParameter(
+                name="query",
+                type="string",
+                description="发送给智能体的查询或指令",
+                required=True
+            )
+        ]
+    
+    def run(self, parameters: Dict[str, Any]) -> str:
+        """执行工具 - 直接调用被包装的 agent"""
+        query = parameters.get('query', '')
+        
+        if not query:
+            return "错误：需要提供 query 参数"
+        
+        try:
+            # 直接调用 agent 的 run 方法
+            return self.agent.run(query)
+        except Exception as e:
+            return f"调用 {self.name} 时出错: {str(e)}"

Co-creation-projects/chen070808-ProgrammingTutor/src/tools/code_runner.py

@@ -0,0 +1,68 @@
+
+import io
+import contextlib
+from hello_agents.tools import Tool
+from typing import Dict, Any
+
+class CodeRunner(Tool):
+    """
+    安全执行 Python 代码并返回输出的工具。
+    警告：此工具使用 exec()，在生产环境中不安全。
+    对于真实产品，请使用 Docker 等沙箱环境。
+    """
+    
+    def __init__(self):
+        super().__init__(
+            name="code_runner",
+            description="执行 Python 代码并返回标准输出/错误。输入应为包含 'code' 键的字典。"
+        )
+
+    def get_parameters(self) -> Dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "code": {
+                    "type": "string",
+                    "description": "要执行的 Python 代码片段"
+                }
+            },
+            "required": ["code"]
+        }
+
+    def run(self, parameters: Dict[str, Any]) -> str:
+        code = parameters.get("code", "")
+        if not code:
+            return "错误：未提供代码。"
+
+        # 捕获标准输出和标准错误
+        stdout_capture = io.StringIO()
+        stderr_capture = io.StringIO()
+
+        try:
+            with contextlib.redirect_stdout(stdout_capture), contextlib.redirect_stderr(stderr_capture):
+                # 创建受限的全局作用域
+                safe_globals = {
+                    "__builtins__": __builtins__,
+                    "print": print,
+                    "range": range,
+                    "len": len,
+                    # 根据需要添加更多安全的内置函数
+                }
+                exec(code, safe_globals)
+            
+            output = stdout_capture.getvalue()
+            errors = stderr_capture.getvalue()
+            
+            result = ""
+            if output:
+                result += f"输出:\n{output}\n"
+            if errors:
+                result += f"错误:\n{errors}\n"
+            
+            if not result:
+                result = "代码执行成功，无输出。"
+                
+            return result
+
+        except Exception as e:
+            return f"运行时错误: {str(e)}"