从Prompt到Agent：教育错题分析系统的流程编排设计实践

从Prompt到Agent：教育错题分析系统的流程编排设计实践

作者 ：南汁bbj
标签 ：大模型应用 | 智能体设计 | 教育AI | 流程编排 | Prompt Engineering
阅读时长：约15分钟

---

一、引言：当教育遇上大模型，我们到底在解决什么问题？

去年夏天，我接到了一个让人头疼的需求：为某K12在线教育平台设计一套"AI错题分析系统"。产品经理的原话是："学生拍了错题照片，AI要能像真正的老师一样，不仅告诉他对错，还要指出错因、关联知识点、推荐同类题，最好能生成个性化学习报告。"

听起来很美好，但落地时我遇到了三个核心痛点：

1. Prompt失控：早期的单轮Prompt方案，面对复杂的数学证明题，模型要么"hallucination（幻觉）"乱给解题步骤，要么把"计算错误"和"概念混淆"混为一谈；
2. 流程僵化：用传统的if-else规则引擎编排，每新增一种题型就要写一堆分支逻辑，维护成本爆炸；
3. 上下文断裂：多轮对话中，学生追问"为什么这里要加辅助线"时，模型经常"失忆"，忘记前面分析的是哪道题。

这些问题本质上不是模型不够"聪明"，而是系统架构没有从"Prompt工程"进化到"Agent工程"。

本文将分享我们如何从一个简单的Prompt调用，逐步演进为一套基于多Agent协作 + 流程编排的教育错题分析系统，并给出可直接落地的代码实践。

---

二、从Prompt到Agent：架构演进的三阶段

2.1 阶段一：单Prompt时代（Demo级）

最早期的方案简单粗暴------把所有逻辑塞进一个System Prompt：

SYSTEM_PROMPT = """
你是一位资深数学教师，擅长错题分析。
请按以下步骤分析学生上传的错题：
1. 识别题目类型（代数/几何/概率...）
2. 判断错误类型（概念错误/计算错误/审题错误...）
3. 给出详细解析
4. 推荐3道同类练习题
5. 生成学习建议

学生错题：{question}
学生答案：{student_answer}
正确答案：{correct_answer}
"""

问题暴露：

• 上下文窗口爆炸：当学生连续上传5道题后，历史记录塞满Prompt，新题分析质量断崖式下降；
• 逻辑耦合："识别题型"和"推荐练习"两个子任务互相干扰，模型经常在推荐环节"放飞自我"，推荐超纲内容；
• 无法回滚：一旦某一步分析错误，整个输出都作废，没有局部重试机制。

2.2 阶段二：链式调用（Chain级）

受LangChain启发，我们将流程拆分为多个独立的LLM调用节点：

from typing import TypedDict, List

class ErrorAnalysisState(TypedDict):
    question: str
    student_answer: str
    question_type: str      # 节点1输出
    error_type: str         # 节点2输出
    analysis: str           # 节点3输出
    recommendations: List[str]  # 节点4输出

def classify_question(state: ErrorAnalysisState) -> ErrorAnalysisState:
    """节点1：题型分类"""
    prompt = f"请判断以下题目的类型：{state['question']}"
    state['question_type'] = llm_call(prompt)
    return state

def diagnose_error(state: ErrorAnalysisState) -> ErrorAnalysisState:
    """节点2：错因诊断"""
    prompt = f"题目类型：{state['question_type']}\n学生答案：{state['student_answer']}\n请诊断错因。"
    state['error_type'] = llm_call(prompt)
    return state

# ... 后续节点

改进点：

• 每个节点职责单一，Prompt更聚焦；
• 可以在节点间插入校验逻辑（如用规则引擎过滤非法的error_type）。

仍存在的问题：

• 流程仍是静态的：所有学生、所有错题都走同样的4个节点，无法根据错题难度动态调整；
• 没有记忆：节点之间只传递当前题的state，不知道这个学生上周就在"一元二次方程判别式"上栽过跟头；
• 缺乏反思：如果节点2诊断错了，节点3会基于错误的诊断继续分析，一错到底。

2.3 阶段三：Agent编排（Production级）

最终，我们采用了多Agent协作 + 动态流程编排的架构，核心思想是：

不是让模型"一次性做对"，而是设计一个可观测、可干预、可回滚的"认知流水线"。

整体架构分为四层（参考Agentic Workflow最佳实践）：

层级	核心模式	解决什么问题
执行层	Tool Use / ReAct	当前这一步该做什么
规划层	Plan-and-Execute	整个任务怎么拆、怎么调
质量层	Reflection / Evaluator	当前结果是否足够好
组织层	Multi-Agent	谁来做、谁来审、谁来汇总

---

三、核心设计：教育错题分析的Agent编排方案

3.1 系统架构全景

我们的系统包含5个核心Agent，每个Agent是一个独立的"专家"：

+-------------------------------------------------------------+
|                      调度Agent (Orchestrator)                 |
|  职责：接收用户输入，制定全局分析计划，协调子Agent执行           |
+--------------+----------------------------------------------+
               |
    +----------+----------+----------+----------+
    v          v          v          v          v
+-------+ +-------+ +-------+ +-------+ +-------+
| 感知Agent| | 解析Agent| | 诊断Agent| | 辅导Agent| | 报告Agent|
|(OCR+   | |(题型+   | |(错因+   | |(讲解+   | |(学情+   |
| 结构化) | | 知识点) | | 归因)   | | 推荐)   | | 可视化) |
+-------+ +-------+ +-------+ +-------+ +-------+
               |
               v
        +-------------+
        |  记忆模块     |
        |(向量数据库+   |
        |  学生画像)    |
        +-------------+

3.2 各Agent详细设计

3.2.1 感知Agent（Perception Agent）

职责：处理多模态输入，将图片/手写体/语音转化为结构化数据。

class PerceptionAgent:
    """感知Agent：负责输入预处理和结构化"""

    def __init__(self):
        self.ocr_tool = MathOCR()  # 数学公式专用OCR
        self.speech_tool = WhisperSTT()

    async def process(self, input_data: dict) -> dict:
        """
        输入：{"image": "base64...", "audio": "base64...", "text": "..."}
        输出：结构化题目对象
        """
        result = {
            "raw_text": "",
            "formulas": [],  # LaTeX公式列表
            "question_type": None,
            "difficulty": None,
            "subject": None
        }

        # 多模态融合处理
        if input_data.get("image"):
            ocr_result = await self.ocr_tool.recognize(input_data["image"])
            result["raw_text"] = ocr_result.text
            result["formulas"] = ocr_result.formulas

        if input_data.get("audio"):
            result["raw_text"] += await self.speech_tool.transcribe(input_data["audio"])

        # 基础元数据提取（轻量级规则+小模型）
        result["subject"] = self._detect_subject(result["raw_text"])
        result["difficulty"] = self._estimate_difficulty(result["raw_text"])

        return result

关键设计：

• 感知层不做复杂推理，只做"信号转数字"，降低LLM调用成本；
• 数学公式用专用OCR（如Pix2Tex），避免通用OCR把积分符号识别成"f"的尴尬。

3.2.2 解析Agent（Parsing Agent）

职责：深度理解题目结构，提取知识点、解题路径、考察能力维度。

class ParsingAgent:
    """解析Agent：题目语义理解"""

    SYSTEM_PROMPT = """你是一位数学教研专家。请对题目进行结构化解析，输出JSON格式：
{
    "knowledge_points": ["知识点1", "知识点2"],  // 必须关联课程标准
    "cognitive_level": "记忆/理解/应用/分析/综合",  // 布鲁姆分类法
    "solution_path": ["步骤1", "步骤2"],  // 标准解题路径
    "common_pitfalls": ["常见陷阱1", "常见陷阱2"],
    "prerequisites": ["前置知识1"]  // 学习该题需要先掌握的内容
}
注意：知识点必须与最新课程标准（2022版义务教育数学课程标准）对齐。"""

    def parse(self, structured_input: dict, student_profile: dict) -> dict:
        prompt = f"""
        题目：{structured_input['raw_text']}
        学生年级：{student_profile['grade']}
        学生历史薄弱点：{student_profile['weak_points']}

        请进行结构化解析。
        """
        return llm_call(self.SYSTEM_PROMPT, prompt, response_format="json")

与简单Prompt的区别：

• 注入了学生画像 （student_profile），解析时会考虑该学生的认知水平；
• 强制JSON输出，后续节点可直接解析，无需模糊的文本匹配；
• 知识点与课程标准对齐，避免模型"自创"知识点名称。

3.2.3 诊断Agent（Diagnosis Agent）

职责：对比学生答案与标准答案，定位具体错因。

这是整个系统最核心的Agent，我们采用了**"模板库 + LLM推理"**的混合策略：

class DiagnosisAgent:
    """诊断Agent：错因定位"""

    # 基于教育心理学的错因模板库
    ERROR_TEMPLATES = {
        "conceptual": {  # 概念性错误
            "patterns": ["混淆定义", "定理条件遗漏", "概念外延不清"],
            "severity": "high",
            "remediation": "概念重构"
        },
        "procedural": {  # 程序性错误
            "patterns": ["步骤跳跃", "公式套用错误", "逻辑链断裂"],
            "severity": "medium", 
            "remediation": "程序性训练"
        },
        "computational": {  # 计算性错误
            "patterns": ["符号错误", "数值计算失误", "单位换算错误"],
            "severity": "low",
            "remediation": "计算强化"
        },
        "symbolic": {  # 符号表示错误
            "patterns": ["数学符号误用", "几何标注错误", "表达式不规范"],
            "severity": "medium",
            "remediation": "规范训练"
        }
    }

    def diagnose(self, question: dict, student_answer: str, 
                 correct_answer: str, parsing_result: dict) -> dict:

        # Step 1: 规则引擎快速匹配（低成本）
        rule_based_hint = self._rule_match(question, student_answer)

        # Step 2: LLM深度推理（高精度）
        prompt = f"""
        你是一位经验丰富的数学教师，擅长错因分析。

        【题目解析】
        知识点：{parsing_result['knowledge_points']}
        标准解题路径：{parsing_result['solution_path']}
        常见陷阱：{parsing_result['common_pitfalls']}

        【作答对比】
        标准答案：{correct_answer}
        学生答案：{student_answer}
        规则引擎初步判断：{rule_based_hint}

        【任务】
        1. 判断错误类型（conceptual/procedural/computational/symbolic）
        2. 定位具体错因（具体到某一步、某个知识点）
        3. 评估错误严重程度（1-10分）
        4. 判断是否为重复错误（参考学生历史错题）

        输出JSON格式。
        """

        diagnosis = llm_call(prompt, response_format="json")

        # Step 3: 与模板库对齐，确保输出规范
        diagnosis = self._align_with_template(diagnosis)

        return diagnosis

设计亮点：

• 分层诊断：规则引擎做"初筛"（毫秒级），LLM做"深度分析"（秒级），平衡成本与精度；
• 错因标准化：所有诊断结果必须映射到预定义的4大类错误模板，避免"模型自创错因"导致后续处理混乱；
• 历史关联：诊断时会查询该学生的历史错题向量库，判断是否为"老毛病复发"。

3.2.4 辅导Agent（Tutoring Agent）

职责：根据诊断结果，生成个性化讲解和练习推荐。

这里我们引入了苏格拉底式引导策略：

class TutoringAgent:
    """辅导Agent：个性化教学"""

    def __init__(self):
        self.strategy_router = TeachingStrategyRouter()
        self.question_bank = QuestionBank()  # 题库系统

    async def generate_guidance(self, diagnosis: dict, 
                               student_profile: dict) -> dict:

        # 根据学生状态选择教学策略
        strategy = self.strategy_router.select(
            confusion_level=student_profile.get("confusion_level", 5),
            error_severity=diagnosis["severity"],
            is_repeat_error=diagnosis["is_repeat"]
        )

        if strategy == "direct_explain":
            # 直接讲解模式（适合简单错误或低年级）
            explanation = await self._direct_explain(diagnosis)

        elif strategy == "socratic_guide":
            # 苏格拉底引导模式（适合概念性错误）
            explanation = await self._socratic_guide(diagnosis)

        elif strategy == "scaffolded_practice":
            # 脚手架练习模式（适合程序性错误）
            explanation = await self._scaffolded_practice(diagnosis)

        # 推荐同类题（基于知识点向量相似度）
        similar_questions = await self.question_bank.retrieve(
            knowledge_points=diagnosis["knowledge_points"],
            difficulty_delta=(-1, 1),  # 难度浮动±1
            exclude_history=True  # 排除已做过的题
        )

        return {
            "strategy": strategy,
            "explanation": explanation,
            "similar_questions": similar_questions[:3],
            "estimated_time": self._estimate_time(diagnosis)
        }

    async def _socratic_guide(self, diagnosis: dict) -> str:
        """苏格拉底式引导：不直接给答案，通过提问引导思考"""
        prompt = f"""
        学生错因：{diagnosis['specific_cause']}
        相关知识点：{diagnosis['knowledge_points']}

        请设计3个引导性问题，帮助学生自己发现错误。
        要求：
        1. 问题由浅入深，每个问题建立在前一个问题的基础上
        2. 不能直接揭示答案，要让学生通过推理得出
        3. 如果学生回答错误，要有追问策略
        4. 语言风格适合{student_profile['grade']}年级学生
        """
        return llm_call(prompt)

策略路由逻辑：

学生状态	错误严重程度	推荐策略	说明
困惑度高 + 重复错误	>=7	scaffolded_practice	降低难度，从基础练起
困惑度低 + 新概念错误	>=5	socratic_guide	引导自主发现
困惑度低 + 计算错误	<=4	direct_explain	直接指出，强化检查习惯

3.2.5 报告Agent（Reporting Agent）

职责：整合单次分析结果，更新长期学情档案，生成可视化报告。

class ReportingAgent:
    """报告Agent：学情追踪与可视化"""

    def update_student_profile(self, student_id: str, 
                              analysis_result: dict) -> dict:
        """更新学生画像"""

        # 从向量数据库读取历史画像
        profile = vector_db.get(f"student:{student_id}")

        # 更新知识点掌握度（艾宾浩斯遗忘曲线加权）
        for kp in analysis_result["knowledge_points"]:
            profile["mastery"][kp] = self._update_mastery(
                old_score=profile["mastery"].get(kp, 0),
                is_correct=analysis_result["is_correct"],
                timestamp=datetime.now()
            )

        # 更新错误模式图谱
        profile["error_patterns"][analysis_result["error_type"]] += 1

        # 检测"危险知识点"（连续3次错误）
        danger_kps = [kp for kp, score in profile["mastery"].items() 
                     if score < 0.3 and self._recent_errors(student_id, kp) >= 3]

        # 写回向量数据库
        vector_db.update(f"student:{student_id}", profile)

        return {
            "updated_profile": profile,
            "danger_knowledge_points": danger_kps,
            "weekly_report": self._generate_weekly_report(profile),
            "trend_chart": self._generate_trend_chart(profile)
        }

3.3 调度Agent：流程编排的核心

调度Agent是整个系统的"大脑"，负责动态编排分析流程。我们使用LangGraph实现状态机编排：

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AnalysisState(TypedDict):
    """全局状态对象，在各Agent间传递"""
    raw_input: dict              # 原始输入
    perception_result: dict      # 感知结果
    parsing_result: dict         # 解析结果
    diagnosis_result: dict       # 诊断结果
    tutoring_result: dict        # 辅导结果
    report_result: dict          # 报告结果
    student_profile: dict        # 学生画像（从记忆模块读取）
    retry_count: int             # 重试计数
    is_valid: bool               # 质量校验结果

# 定义节点（即各Agent的调用入口）
def perception_node(state: AnalysisState):
    agent = PerceptionAgent()
    state["perception_result"] = agent.process(state["raw_input"])
    return state

def parsing_node(state: AnalysisState):
    agent = ParsingAgent()
    state["parsing_result"] = agent.parse(
        state["perception_result"], 
        state["student_profile"]
    )
    return state

def diagnosis_node(state: AnalysisState):
    agent = DiagnosisAgent()
    state["diagnosis_result"] = agent.diagnose(
        state["perception_result"],
        state["raw_input"]["student_answer"],
        state["raw_input"]["correct_answer"],
        state["parsing_result"]
    )
    return state

def quality_check_node(state: AnalysisState):
    """质量校验节点（Reflection层）"""
    evaluator = QualityEvaluator()
    state["is_valid"] = evaluator.check(state["diagnosis_result"])
    return state

def tutoring_node(state: AnalysisState):
    agent = TutoringAgent()
    state["tutoring_result"] = agent.generate_guidance(
        state["diagnosis_result"],
        state["student_profile"]
    )
    return state

def report_node(state: AnalysisState):
    agent = ReportingAgent()
    state["report_result"] = agent.update_student_profile(
        state["raw_input"]["student_id"],
        {
            **state["diagnosis_result"],
            **state["tutoring_result"]
        }
    )
    return state

# 构建状态图
workflow = StateGraph(AnalysisState)

# 添加节点
workflow.add_node("perception", perception_node)
workflow.add_node("parsing", parsing_node)
workflow.add_node("diagnosis", diagnosis_node)
workflow.add_node("quality_check", quality_check_node)
workflow.add_node("tutoring", tutoring_node)
workflow.add_node("reporting", report_node)

# 定义边（流程编排）
workflow.set_entry_point("perception")
workflow.add_edge("perception", "parsing")
workflow.add_edge("parsing", "diagnosis")
workflow.add_edge("diagnosis", "quality_check")

# 条件边：质量校验失败则重试，最多3次
def route_by_quality(state: AnalysisState):
    if state["is_valid"] or state["retry_count"] >= 3:
        return "tutoring"
    else:
        state["retry_count"] += 1
        return "diagnosis"  # 回退到诊断节点重试

workflow.add_conditional_edges(
    "quality_check",
    route_by_quality,
    {"tutoring": "tutoring", "diagnosis": "diagnosis"}
)

workflow.add_edge("tutoring", "reporting")
workflow.add_edge("reporting", END)

# 编译为可执行应用
app = workflow.compile()

# 运行
result = app.invoke({
    "raw_input": {
        "image": "base64...",
        "student_answer": "x=3",
        "correct_answer": "x=5",
        "student_id": "stu_12345"
    },
    "student_profile": load_profile("stu_12345"),
    "retry_count": 0,
    "is_valid": False
})

编排设计要点：

1. 显式状态管理 ：所有Agent共享一个AnalysisState，避免上下文丢失；
2. 条件分支：根据质量校验结果动态选择路径，实现"诊断-校验-重试"闭环；
3. 记忆注入 ：每个节点都可以读取student_profile，实现跨会话的个性化；
4. 可观测性：LangGraph自动记录每个节点的输入输出，便于调试和审计。

---

四、关键技术细节与踩坑记录

4.1 Prompt设计的"三层结构"

生产级Prompt不是"一段话"，而是分层架构：

class LayeredPrompt:
    """三层Prompt结构"""

    def __init__(self):
        # 第一层：角色与目标（最稳定，很少改动）
        self.role_layer = """你是一位{subject}教师，教龄20年...
工作方式：
- 优先使用苏格拉底式提问
- 禁止直接给出完整答案
- 语言风格适配{grade}年级学生
"""

        # 第二层：上下文与工具（每次调用动态注入）
        self.context_layer = """当前学生：{student_name}
历史薄弱点：{weak_points}
可用工具：{tools_description}
"""

        # 第三层：任务与格式（最灵活，根据具体任务调整）
        self.task_layer = """请完成以下任务：{task}
输出格式：{output_format}
约束条件：{constraints}
"""

    def build(self, **kwargs) -> str:
        return f"{self.role_layer}\n{self.context_layer}\n{self.task_layer}".format(**kwargs)

4.2 上下文窗口管理："惰性回收"策略

教育场景的多轮对话很容易撑爆上下文窗口。我们借鉴了Claude设计系统的snip机制：

class ContextManager:
    """上下文窗口管理器"""

    def __init__(self, max_tokens=8000):
        self.max_tokens = max_tokens
        self.snippets = []  # 可标记删除的片段

    def add(self, content: str, snippable: bool = False):
        """添加内容，标记是否可裁剪"""
        self.snippets.append({
            "content": content,
            "snippable": snippable,
            "timestamp": time.time()
        })
        self._compress_if_needed()

    def _compress_if_needed(self):
        """惰性回收：只在必要时才裁剪"""
        total = sum(len(s["content"]) for s in self.snippets)
        if total < self.max_tokens:
            return

        # 优先裁剪标记为snippable的旧片段
        for snippet in sorted(self.snippets, key=lambda x: x["timestamp"]):
            if snippet["snippable"]:
                snippet["content"] = self._summarize(snippet["content"])
                if sum(len(s["content"]) for s in self.snippets) < self.max_tokens:
                    break

    def _summarize(self, text: str) -> str:
        """用LLM压缩历史记录"""
        prompt = f"请用50字以内总结以下教学对话的核心信息：{text}"
        return llm_call(prompt)

4.3 安全与合规：教育AI的底线

教育AI必须考虑合规性，特别是面向未成年人的场景：

class SafetyGuard:
    """安全合规引擎"""

    FORBIDDEN_PATTERNS = [
        r".*(自杀|自残).*",  # 危险行为
        r".*(答案直接给你|抄我的).*",  # 学术不端诱导
        r".*(辱骂|歧视).*",  # 不当言论
    ]

    def check_input(self, text: str) -> tuple[bool, str]:
        """输入安检"""
        for pattern in self.FORBIDDEN_PATTERNS:
            if re.match(pattern, text):
                return False, "输入包含不当内容，已拦截"
        return True, ""

    def check_output(self, text: str, subject: str) -> tuple[bool, str]:
        """输出质检：确保知识点正确"""
        # 用规则引擎检查常见知识点错误
        if subject == "math":
            if "0不能做除数" in text and "除数可以为0" in text:
                return False, "知识点冲突：除数不能为0"

        # 用轻量级模型做语义安全检查
        safety_score = self.safety_model.predict(text)
        if safety_score < 0.8:
            return False, "输出安全置信度不足，已拦截"

        return True, ""

4.4 成本优化：动态模型路由

不是所有任务都需要GPT-4o。我们根据任务复杂度动态选择模型：

class ModelRouter:
    """动态模型路由"""

    MODEL_POOL = {
        "light": {"model": "qwen2.5-7b", "cost": 0.001, "max_tokens": 4096},
        "standard": {"model": "gpt-4o-mini", "cost": 0.01, "max_tokens": 8192},
        "heavy": {"model": "gpt-4o", "cost": 0.05, "max_tokens": 128000}
    }

    def route(self, task_type: str, complexity: int) -> str:
        """
        根据任务类型和复杂度选择模型
        complexity: 1-10
        """
        if task_type in ["ocr_postprocess", "rule_match"] or complexity <= 3:
            return self.MODEL_POOL["light"]
        elif task_type in ["parsing", "diagnosis"] and complexity <= 7:
            return self.MODEL_POOL["standard"]
        else:
            return self.MODEL_POOL["heavy"]

---

五、效果评估与迭代优化

5.1 评估指标体系

我们建立了三维评估体系：

维度	指标	说明
省时	分析耗时	从上传错题到输出报告的时间
	教师减负比	AI处理量 / 原教师处理量
高效	错因定位准确率	与教研专家标注的一致性
	知识点对齐率	输出知识点与课程标准的匹配度
	推荐题相关度	推荐题目与错因的关联度
针对性	个性化匹配度	推荐策略与学生画像的匹配度
	重复错误识别率	是否能识别学生的历史薄弱环节

5.2 实际运行数据

系统上线3个月后的核心指标：

• 错因定位准确率 ：从单Prompt方案的62% -> 89%（人工抽检500道题）
• 平均分析耗时 ：从15秒 -> 4.2秒（动态模型路由+缓存命中）
• 教师满意度：87%的教师认为"显著减轻了批改负担"
• 学生留存率 ：使用AI错题分析的学生，周留存率比对照组高23%

5.3 持续迭代机制

class FeedbackLoop:
    """反馈闭环：用数据驱动Prompt和策略迭代"""

    def collect_feedback(self, analysis_id: str, feedback: dict):
        """收集教师/学生反馈"""
        # 教师纠正的错因 -> 用于微调诊断Agent的Prompt
        if feedback.get("teacher_correction"):
            self.prompt_optimizer.add_negative_example(
                original=feedback["original_diagnosis"],
                corrected=feedback["teacher_correction"]
            )

        # 学生是否做对推荐题 -> 用于评估推荐质量
        if feedback.get("retry_result") is not None:
            self.recommendation_evaluator.update(
                question_id=feedback["recommended_question"],
                is_correct=feedback["retry_result"]
            )

    def weekly_optimize(self):
        """每周自动优化"""
        # 1. Prompt迭代：用Few-Shot学习更新示例
        new_examples = self.prompt_optimizer.generate_few_shot()
        update_prompt_template("diagnosis", new_examples)

        # 2. 策略调参：根据成功率调整教学策略阈值
        success_rates = self.recommendation_evaluator.get_success_rates()
        adjust_strategy_thresholds(success_rates)

        # 3. 知识库更新：将新错题纳入向量库
        new_questions = self.question_collector.get_weekly_new()
        vector_db.add_batch(new_questions)

---

六、总结与展望

6.1 核心经验

1. 从Prompt到Agent，本质是"控制复杂度的艺术"：单Prompt适合Demo，Chain适合原型，只有Agent编排才能应对生产环境的多样性；
2. 流程编排比模型选择更重要：一个好的状态机+普通模型，往往比糟糕的流程+顶级模型效果更好；
3. 教育AI的"温度"来自记忆：没有学生画像的AI是"复读机"，有记忆的AI才是"辅导老师"。

6.2 未来方向

• 多模态融合：接入手写笔迹分析、语音情感识别，实现"看笔迹知思路"；
• 群体智能：跨班级的错题聚类，帮助教师发现"全班共性盲区"；
• 端云协同：将简单的规则判断下沉到手机端侧，保护隐私的同时降低延迟。

---

讨论区：你在教育AI落地过程中遇到过哪些"Prompt失控"或"流程僵化"的问题？欢迎在评论区分享，我们一起探讨Agent编排的最佳实践。

---

本文首发于CSDN，转载请注明出处。