AI备课助手完整教程：从教案生成到智能课件制作全链路实战指南

摘要：本教程系统讲解AI备课助手全链路实战，覆盖教案生成、课件制作、出卷组卷、分层作业、学情分析五大场景，包含Prompt工程、RAG知识库、多智能体备课、完整代码示例与排错方案，帮助教师将备课时间从3小时压缩到30分钟。

核心检索词：AI备课助手、智能教案生成、AI课件制作、DeepSeek教育应用、RAG教学知识库、AI出卷组卷、AI分层作业、教师AI工具 

目录

• • 第一章 认识AI备课助手
• • 第二章 "四层智能备课引擎"架构模型
• • 第三章 "六阶落地路径"快速入门
• • 第四章 AI教案生成实战
• • 第五章 AI课件(PPT)智能制作实战
• • 第六章 RAG教学知识库搭建实战
• • 第七章 AI出卷组卷系统实战
• • 第八章 AI分层作业设计实战
• • 第九章 AI课堂活动与互动设计
• • 第十章 多智能体自动化备课
• • 第十一章 AI学情分析与教学决策
• • 第十二章 五大热门实操案例
• • 第十三章 竞品对比与选型决策树
• • 第十四章 常见问题排错手册
• • 第十五章 变现路径与未来展望
• • 参考来源

第一章 认识AI备课助手

1.1 从"编剧工作室"到"智能备课流水线"

传统备课像是一位老师独自经营一家"编剧工作室"——研读剧本（教材）、查阅背景资料、设计剧情节奏（教学流程）、准备道具布景（课件素材）、编排互动桥段（课堂活动）、撰写考核剧本（出卷改卷），每一道工序都得亲手打磨。一节课40分钟，背后往往是3个小时的备课时间。如果遇到公开课、评比课，备一堂课花一整天也不稀奇。

AI备课助手做的事情，本质上是给这个"编剧工作室"配置了一队"数字教研员"——有的负责查阅文献，有的负责起草教案，有的负责制作课件，有的负责出题组卷，有的负责设计互动。老师从"什么都自己干"的执行者，变成"指挥数字教研团队"的导演。

这不是要替代老师。恰恰相反，它把老师从重复性劳动中解放出来，让精力回归到真正需要人来做的事情上——理解学生、判断学情、调整教学策略、做有温度的教育。

1.2 四个核心价值

价值一：备课效率的量级跃升

传统备课链路中，查阅资料占30%时间、写教案占25%、做课件占25%、出题改卷占20%。AI能在这四个环节分别提供50%-80%的效率提升。综合来看，一节课的备课时间可以从3小时压缩到30-45分钟。这不是理论估算——2026年中研网的行业报告显示，使用AI备课系统的教师平均备课时间缩短40%，高频使用者缩短60%以上。

价值二：备课质量的标准化提升

年轻教师备课时最大的困惑是"不知道一节好课长什么样"。AI备课助手可以基于优秀教师的历史教案生成参考模板，让新教师的备课质量向经验丰富的骨干教师看齐。这不是让所有人都用同一套教案——而是提供一条"质量基准线"，老师在此基础上做个性化调整。

价值三：个性化教学的规模化实现

“因材施教"喊了两千年，但在40人一个班的现实下几乎不可能做到。AI备课助手可以基于学情数据，为同一个知识点生成基础版、提高版、拓展版三套教案和作业，让分层教学从"理想"变成"可操作的流程”。

价值四：教研协作的知识沉淀

一位老师退休，几十年的备课经验也随之带走。AI备课助手配合校本知识库，可以把优秀教案、教学反思、学生常见错题等隐性经验显性化、结构化，沉淀为学校的数字资产。新老师接手时，不是从零开始，而是站在前人的肩膀上。

1.3 AI备课助手的能力边界

坦率地说，AI备课助手不是万能的。以下场景它目前做得还不够好：

关键认知：AI备课助手更像是一台"CT扫描仪"——快速扫描定位教学要点和知识盲区，最终的诊断和教学处方仍然需要老师来把关。它是"分层协作工具"，不是"全能替代方案"：客观题批改、资料检索、格式排版等机械性工作交给AI；教学目标设计、学情判断、情感互动等创造性工作留给老师。

1.4 三大技术跃迁

理解AI备课助手的发展脉络，有助于你判断现在处于什么阶段、未来往哪里走。

跃迁一：从"关键词匹配"到"语义理解"（2018-2023）

2018年以前的"AI备课"主要靠关键词匹配——在题库中按标签检索相似题目，在资源库中按分类查找课件。这种方式效率有限，碰到"换一种问法"就失灵。2020年后，BERT等预训练模型让机器开始"读懂"题目语义，在教案检索场景中，语义匹配的召回率比关键词匹配提升约35%（基于教育题库实测数据），但生成能力仍然很弱，只能做检索和分类，无法"创造"新的教案内容。

跃迁二：从"检索增强"到"生成式备课"（2023-2025）

2023年ChatGPT的爆发改变了一切。大语言模型（LLM）不再只是"帮你找到已有内容"，而是能"从零生成"教案、课件提纲、教学活动设计。2024年国产大模型（文心一言、通义千问、Kimi）快速跟进，中文教育场景的可用性大幅提升。这一阶段的核心特征是"单点生成"——老师输入需求，AI输出一段文本。

跃迁三：从"单点生成"到"全流程Agent"（2025-2026）

2025年下半年开始，AI备课进入Agent时代。不再是"问一句答一句"的对话模式，而是多个AI智能体协作完成完整备课流程：需求解析Agent理解教学目标→知识检索Agent从课标和教材库中提取相关知识点→大纲生成Agent规划教学结构→并行页面生成Agent同时制作教案、课件、学案→交互组件注入Agent添加课堂活动→内容审查Agent检查准确性和课标对齐度→优化Agent打磨细节→归档Agent存入校本知识库。2026年4月教育部发布"人工智能+教育"行动计划后，这一方向加速发展。

第二章 "四层智能备课引擎"架构模型

说明："四层智能备课引擎"是本教程为帮助读者建立系统认知而归纳的架构模型，非行业标准术语。它以课程标准为输入、以课堂教学落地为输出，强调教学知识数据与AI生成能力的融合闭环。

2.1 架构全景图

┌─────────────────────────────────────────────────────────┐
│                   应用场景层                              │
│  教案生成 · 课件制作 · 出卷组卷 · 分层作业 · 学情分析     │
│  课堂活动设计 · 教研协作 · 校本资源沉淀                   │
├─────────────────────────────────────────────────────────┤
│                   智能生成层                              │
│  LLM教案引擎 · PPT生成引擎 · 题目生成引擎                 │
│  多智能体编排 · Prompt工程 · 多模态生成(文/图/音/视频)    │
├─────────────────────────────────────────────────────────┤
│                   知识数据层                              │
│  课标知识库 · 教材版本库 · 校本教案库 · 题库 · 学情数据库  │
│  RAG向量检索 · 知识图谱 · 错题归因库                     │
├─────────────────────────────────────────────────────────┤
│                   基础设施层                              │
│  大模型API(DeepSeek/通义/GPT) · 本地模型(Ollama)          │
│  向量数据库(FAISS/Milvus) · 文档处理引擎 · 导出格式转换    │
└─────────────────────────────────────────────────────────┘

2.2 各层职责详解

基础设施层——“发动机与底盘”

这一层提供算力和基础工具：

• • 大模型服务：DeepSeek-R1（深度推理、免费）、通义千问Qwen3（录音转写+会议纪要）、GPT-4o（多模态生成）、本地Ollama部署（隐私优先场景）
• • 向量数据库：FAISS（轻量级、适合单校部署）、Milvus（企业级、支持分布式）
• • 文档处理引擎：python-docx（Word生成）、python-pptx（PPT生成）、docxtemplater（模板填充）
• • 格式转换：Markdown→Word、Markdown→PPT、HTML离线打包

知识数据层——“燃料库”

AI生成的质量上限取决于"喂"给它什么数据。这一层是AI备课的"燃料库"：

• • 课标知识库：2022版义务教育课标、2017版高中课标的核心素养标准、学业质量水平描述
• • 教材版本库：人教版、北师大版、苏教版等各版本教材的章节结构和知识点体系
• • 校本教案库：学校积累的优质教案、教学反思、公开课实录
• • 题库：按知识点、难度、题型标注的结构化题库
• • 学情数据库：学生历次考试数据、错题记录、知识点掌握度

智能生成层——“加工车间”

这一层把基础设施层的算力和知识数据层的"燃料"转化为具体的教学产出：

• • LLM教案引擎：基于Prompt工程和RAG检索，生成结构化教案
• • PPT生成引擎：教案大纲→PPT页面规划→内容填充→模板套用→导出
• • 题目生成引擎：知识点+难度+题型→题目+答案+解析+变式
• • 多智能体编排：LangGraph驱动的8 Agent流水线，实现全流程自动化
• • 多模态生成：教学插图（通义万相/即梦）、教学微课视频（剪映AI）、语音朗读（TTS）

应用场景层——“交付窗口”

这一层是老师实际接触到的功能界面：

• • 教案生成与编辑
• • 课件制作与导出
• • 出卷组卷与打印
• • 分层作业设计与推送
• • 学情分析与教学建议
• • 课堂活动与互动设计
• • 教研协作与资源分享

2.3 数据流转闭环

四层之间不是单向调用，而是形成闭环：

1. 1. 老师在应用场景层发起备课需求（如"生成七年级数学《有理数加减法》教案"）
2. 2. 智能生成层接收需求，调用知识数据层检索相关课标和教材内容
3. 3. 基础设施层的大模型基于检索结果生成教案初稿
4. 4. 教师审核修改后，优质教案回流到知识数据层的校本教案库
5. 5. 学情数据层的考试数据反馈到智能生成层，指导下一次备课的难度和侧重调整

这个闭环意味着：用得越久，AI备课系统越"懂"你的教学风格和学生学情。

第三章 "六阶落地路径"快速入门

说明："六阶落地路径"是本教程归纳的落地步骤框架，强调"需求先行、数据为本、AI赋能"的实施顺序，非行业标准流程。

3.1 总览

需求诊断 → 工具选型 → 数据准备 → 系统搭建 → 测试上线 → 效果迭代
  ↓          ↓          ↓          ↓          ↓          ↓
 找痛点    选方案    喂数据    跑通流程   小范围试   持续优化

3.2 第一步：需求诊断

不要为了用AI而用AI。先问自己三个问题：

问题1：备课时最耗时间的是哪个环节？

• • 查资料（→选DeepSeek+秘塔AI搜索）
• • 写教案（→选LLM教案生成）
• • 做课件（→选Kimi PPT/Gamma/希沃AI）
• • 出题改卷（→选AI出卷+AI批改）
• • 设计活动（→选AI课堂活动生成器）

问题2：哪个学科、哪个学段？

• • K12语文/数学/英语：通用AI工具+课标知识库
• • 高校专业课：舟道超级教案或自建RAG
• • 职业教育实训：需要仿真组件支持
• • 跨学科STEAM：DeepSeek深度推理能力

问题3：你的技术能力在哪个层级？

• • 零基础教师：用现成SaaS产品（希沃AI/讯飞星火/舟道）
• • 有一定数字化能力：DeepSeek+Kimi+WPS AI组合
• • 有开发能力：自建LangChain+RAG+Ollama方案

3.3 第二步：工具选型

根据需求诊断结果，选择工具组合。以下是三套推荐方案：

方案A：零代码轻量方案（适合个人教师）

方案B：SaaS专业方案（适合学校/教研组）

方案C：自建技术方案（适合有开发能力的团队）

3.4 第三步：数据准备

AI生成的质量上限取决于你喂的数据质量。这一步是最容易被忽略、却最关键的环节。

必备数据清单：

1. 1. 课程标准文件：2022版义务教育课标（对应学科）、2017版高中课标（对应学科）。PDF格式即可，后续转为文本入库。
2. 2. 教材电子版：你使用的教材版本的电子版（PDF/图片），按章节切分。
3. 3. 历史优质教案：至少收集20-30份本校或外校的优质教案，作为AI学习的"范本"。
4. 4. 题库：按"知识点+难度+题型"三维度标注的题目集合，至少500题起步。
5. 5. 学情数据（可选但推荐）：最近2-3次考试的成绩分布、常见错题。

数据处理脚本示例：

import os
from pathlib import Path
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader

# 1. 加载课标PDF
defload_curriculum_standard(pdf_path):
"""加载课程标准PDF并切分"""
    loader = PyPDFLoader(pdf_path)
    pages = loader.load()

# 按递归字符切分，保持语义完整性
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=500,
        chunk_overlap=50,
        separators=["\n\n", "\n", "。", "；", " "]
    )
    chunks = splitter.split_documents(pages)
return chunks

# 2. 加载教材并按章节切分
defload_textbook_by_chapter(textbook_dir):
"""按章节加载教材"""
    chapters = []
for pdf_file insorted(Path(textbook_dir).glob("*.pdf")):
        chapter_name = pdf_file.stem  # 文件名即章节名
        loader = PyPDFLoader(str(pdf_file))
        pages = loader.load()
for page in pages:
            page.metadata["chapter"] = chapter_name
            page.metadata["source_type"] = "textbook"
        chapters.extend(pages)
return chapters

# 3. 加载历史教案
defload_teaching_plans(plan_dir):
"""加载历史优质教案"""
    plans = []
for doc_file in Path(plan_dir).glob("*.docx"):
# 使用python-docx读取
from docx import Document
        doc = Document(str(doc_file))
        content = "\n".join([p.text for p in doc.paragraphs if p.text.strip()])
        plans.append({
"content": content,
"metadata": {
"source": doc_file.name,
"source_type": "teaching_plan"
            }
        })
return plans

# 4. 构建向量索引
defbuild_vector_index(documents, index_path="./faiss_index"):
"""构建FAISS向量索引"""
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_community.vectorstores import FAISS

# 使用中文嵌入模型
    embeddings = HuggingFaceEmbeddings(
        model_name="BAAI/bge-small-zh-v1.5",
        model_kwargs={"device": "cpu"}
    )

    vectorstore = FAISS.from_documents(documents, embeddings)
    vectorstore.save_local(index_path)
print(f"向量索引构建完成，共{len(documents)}个文档块")
return vectorstore

# 主流程
if __name__ == "__main__":
    all_documents = []

# 加载各类数据
print("加载课程标准...")
    all_documents.extend(load_curriculum_standard("./data/课标/数学2022版.pdf"))

print("加载教材...")
    all_documents.extend(load_textbook_by_chapter("./data/教材/"))

print("加载历史教案...")
    plans = load_teaching_plans("./data/教案/")
# 将教案转为Document对象
from langchain.schema import Document
for plan in plans:
        all_documents.append(Document(page_content=plan["content"], metadata=plan["metadata"]))

print(f"总计加载{len(all_documents)}个文档块")

# 构建向量索引
    build_vector_index(all_documents)

3.5 第四步：系统搭建

以方案C（自建技术方案）为例，搭建核心服务：

# teaching_assistant.py — AI备课助手核心服务
from fastapi import FastAPI
from pydantic import BaseModel
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_openai import ChatOpenAI
from langchain.chains import RetrievalQA
from langchain.prompts import PromptTemplate
import json

app = FastAPI(title="AI备课助手API")

# 加载向量库
embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh-v1.5")
vectorstore = FAISS.load_local("./faiss_index", embeddings, allow_dangerous_deserialization=True)
retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

# 配置大模型（DeepSeek）
llm = ChatOpenAI(
    model="deepseek-chat",
    api_key="your-api-key",
    base_url="https://api.deepseek.com",
    temperature=0.7
)

classLessonPlanRequest(BaseModel):
    subject: str# 学科
    grade: str# 年级
    chapter: str# 章节
    duration: int = 40# 课时时长（分钟）
    teaching_style: str = "启发探究型"# 教学风格
    student_level: str = "中等"# 学生水平

@app.post("/generate_lesson_plan")
asyncdefgenerate_lesson_plan(req: LessonPlanRequest):
"""生成教案"""

# 第一步：检索相关课标和教材内容
    query = f"{req.grade}{req.subject}{req.chapter}教学目标 核心素养"
    relevant_docs = retriever.get_relevant_documents(query)
    context = "\n".join([doc.page_content for doc in relevant_docs])

# 第二步：构建Prompt
    prompt = PromptTemplate(
        input_variables=["subject", "grade", "chapter", "duration", "style", "level", "context"],
        template="""你是一位拥有20年教龄的资深{subject}教师，请根据以下信息生成一份完整的教案。

【教学信息】
- 学科：{subject}
- 年级：{grade}
- 章节：{chapter}
- 课时：{duration}分钟
- 教学风格：{style}
- 学生水平：{level}

【课标与教材参考】
{context}

【教案结构要求】
请严格按以下JSON格式输出：
{{
  "课题": "",
  "课型": "新授课/复习课/练习课",
  "教学目标": {{
    "知识与技能": "",
    "过程与方法": "",
    "情感态度与价值观": ""
  }},
  "教学重点": "",
  "教学难点": "",
  "教学准备": [],
  "教学过程": [
    {{
      "环节": "导入",
      "时长": "5分钟",
      "教师活动": "",
      "学生活动": "",
      "设计意图": ""
    }},
    {{
      "环节": "新知探究",
      "时长": "20分钟",
      "教师活动": "",
      "学生活动": "",
      "设计意图": ""
    }},
    {{
      "环节": "巩固练习",
      "时长": "10分钟",
      "教师活动": "",
      "学生活动": "",
      "设计意图": ""
    }},
    {{
      "环节": "课堂小结",
      "时长": "3分钟",
      "教师活动": "",
      "学生活动": "",
      "设计意图": ""
    }},
    {{
      "环节": "布置作业",
      "时长": "2分钟",
      "教师活动": "",
      "学生活动": "",
      "设计意图": ""
    }}
  ],
  "板书设计": "",
  "教学反思预留": "（课后填写）"
}}

注意：
1. 教学目标必须对齐2022版新课标核心素养
2. 教学过程必须体现{style}的教学风格
3. 每个环节的设计意图要具体，不能泛泛而谈
4. 作业设计要分层（基础/提高/拓展）
"""
    )

# 第三步：生成教案
    chain = prompt | llm
    result = chain.invoke({
"subject": req.subject,
"grade": req.grade,
"chapter": req.chapter,
"duration": req.duration,
"style": req.teaching_style,
"level": req.student_level,
"context": context
    })

# 第四步：解析JSON并返回
try:
        lesson_plan = json.loads(result.content)
return {"status": "success", "data": lesson_plan}
except json.JSONDecodeError:
return {"status": "success", "data": {"raw_content": result.content}}

@app.post("/generate_quiz")
asyncdefgenerate_quiz(req: dict):
"""生成练习题/试卷"""
# 详细实现见第七章
pass

@app.post("/generate_ppt_outline")
asyncdefgenerate_ppt_outline(req: dict):
"""生成PPT大纲"""
# 详细实现见第五章
pass

if __name__ == "__main__":
import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

3.6 第五步：测试上线

搭建完成后，不要直接全量使用。按以下步骤小范围测试：

1. 1. 单科试点：选一个学科、一个年级、一位愿意尝试的老师
2. 2. 对比测试：同一节课，用传统方式备一次、用AI备一次，对比质量和时间
3. 3. 课堂验证：用AI备课的教案实际上一堂课，观察学生反馈
4. 4. 收集问题：记录AI生成的不足之处（课标不对齐、难度不匹配、内容有误等）
5. 5. 迭代优化：根据问题调整Prompt、补充知识库数据

3.7 第六步：效果迭代

上线后持续优化的方向：

• • Prompt迭代：每用一次发现一个问题，就优化一次Prompt模板
• • 知识库扩充：每月新增10-20份优质教案入库
• • 学情反馈闭环：把考试数据反馈到备课系统，调整难度参数
• • 教研协作：多位老师共享Prompt模板和知识库，形成教研合力

第四章 AI教案生成实战

4.1 教案生成的核心挑战

教案生成是AI备课助手最核心的功能，也是最难做好的功能。核心挑战有三个：

挑战一：课标对齐

2022版新课标强调"核心素养"，但通用大模型的训练数据中课标内容有限。直接让AI"生成教案"，它可能写出一份结构完整但核心素养缺失的"老式教案"。

解决方案：RAG检索增强。先从课标知识库中检索该章节对应的核心素养要求，再把检索结果作为上下文喂给大模型。

挑战二：结构化输出

教案不是自由文本，而是有固定结构（教学目标/重点/难点/教学过程/板书设计等）。如果AI输出的是一大段文字，老师还得手动拆分整理，效率反而降低。

解决方案：用JSON格式约束输出。在Prompt中明确要求AI输出严格的JSON结构，方便后续解析和格式化。

挑战三：教学风格的个性化

不同老师有不同的教学风格——有的偏严谨学术，有的偏活泼互动，有的偏启发探究。如果AI生成的教案千篇一律，老师还得大量修改。

解决方案：在Prompt中设置"教学风格参数"，让AI按指定风格生成。

4.2 "框架-精细化"两步生成法

说明：分步生成教案的思路在教育AI领域已被广泛讨论。本教程采用的"框架-精细化"两步法在具体实现上做了三项差异化设计：①框架阶段强制绑定课标知识点ID；②精细化阶段按教学环节异步并行生成（而非顺序填充）；③两步之间加入教师确认环节，形成"人机协作闭环"。

一次性生成完整教案的效果往往不理想——AI容易在长文本生成中"跑偏"或遗漏关键要素。本教程采用"框架-精细化"两步生成法：

第一步：框架生成（Framework Generation）

先生成教案的结构骨架，包括：教学目标（三维，每条绑定课标知识点ID）、重点难点、教学环节划分（每环节时长和核心活动）、作业设计方向。框架阶段使用较高的temperature（0.8）激发创意多样性，允许快速生成多个候选框架供教师选择。

第二步：精细化写作（Detailed Writing）

教师确认框架后，系统按教学环节异步并行填充详细内容：教师活动、学生活动、设计意图、预设师生对话。精细化阶段使用较低的temperature（0.5）保证表述稳定。并行生成意味着5个教学环节同时处理，而非逐个串行，生成速度提升3-5倍。

三步之间的教师确认环节是区别于一般"两步生成"方案的关键——框架生成后暂停，等教师审核修改确认后，才进入精细化阶段。这避免了"框架跑偏→详情跟着跑偏"的连锁错误。

# dual_stage_lesson_plan.py — 双阶段教案生成
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
import json

classDualStageLessonPlanner:
def__init__(self, api_key, faiss_path="./faiss_index"):
self.llm = ChatOpenAI(
            model="deepseek-chat",
            api_key=api_key,
            base_url="https://api.deepseek.com",
            temperature=0.7
        )
# 大纲阶段用稍高temperature激发创意
self.llm_outline = ChatOpenAI(
            model="deepseek-chat",
            api_key=api_key,
            base_url="https://api.deepseek.com",
            temperature=0.8
        )
# 详情阶段用稍低temperature保证稳定性
self.llm_detail = ChatOpenAI(
            model="deepseek-chat",
            api_key=api_key,
            base_url="https://api.deepseek.com",
            temperature=0.5
        )

        embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-zh-v1.5")
self.vectorstore = FAISS.load_local(
            faiss_path, embeddings, allow_dangerous_deserialization=True
        )

def_retrieve_context(self, query, k=5):
"""检索课标和教材上下文"""
        docs = self.vectorstore.similarity_search(query, k=k)
        context = "\n\n---\n\n".join([
f"[来源: {d.metadata.get('source_type', '未知')}] {d.page_content}"
for d in docs
        ])
return context

defgenerate_outline(self, subject, grade, chapter, duration=40, style="启发探究型"):
"""第一阶段：生成教案大纲"""

        context = self._retrieve_context(f"{grade}{subject}{chapter} 核心素养 教学目标")

        outline_prompt = PromptTemplate(
            input_variables=["subject", "grade", "chapter", "duration", "style", "context"],
            template="""你是一位拥有20年教龄的资深{subject}教师。请生成以下课程的教案大纲。

【课程信息】
- 学科：{subject}
- 年级：{grade}
- 章节：{chapter}
- 课时：{duration}分钟
- 教学风格：{style}

【课标参考】
{context}

请输出JSON格式的大纲：
{{
  "课题": "",
  "课型": "",
  "教学目标": {{
    "知识与技能": "（1-2条具体目标）",
    "过程与方法": "（1-2条，体现{style}风格）",
    "情感态度与价值观": "（1条）"
  }},
  "教学重点": "（1句话概括）",
  "教学难点": "（1句话概括）",
  "教学环节": [
    {{"环节名": "", "时长": "", "核心活动": ""}}
  ],
  "作业设计方向": "基础/提高/拓展三层的方向"
}}
"""
        )

        chain = outline_prompt | self.llm_outline
        result = chain.invoke({
"subject": subject, "grade": grade, "chapter": chapter,
"duration": duration, "style": style, "context": context
        })

try:
return json.loads(result.content)
except json.JSONDecodeError:
return {"raw": result.content}

defgenerate_detail(self, outline, subject, grade, chapter, style="启发探究型"):
"""第二阶段：基于大纲填充详情"""

        detail_prompt = PromptTemplate(
            input_variables=["outline", "subject", "grade", "chapter", "style"],
            template="""你是一位拥有20年教龄的资深{subject}教师。请基于以下教案大纲，填充每个环节的详细内容。

【教案大纲】
{outline}

【学科】{subject}
【年级】{grade}
【章节】{chapter}
【教学风格】{style}

请为每个教学环节填充以下内容，输出JSON格式：
{{
  "教学过程": [
    {{
      "环节": "（来自大纲）",
      "时长": "（来自大纲）",
      "教师活动": "（详细的教师指令和引导语）",
      "学生活动": "（预期的学生反应和行为）",
      "设计意图": "（为什么这样设计，体现什么教学理念）",
      "预设对话": "（1-2轮典型师生对话示例）"
    }}
  ],
  "板书设计": "（文字描述板书布局）",
  "分层作业": {{
    "基础层": "（面向全体学生的必做题，2-3题）",
    "提高层": "（面向中等以上学生的选做题，1-2题）",
    "拓展层": "（面向学有余力学生的挑战题，1题）"
  }}
}}

要求：
1. 教师活动要具体可执行，不要写"引导学生思考"这种空话
2. 学生活动要符合{grade}学生的认知水平
3. 预设对话要真实自然
4. 设计意图要联系{style}教学风格
"""
        )

        chain = detail_prompt | self.llm_detail
        result = chain.invoke({
"outline": json.dumps(outline, ensure_ascii=False),
"subject": subject, "grade": grade, "chapter": chapter, "style": style
        })

try:
            detail = json.loads(result.content)
# 合并大纲和详情
            outline.update(detail)
return outline
except json.JSONDecodeError:
            outline["raw_detail"] = result.content
return outline

defgenerate(self, subject, grade, chapter, duration=40, style="启发探究型"):
"""完整双阶段生成"""
print(f"第一阶段：生成大纲...")
        outline = self.generate_outline(subject, grade, chapter, duration, style)
print(f"大纲生成完成：{outline.get('课题', '未知')}")

print(f"第二阶段：填充详情...")
        full_plan = self.generate_detail(outline, subject, grade, chapter, style)
print(f"教案生成完成")

return full_plan


# 使用示例
if __name__ == "__main__":
    planner = DualStageLessonPlanner(api_key="your-api-key")

    lesson_plan = planner.generate(
        subject="数学",
        grade="七年级",
        chapter="有理数的加减法",
        duration=40,
        style="启发探究型"
    )

print(json.dumps(lesson_plan, ensure_ascii=False, indent=2))

4.3 面向教案生成的Prompt五要素

说明：Prompt工程的通用原则已有广泛讨论。以下五要素是本教程针对"教案生成"这一特定场景提炼的专用框架，与通用Prompt指南在要素构成和适用场景上有实质差异。

经过大量实测验证，高质量的教案生成Prompt需要包含以下五个要素：

要素一：角色定义

你是一位拥有20年教龄的资深{学科}教师，擅长{教学风格}教学法，
对2022版新课标有深入理解。

角色定义不是装饰——它直接影响AI的"视角"和输出风格。没有角色定义时，AI倾向于生成百科式的知识罗列；有角色定义后，AI会从"教师视角"组织内容。

要素二：任务约束

请生成一份{时长}分钟的{课型}教案，包含以下结构：
教学目标（三维）→ 重点难点 → 教学过程（5环节）→ 板书设计 → 分层作业

明确任务结构，避免AI自由发挥。

要素三：上下文注入

【课标参考】
{RAG检索到的课标内容}

【教材参考】
{RAG检索到的教材内容}

【本校优质教案参考】
{RAG检索到的历史教案}

这是RAG的核心价值——让AI"看到"课标要求和优秀范本，而不是凭空生成。

要素四：输出格式约束

请严格按以下JSON格式输出：
{{
  "课题": "",
  "教学目标": {{...}},
  ...
}}

JSON格式约束确保输出可解析、可格式化、可导出。

要素五：质量要求

注意：
1. 教学目标必须对齐2022版新课标核心素养
2. 每个环节的设计意图要具体
3. 作业设计要分层
4. 教师活动要可执行，不要空话

质量要求是"防错指令"，告诉AI哪些是常见的低质量输出模式，提前规避。

4.4 教学风格参数化

不同学科、不同课型适合不同的教学风格。将教学风格参数化，可以让同一套系统服务不同老师的需求：

TEACHING_STYLES = {
"严谨学术型": {
"description": "注重知识体系的严密性和逻辑性，适合数学、物理等理科",
"prompt_hint": "强调概念精准、推导严谨、逻辑链条完整",
"student_activity": "独立思考、推理论证"
    },
"活泼互动型": {
"description": "注重课堂氛围和学生参与度，适合小学低年级、英语等",
"prompt_hint": "多用游戏、竞赛、角色扮演等互动形式",
"student_activity": "小组合作、游戏参与、表达展示"
    },
"启发探究型": {
"description": "注重引导学生自主发现和建构知识，适合科学、数学等",
"prompt_hint": "以问题链驱动，层层递进，让学生在探究中发现规律",
"student_activity": "观察假设、实验验证、归纳总结"
    },
"传统讲授型": {
"description": "注重知识传递的效率和系统性，适合复习课、概念引入",
"prompt_hint": "讲解清晰、板书规范、举例充分",
"student_activity": "听讲记录、跟练模仿"
    }
}

defget_style_prompt(style_name):
"""获取教学风格的Prompt片段"""
    style = TEACHING_STYLES.get(style_name, TEACHING_STYLES["启发探究型"])
returnf"""
教学风格：{style_name}
风格说明：{style['description']}
生成要求：{style['prompt_hint']}
学生活动倾向：{style['student_activity']}
"""

4.5 教案导出为Word文档

生成的JSON教案需要导出为老师熟悉的Word格式：

# export_to_docx.py — 教案导出为Word
from docx import Document
from docx.shared import Pt, Inches, RGBColor
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.enum.table import WD_TABLE_ALIGNMENT
import json

defexport_lesson_plan_to_docx(lesson_plan, output_path):
"""将JSON教案导出为Word文档"""

    doc = Document()

# 设置默认字体
    style = doc.styles['Normal']
    font = style.font
    font.name = '宋体'
    font.size = Pt(12)

# 标题
    title = doc.add_heading(f'{lesson_plan.get("课题", "教案")}', level=0)
    title.alignment = WD_ALIGN_PARAGRAPH.CENTER

# 基本信息
    info_table = doc.add_table(rows=3, cols=4)
    info_table.style = 'Table Grid'
    info_data = [
        ("学科", lesson_plan.get("subject", ""), "年级", lesson_plan.get("grade", "")),
        ("章节", lesson_plan.get("chapter", ""), "课时", f'{lesson_plan.get("duration", 40)}分钟'),
        ("课型", lesson_plan.get("课型", "新授课"), "教学风格", lesson_plan.get("style", "启发探究型"))
    ]
for i, row_data inenumerate(info_data):
for j, cell_text inenumerate(row_data):
            cell = info_table.rows[i].cells[j]
            cell.text = cell_text
if j % 2 == 0:
# 标签列加粗
for paragraph in cell.paragraphs:
for run in paragraph.runs:
                        run.bold = True

    doc.add_paragraph("")

# 教学目标
    doc.add_heading('一、教学目标', level=1)
    objectives = lesson_plan.get("教学目标", {})
for key, value in objectives.items():
        p = doc.add_paragraph()
        p.add_run(f'【{key}】').bold = True
        p.add_run(value)

# 重点难点
    doc.add_heading('二、教学重点与难点', level=1)
    doc.add_paragraph().add_run('重点：').bold = True
    doc.add_paragraph(lesson_plan.get("教学重点", ""))
    doc.add_paragraph().add_run('难点：').bold = True
    doc.add_paragraph(lesson_plan.get("教学难点", ""))

# 教学过程
    doc.add_heading('三、教学过程', level=1)

    process = lesson_plan.get("教学过程", [])
for i, step inenumerate(process, 1):
        doc.add_heading(f'环节{i}：{step.get("环节", "")}（{step.get("时长", "")}）', level=2)

# 用表格呈现教师活动和学生活动
        table = doc.add_table(rows=3, cols=2)
        table.style = 'Table Grid'

# 表头
        table.rows[0].cells[0].text = "教师活动"
        table.rows[0].cells[1].text = "学生活动"
for cell in table.rows[0].cells:
for paragraph in cell.paragraphs:
for run in paragraph.runs:
                    run.bold = True

        table.rows[1].cells[0].text = step.get("教师活动", "")
        table.rows[1].cells[1].text = step.get("学生活动", "")

# 设计意图
        table.rows[2].cells[0].text = "设计意图"
        table.rows[2].cells[1].text = step.get("设计意图", "")
        table.rows[2].cells[0].paragraphs[0].runs[0].bold = True

# 预设对话
if step.get("预设对话"):
            doc.add_paragraph().add_run('预设对话：').bold = True
            doc.add_paragraph(step["预设对话"])

        doc.add_paragraph("")

# 板书设计
    doc.add_heading('四、板书设计', level=1)
    doc.add_paragraph(lesson_plan.get("板书设计", ""))

# 分层作业
    doc.add_heading('五、分层作业', level=1)
    homework = lesson_plan.get("分层作业", {})
ifisinstance(homework, dict):
for level, content in homework.items():
            p = doc.add_paragraph()
            p.add_run(f'【{level}】').bold = True
            p.add_run(content)

# 教学反思
    doc.add_heading('六、教学反思（课后填写）', level=1)
    doc.add_paragraph("")
    doc.add_paragraph("")
    doc.add_paragraph("")

    doc.save(output_path)
print(f"教案已导出：{output_path}")


# 使用示例
if __name__ == "__main__":
# 假设lesson_plan是AI生成的JSON
    lesson_plan = {
"课题": "有理数的加减法",
"subject": "数学",
"grade": "七年级",
"chapter": "有理数的加减法",
"duration": 40,
"课型": "新授课",
"style": "启发探究型",
"教学目标": {
"知识与技能": "掌握有理数加法法则，能正确进行有理数加法运算",
"过程与方法": "通过数轴模型探究加法法则，经历从具体到抽象的归纳过程",
"情感态度与价值观": "体会数学与现实生活的联系，培养严谨的思维习惯"
        },
"教学重点": "有理数加法法则的理解和应用",
"教学难点": "异号两数相加的法则归纳",
"教学过程": [
            {
"环节": "情境导入",
"时长": "5分钟",
"教师活动": "出示足球比赛净胜球问题：上半场进2球，下半场失1球，净胜球是多少？",
"学生活动": "思考并尝试用正负数表示进球和失球",
"设计意图": "用生活情境引出有理数加法的必要性",
"预设对话": "师：净胜球怎么算？生：2-1=1。师：如果用正负数表示呢？"
            }
        ],
"板书设计": "有理数加法法则\n同号：...\n异号：...\n",
"分层作业": {
"基础层": "课本P20 练习1-3题",
"提高层": "课本P21 习题5-6题",
"拓展层": "探究：三个有理数相加，运算律是否成立？"
        }
    }

    export_lesson_plan_to_docx(lesson_plan, "./output/有理数加减法教案.docx")

第五章 AI课件(PPT)智能制作实战

5.1 AI制作PPT的三条路线

路线一：AI生成大纲 + 人工制作PPT

用DeepSeek/Kimi生成课件大纲（每页的标题和要点），再导入PowerPoint/WPS手动排版。适合对课件美观度要求高的场景。

路线二：AI生成大纲 + AI一键生成PPT

用DeepSeek生成大纲，再用Kimi/Gamma/WPS AI一键生成完整PPT。效率最高，但模板化痕迹较重，需要后期微调。

路线三：代码全流程自动生成

用python-pptx库，从教案JSON直接生成PPT文件。适合需要批量生成、定制化程度高的场景。

5.2 路线二：DeepSeek + Kimi 一键PPT

这是目前教师群体中最高效的组合：

# step1_generate_outline.py — 用DeepSeek生成PPT大纲
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
import json

defgenerate_ppt_outline(subject, grade, chapter, lesson_plan=None):
"""基于教案生成PPT大纲"""

    llm = ChatOpenAI(
        model="deepseek-chat",
        api_key="your-api-key",
        base_url="https://api.deepseek.com",
        temperature=0.7
    )

    prompt = PromptTemplate(
        input_variables=["subject", "grade", "chapter", "lesson_plan"],
        template="""你是一位擅长制作教学课件的教育专家。请为以下课程生成PPT大纲。

【课程信息】
- 学科：{subject}
- 年级：{grade}
- 章节：{chapter}

【教案参考】
{lesson_plan}

请生成8-12页的PPT大纲，每页包含标题和要点。输出JSON格式：
{{
  "ppt_title": "课件总标题",
  "slides": [
    {{
      "page": 1,
      "type": "封面",
      "title": "",
      "content": ["副标题"]
    }},
    {{
      "page": 2,
      "type": "学习目标",
      "title": "本节学习目标",
      "content": ["目标1", "目标2", "目标3"]
    }},
    {{
      "page": 3,
      "type": "情境导入",
      "title": "",
      "content": ["导入情境描述", "思考问题"]
    }},
    {{
      "page": 4,
      "type": "新知探究",
      "title": "",
      "content": ["核心知识点1", "图示/公式", "例题"]
    }},
    ...
    {{
      "page": "倒数第二页",
      "type": "课堂练习",
      "title": "随堂练习",
      "content": ["练习题1", "练习题2"]
    }},
    {{
      "page": "最后一页",
      "type": "总结作业",
      "title": "课堂小结与作业",
      "content": ["知识点总结", "分层作业"]
    }}
  ]
}}

要求：
1. 每页content不超过4个要点
2. 适合{grade}学生的认知水平
3. 新知探究部分占40%以上的页数
4. 每页注明type，方便后续选模板
"""
    )

    chain = prompt | llm
    result = chain.invoke({
"subject": subject, "grade": grade, "chapter": chapter,
"lesson_plan": json.dumps(lesson_plan, ensure_ascii=False) if lesson_plan else"无"
    })

try:
return json.loads(result.content)
except json.JSONDecodeError:
return {"raw": result.content}

# 生成后，将大纲文本复制到Kimi的PPT生成功能中
# Kimi会基于大纲自动生成完整PPT

5.3 路线三：python-pptx 全流程自动生成

对于需要完全控制PPT样式的场景，用python-pptx直接生成：

# auto_ppt_generator.py — 自动生成教学PPT
from pptx import Presentation
from pptx.util import Inches, Pt, Emu
from pptx.dml.color import RGBColor
from pptx.enum.text import PP_ALIGN, MSO_ANCHOR
import json

classTeachingPPTGenerator:
def__init__(self):
self.prs = Presentation()
self.prs.slide_width = Inches(13.333)  # 16:9
self.prs.slide_height = Inches(7.5)

# 配色方案（教育主题）
self.colors = {
"primary": RGBColor(0x2E, 0x86, 0xC1),    # 蓝色主色
"secondary": RGBColor(0x28, 0xB4, 0x63),   # 绿色辅助
"accent": RGBColor(0xF3, 0x9C, 0x12),      # 橙色强调
"bg_light": RGBColor(0xF8, 0xF9, 0xFA),    # 浅色背景
"text_dark": RGBColor(0x2C, 0x3E, 0x50),   # 深色文字
"text_light": RGBColor(0xFF, 0xFF, 0xFF),  # 浅色文字
        }

def_add_background(self, slide, color):
"""设置幻灯片背景色"""
        background = slide.background
        fill = background.fill
        fill.solid()
        fill.fore_color.rgb = color

def_add_text_box(self, slide, left, top, width, height, text, 
                      font_size=18, color=None, bold=False, alignment=PP_ALIGN.LEFT):
"""添加文本框"""
        txBox = slide.shapes.add_textbox(left, top, width, height)
        tf = txBox.text_frame
        tf.word_wrap = True
        p = tf.paragraphs[0]
        p.text = text
        p.font.size = Pt(font_size)
        p.font.bold = bold
        p.alignment = alignment
if color:
            p.font.color.rgb = color
return txBox

defadd_cover_slide(self, title, subtitle=""):
"""添加封面页"""
        slide_layout = self.prs.slide_layouts[6]  # 空白布局
        slide = self.prs.slides.add_slide(slide_layout)
self._add_background(slide, self.colors["primary"])

# 主标题
self._add_text_box(
            slide, Inches(1), Inches(2.5), Inches(11), Inches(2),
            title, font_size=44, color=self.colors["text_light"],
            bold=True, alignment=PP_ALIGN.CENTER
        )

# 副标题
if subtitle:
self._add_text_box(
                slide, Inches(1), Inches(4.5), Inches(11), Inches(1),
                subtitle, font_size=20, color=self.colors["text_light"],
                alignment=PP_ALIGN.CENTER
            )
return slide

defadd_objectives_slide(self, objectives):
"""添加学习目标页"""
        slide_layout = self.prs.slide_layouts[6]
        slide = self.prs.slides.add_slide(slide_layout)
self._add_background(slide, self.colors["bg_light"])

# 标题
self._add_text_box(
            slide, Inches(0.5), Inches(0.3), Inches(12), Inches(1),
"学习目标", font_size=36, color=self.colors["primary"],
            bold=True, alignment=PP_ALIGN.LEFT
        )

# 分割线
from pptx.shapes.connector import Connector
        connector = slide.shapes.add_connector(
1, Inches(0.5), Inches(1.3), Inches(12.5), Inches(1.3)
        )
        connector.line.color.rgb = self.colors["accent"]
        connector.line.width = Pt(3)

# 目标内容
        y = 1.6
for key, value in objectives.items():
self._add_text_box(
                slide, Inches(1), Inches(y), Inches(11), Inches(1),
f"▸ {key}：{value}",
                font_size=22, color=self.colors["text_dark"]
            )
            y += 1.2
return slide

defadd_content_slide(self, title, points, slide_type="新知探究"):
"""添加内容页"""
        slide_layout = self.prs.slide_layouts[6]
        slide = self.prs.slides.add_slide(slide_layout)
self._add_background(slide, self.colors["bg_light"])

# 标题栏
        title_bar = slide.shapes.add_textbox(
            Inches(0), Inches(0), Inches(13.333), Inches(1.2)
        )
        tf = title_bar.text_frame
        p = tf.paragraphs[0]
        p.text = title
        p.font.size = Pt(32)
        p.font.bold = True
        p.font.color.rgb = self.colors["text_light"]
        p.alignment = PP_ALIGN.LEFT

# 标题栏背景
from pptx.util import Cm
        shape = slide.shapes.add_shape(
1,  # 矩形
            Inches(0), Inches(0), Inches(13.333), Inches(1.2)
        )
        shape.fill.solid()
        shape.fill.fore_color.rgb = self.colors["primary"]
        shape.line.fill.background()
# 把标题放到最上层
        title_bar = slide.shapes.add_textbox(
            Inches(0.5), Inches(0.1), Inches(12), Inches(1)
        )
        tf = title_bar.text_frame
        p = tf.paragraphs[0]
        p.text = title
        p.font.size = Pt(32)
        p.font.bold = True
        p.font.color.rgb = self.colors["text_light"]

# 内容要点
        y = 1.6
for point in points:
self._add_text_box(
                slide, Inches(1), Inches(y), Inches(11), Inches(0.8),
f"● {point}",
                font_size=24, color=self.colors["text_dark"]
            )
            y += 1.0

return slide

defadd_summary_slide(self, summary_points, homework):
"""添加总结作业页"""
        slide_layout = self.prs.slide_layouts[6]
        slide = self.prs.slides.add_slide(slide_layout)
self._add_background(slide, self.colors["bg_light"])

# 左半部分：课堂小结
self._add_text_box(
            slide, Inches(0.5), Inches(0.3), Inches(6), Inches(0.8),
"课堂小结", font_size=32, color=self.colors["primary"], bold=True
        )

        y = 1.3
for point in summary_points:
self._add_text_box(
                slide, Inches(0.7), Inches(y), Inches(5.5), Inches(0.8),
f"✓ {point}",
                font_size=20, color=self.colors["text_dark"]
            )
            y += 0.9

# 右半部分：作业
self._add_text_box(
            slide, Inches(7), Inches(0.3), Inches(6), Inches(0.8),
"课后作业", font_size=32, color=self.colors["secondary"], bold=True
        )

        y = 1.3
for level, content in homework.items():
self._add_text_box(
                slide, Inches(7.2), Inches(y), Inches(5.5), Inches(0.8),
f"【{level}】{content}",
                font_size=18, color=self.colors["text_dark"]
            )
            y += 1.2

return slide

defgenerate_from_lesson_plan(self, lesson_plan):
"""从教案JSON生成完整PPT"""
# 封面
self.add_cover_slide(
            title=lesson_plan.get("课题", "教学课件"),
            subtitle=f'{lesson_plan.get("subject", "")} · {lesson_plan.get("grade", "")}'
        )

# 学习目标
        objectives = lesson_plan.get("教学目标", {})
if objectives:
self.add_objectives_slide(objectives)

# 教学过程各环节
        process = lesson_plan.get("教学过程", [])
for step in process:
            points = []
            teacher_activity = step.get("教师活动", "")
            student_activity = step.get("学生活动", "")
if teacher_activity:
                points.append(f"教师：{teacher_activity}")
if student_activity:
                points.append(f"学生：{student_activity}")
            intent = step.get("设计意图", "")
if intent:
                points.append(f"意图：{intent}")

self.add_content_slide(
                title=f'{step.get("环节", "")}（{step.get("时长", "")}）',
                points=points
            )

# 总结作业
        homework = lesson_plan.get("分层作业", {})
        summary_points = [
            lesson_plan.get("教学重点", ""),
            lesson_plan.get("教学难点", "")
        ]
self.add_summary_slide(summary_points, homework)

returnself.prs

defsave(self, filepath):
self.prs.save(filepath)
print(f"PPT已保存：{filepath}")


# 使用示例
if __name__ == "__main__":
    generator = TeachingPPTGenerator()

# 从教案生成PPT
    lesson_plan = {
"课题": "有理数的加减法",
"subject": "数学",
"grade": "七年级",
"教学目标": {
"知识与技能": "掌握有理数加法法则",
"过程与方法": "通过数轴模型探究法则",
"情感态度与价值观": "培养严谨思维"
        },
"教学重点": "有理数加法法则",
"教学难点": "异号相加法则",
"教学过程": [
            {
"环节": "情境导入",
"时长": "5分钟",
"教师活动": "出示足球净胜球问题",
"学生活动": "用正负数表示进球失球",
"设计意图": "生活情境引出加法需求"
            },
            {
"环节": "新知探究",
"时长": "20分钟",
"教师活动": "引导用数轴演示加法过程",
"学生活动": "分组探究不同情况",
"设计意图": "从具体到抽象归纳法则"
            }
        ],
"分层作业": {
"基础层": "课本P20 练习1-3",
"提高层": "课本P21 习题5-6",
"拓展层": "探究加法运算律"
        }
    }

    generator.generate_from_lesson_plan(lesson_plan)
    generator.save("./output/有理数加减法课件.pptx")

5.3 AI课件制作的常见问题与优化

问题1：AI生成的PPT图片与内容不匹配

这是教师反馈最高频的痛点。希沃AI备课试用实测发现"文字与图片内容完全不相关"。

解决方案：

• • 用通义万相/即梦AI按页面内容生成专属配图，而非使用通用图片库
• • 在Prompt中明确描述需要的图片内容
• • 图片生成后人工审核替换

# generate_teaching_image.py — 生成教学配图
from openai import OpenAI

defgenerate_teaching_image(description, save_path):
"""根据教学内容生成配图"""
    client = OpenAI(
        api_key="your-api-key",
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )

# 增强描述，确保适合教学场景
    enhanced_prompt = f"""
    教学插图：{description}
    风格：扁平化教育插画，色彩明亮，适合{save_path.split('/')[-1].split('_')[0]}学生
    要求：无文字标注，简洁清晰，适合投影展示
    """

    result = client.images.generate(
        model="wanx-v1",
        prompt=enhanced_prompt,
        n=1,
        size="1024*576"# 16:9比例，适合PPT
    )

# 下载图片
import requests
    image_url = result.data[0].url
    response = requests.get(image_url)
withopen(save_path, 'wb') as f:
        f.write(response.content)

print(f"教学配图已生成：{save_path}")
return save_path

问题2：PPT导出格式兼容性

不同学校使用的软件不同（PowerPoint/WPS/Keynote），导出格式需要兼容。建议统一导出为.pptx格式（兼容性最好），同时在系统内提供"导出为PDF"选项（保证排版不变形）。

问题3：PPT模板同质化

AI一键生成的PPT往往模板雷同。解决方案：

• • 准备5-10套不同风格的学校专属模板
• • 在python-pptx中实现模板随机选择
• • 允许教师上传自定义模板

第六章 RAG教学知识库搭建实战

6.1 为什么需要RAG

直接用大模型生成教案最大的问题是"幻觉"——AI可能编造不存在的知识点、引用错误的课标内容、生成超纲的教学设计。

RAG（Retrieval-Augmented Generation，检索增强生成）的核心思路是：先从你准备好的知识库中检索相关内容，再把检索结果作为上下文喂给大模型。这样AI的生成就有了"事实依据"，大幅降低幻觉风险。

对于教育场景，RAG的价值尤其突出：

• • 课标对齐：检索课标原文，确保教学目标不偏离
• • 教材准确：检索教材内容，确保知识点表述与教材一致
• • 风格统一：检索本校优质教案，让AI生成的教案风格与学校要求一致
• • 难度适配：检索学情数据，让AI按学生实际水平调整难度

6.2 教学知识库的分层架构

┌──────────────────────────────────────┐
│        检索增强层（RAG Engine）        │
│  查询改写 → 多路召回 → 重排序 → 注入   │
├──────────────────────────────────────┤
│        知识分层层                      │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐│
│  │课标知识库│ │教材知识库│ │教案知识库││
│  │(权威层) │ │(标准层) │ │(参考层) ││
│  └─────────┘ └─────────┘ └─────────┘│
│  ┌─────────┐ ┌─────────┐            │
│  │题目知识库│ │学情数据库│            │
│  │(练习层) │ │(反馈层) │            │
│  └─────────┘ └─────────┘            │
├──────────────────────────────────────┤
│        数据处理层                      │
│  PDF解析 → 文本切分 → 向量化 → 入库   │
└──────────────────────────────────────┘

分层设计的关键：不同层级的知识库有不同的权重和用途。课标知识库权重最高（权威依据），教案知识库权重较低（参考性质）。检索时优先返回高权重内容。

6.3 完整RAG系统实现

# teaching_rag.py — 教学知识库RAG系统
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import PyPDFLoader, Docx2txtLoader
from langchain.retrievers import MergerRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor
from langchain.retrievers import ContextualCompressionRetriever
from langchain_openai import ChatOpenAI
from pathlib import Path
import json

classTeachingKnowledgeBase:
"""教学知识库管理系统"""

def__init__(self, base_dir="./knowledge_base"):
self.base_dir = Path(base_dir)
self.base_dir.mkdir(parents=True, exist_ok=True)

# 嵌入模型
self.embeddings = HuggingFaceEmbeddings(
            model_name="BAAI/bge-small-zh-v1.5",
            model_kwargs={"device": "cpu"}
        )

# 文本切分器
self.splitter = RecursiveCharacterTextSplitter(
            chunk_size=500,
            chunk_overlap=50,
            separators=["\n\n", "\n", "。", "；", "，", " "]
        )

# 各类知识库的向量索引
self.indices = {}

# 知识库配置
self.kb_config = {
"curriculum_standard": {
"name": "课标知识库",
"dir": self.base_dir / "curriculum_standard",
"weight": 1.0,  # 最高权重
"description": "课程标准原文，教学设计的权威依据"
            },
"textbook": {
"name": "教材知识库",
"dir": self.base_dir / "textbook",
"weight": 0.9,
"description": "教材内容，知识点表述的标准来源"
            },
"teaching_plan": {
"name": "教案知识库",
"dir": self.base_dir / "teaching_plan",
"weight": 0.7,
"description": "历史优质教案，教学设计的参考范本"
            },
"question_bank": {
"name": "题目知识库",
"dir": self.base_dir / "question_bank",
"weight": 0.8,
"description": "结构化题库，出卷组卷的数据来源"
            },
"student_data": {
"name": "学情数据库",
"dir": self.base_dir / "student_data",
"weight": 0.6,
"description": "学生考试数据，难度适配的反馈来源"
            }
        }

defingest_documents(self, kb_type, file_path):
"""向指定知识库导入文档"""
if kb_type notinself.kb_config:
raise ValueError(f"未知知识库类型: {kb_type}")

        config = self.kb_config[kb_type]
        kb_dir = config["dir"]
        kb_dir.mkdir(parents=True, exist_ok=True)

# 根据文件类型选择加载器
        file_path = Path(file_path)
if file_path.suffix.lower() == ".pdf":
            loader = PyPDFLoader(str(file_path))
elif file_path.suffix.lower() in [".docx", ".doc"]:
            loader = Docx2txtLoader(str(file_path))
elif file_path.suffix.lower() == ".txt":
from langchain_community.document_loaders import TextLoader
            loader = TextLoader(str(file_path))
else:
raise ValueError(f"不支持的文件格式: {file_path.suffix}")

# 加载并切分
        documents = loader.load()
        chunks = self.splitter.split_documents(documents)

# 添加元数据
for chunk in chunks:
            chunk.metadata["kb_type"] = kb_type
            chunk.metadata["kb_name"] = config["name"]
            chunk.metadata["weight"] = config["weight"]
            chunk.metadata["source_file"] = file_path.name

# 构建或更新向量索引
        index_path = kb_dir / "faiss_index"
if index_path.exists():
# 增量更新
            existing_store = FAISS.load_local(
str(index_path), self.embeddings,
                allow_dangerous_deserialization=True
            )
            existing_store.add_documents(chunks)
            existing_store.save_local(str(index_path))
else:
# 新建索引
            vectorstore = FAISS.from_documents(chunks, self.embeddings)
            vectorstore.save_local(str(index_path))

print(f"已导入 {len(chunks)} 个文档块到 {config['name']}")
returnlen(chunks)

defget_retriever(self, kb_types=None, k=5):
"""获取检索器

        Args:
            kb_types: 指定检索的知识库列表，None表示检索全部
            k: 每个知识库返回的文档数
        """
if kb_types isNone:
            kb_types = list(self.kb_config.keys())

        retrievers = []
for kb_type in kb_types:
            config = self.kb_config[kb_type]
            index_path = config["dir"] / "faiss_index"
if index_path.exists():
                vectorstore = FAISS.load_local(
str(index_path), self.embeddings,
                    allow_dangerous_deserialization=True
                )
                retriever = vectorstore.as_retriever(
                    search_kwargs={"k": k}
                )
                retrievers.append(retriever)

iflen(retrievers) == 1:
return retrievers[0]
eliflen(retrievers) > 1:
# 多路召回合并
return MergerRetriever(retrievers=retrievers)
else:
raise ValueError("没有可用的知识库索引")

defsearch_with_context(self, query, kb_types=None, k=5):
"""带上下文的检索"""
        retriever = self.get_retriever(kb_types, k)
        docs = retriever.get_relevant_documents(query)

# 按权重排序
        docs.sort(key=lambda d: d.metadata.get("weight", 0), reverse=True)

        context_parts = []
for doc in docs:
            kb_name = doc.metadata.get("kb_name", "未知")
            weight = doc.metadata.get("weight", 0)
            source = doc.metadata.get("source_file", "")
            context_parts.append(
f"[{kb_name} | 权重:{weight} | 来源:{source}]\n{doc.page_content}"
            )

return"\n\n---\n\n".join(context_parts)

defcompressed_search(self, query, llm, kb_types=None, k=10):
"""压缩检索（用LLM过滤无关内容）"""
        retriever = self.get_retriever(kb_types, k)

# 用LLM压缩检索结果
        compressor = LLMChainExtractor.from_llm(llm)
        compression_retriever = ContextualCompressionRetriever(
            base_compressor=compressor,
            base_retriever=retriever
        )

        compressed_docs = compression_retriever.get_relevant_documents(query)
return compressed_docs


# 使用示例
if __name__ == "__main__":
    kb = TeachingKnowledgeBase()

# 导入课标
    kb.ingest_documents("curriculum_standard", "./data/课标/义务教育数学课程标准2022.pdf")

# 导入教材
    kb.ingest_documents("textbook", "./data/教材/七年级数学上册.pdf")

# 导入历史教案
    kb.ingest_documents("teaching_plan", "./data/教案/有理数加减法_优质课.docx")

# 导入题库
    kb.ingest_documents("question_bank", "./data/题库/七年级数学题库.txt")

# 检索测试
    context = kb.search_with_context("有理数加法法则 核心素养")
print("检索结果：")
print(context)

6.4 检索质量优化三策略

策略一：查询改写

教师输入的查询往往是口语化的（如"这节课的重点是什么"），直接检索效果不好。用LLM先改写查询：

defrewrite_query(original_query, subject, grade, chapter):
"""用LLM改写检索查询"""
    llm = ChatOpenAI(
        model="deepseek-chat",
        api_key="your-api-key",
        base_url="https://api.deepseek.com",
        temperature=0.3
    )

    prompt = f"""请将以下教学查询改写为更适合知识库检索的关键词组合。

原始查询：{original_query}
学科：{subject}
年级：{grade}
章节：{chapter}

请输出3-5个检索关键词组合，用换行分隔。每个组合聚焦一个检索维度。
例如：
- {chapter} 核心素养 教学目标 课标要求
- {chapter} 教学重点 难点 常见错误
- {chapter} 教学设计 活动方案 课堂导入
"""
    result = llm.invoke(prompt)
    queries = result.content.strip().split("\n")
return [q.strip().strip("- ") for q in queries if q.strip()]

策略二：多路召回 + 重排序

对同一查询，分别在课标库、教材库、教案库中检索，然后合并结果并重排序：

defmulti_route_search(query, kb, k=3):
"""多路召回"""
    all_results = []

# 课标库召回
    standard_docs = kb.get_retriever(["curriculum_standard"], k=k).get_relevant_documents(query)
    all_results.extend(standard_docs)

# 教材库召回
    textbook_docs = kb.get_retriever(["textbook"], k=k).get_relevant_documents(query)
    all_results.extend(textbook_docs)

# 教案库召回
    plan_docs = kb.get_retriever(["teaching_plan"], k=k).get_relevant_documents(query)
    all_results.extend(plan_docs)

# 按权重+相关度排序
    all_results.sort(key=lambda d: d.metadata.get("weight", 0), reverse=True)

return all_results[:10]  # 返回top10

策略三：课标知识点强制绑定

最关键的质量保障措施：在教案生成时，强制要求AI引用课标知识点ID：

defgenerate_with_standard_binding(query, kb, llm):
"""带课标绑定的教案生成"""

# 第一步：检索课标
    standard_context = kb.search_with_context(
        query, kb_types=["curriculum_standard"], k=3
    )

# 第二步：检索教材
    textbook_context = kb.search_with_context(
        query, kb_types=["textbook"], k=3
    )

# 第三步：检索教案参考
    plan_context = kb.search_with_context(
        query, kb_types=["teaching_plan"], k=2
    )

    prompt = f"""请基于以下课标和教材内容生成教案。

【课标依据（必须对齐）】
{standard_context}

【教材内容（必须准确）】
{textbook_context}

【优质教案参考（学习风格）】
{plan_context}

请生成教案，并在每个教学目标后标注对应的课标条目编号。
如果某个教学目标无法在课标中找到对应条目，请标注"⚠️ 课标未覆盖"。
"""
    result = llm.invoke(prompt)
return result.content

第七章 AI出卷组卷系统实战

7.1 AI出卷的三种模式

模式一：题库组卷（从已有题库中选题）

适合有结构化题库的场景。AI根据知识点覆盖、难度分布、题型比例等约束，从题库中智能选题组卷。

模式二：AI生成新题（大模型生成原创题目）

适合题库不足或需要定制题目的场景。AI根据知识点和难度要求生成全新题目，但需要人工审核准确性。

模式三：混合模式（题库为主 + AI生成补充）

最实用的模式。先从题库中选题，不足部分用AI生成补充，兼顾质量和覆盖度。

7.2 题库组卷系统实现

# quiz_generator.py — AI出卷组卷系统
from pydantic import BaseModel
from typing importList, Optional
import json
import random

classQuestionSpec(BaseModel):
"""题目规格"""
    question_type: str# 题型：选择/填空/解答/计算
    knowledge_point: str# 知识点
    difficulty: str# 难度：基础/中等/提高
    count: int# 数量

classExamSpec(BaseModel):
"""试卷规格"""
    exam_title: str
    subject: str
    grade: str
    duration: int = 90# 考试时长（分钟）
    total_score: int = 100# 总分
    sections: List[QuestionSpec]  # 各题量规格

classQuizGenerator:
def__init__(self, llm, kb):
self.llm = llm
self.kb = kb  # TeachingKnowledgeBase实例

defgenerate_from_bank(self, exam_spec):
"""从题库组卷"""

        exam_paper = {
"title": exam_spec.exam_title,
"subject": exam_spec.subject,
"grade": exam_spec.grade,
"duration": exam_spec.duration,
"total_score": exam_spec.total_score,
"sections": []
        }

        section_score = exam_spec.total_score // len(exam_spec.sections)

for i, spec inenumerate(exam_spec.sections):
# 从题库检索题目
            query = f"{spec.knowledge_point}{spec.difficulty}{spec.question_type}"
            docs = self.kb.get_retriever(["question_bank"], k=spec.count * 3).get_relevant_documents(query)

# 解析题目
            questions = []
for doc in docs[:spec.count]:
try:
                    q = json.loads(doc.page_content)
                    questions.append(q)
except json.JSONDecodeError:
# 非JSON格式的题目，直接用文本
                    questions.append({
"content": doc.page_content,
"type": spec.question_type,
"difficulty": spec.difficulty,
"knowledge_point": spec.knowledge_point
                    })

# 如果题库不足，用AI生成补充
iflen(questions) < spec.count:
                shortage = spec.count - len(questions)
                generated = self._generate_new_questions(spec, shortage)
                questions.extend(generated)

            exam_paper["sections"].append({
"section_name": f"第{i+1}部分：{spec.question_type}题",
"question_type": spec.question_type,
"score_per_question": section_score // spec.count,
"section_score": section_score,
"questions": questions
            })

return exam_paper

def_generate_new_questions(self, spec, count):
"""用AI生成新题目"""

        prompt = f"""请生成{count}道{spec.difficulty}难度的{spec.question_type}题。

【知识点】{spec.knowledge_point}

请输出JSON格式：
[
  {{
    "content": "题干内容",
    "options": ["A. ...", "B. ...", "C. ...", "D. ..."],  // 选择题才有
    "answer": "正确答案",
    "analysis": "解析说明",
    "difficulty": "{spec.difficulty}",
    "knowledge_point": "{spec.knowledge_point}"
  }}
]

要求：
1. 题目必须准确无误，不能有知识性错误
2. 难度必须符合"{spec.difficulty}"级别
3. 选择题的干扰项要有迷惑性但不能有歧义
4. 解析要详细，说明解题思路
"""
        result = self.llm.invoke(prompt)
try:
            questions = json.loads(result.content)
# 标记为AI生成
for q in questions:
                q["source"] = "AI生成"
                q["needs_review"] = True
return questions
except json.JSONDecodeError:
return []

defgenerate_variations(self, question, count=3):
"""生成题目的变式（同知识点不同情境）"""

        prompt = f"""请基于以下题目，生成{count}道变式题。

【原题】
{json.dumps(question, ensure_ascii=False)}

变式要求：
1. 保持知识点和难度不变
2. 更换情境、数据或提问角度
3. 不能与原题雷同

请输出JSON数组格式。
"""
        result = self.llm.invoke(prompt)
try:
            variations = json.loads(result.content)
for v in variations:
                v["source"] = "AI变式生成"
                v["original_question"] = question.get("content", "")
                v["needs_review"] = True
return variations
except json.JSONDecodeError:
return []

defexport_to_docx(self, exam_paper, output_path, include_answer=True):
"""导出试卷为Word"""
from docx import Document
from docx.shared import Pt, Inches
from docx.enum.text import WD_ALIGN_PARAGRAPH

        doc = Document()

# 试卷标题
        title = doc.add_heading(exam_paper["title"], level=0)
        title.alignment = WD_ALIGN_PARAGRAPH.CENTER

# 基本信息
        info = doc.add_paragraph()
        info.alignment = WD_ALIGN_PARAGRAPH.CENTER
        info.add_run(
f'{exam_paper["subject"]} · {exam_paper["grade"]} · '
f'考试时间{exam_paper["duration"]}分钟 · 满分{exam_paper["total_score"]}分'
        )

        doc.add_paragraph("")

# 各部分题目
        question_num = 1
for section in exam_paper["sections"]:
            doc.add_heading(section["section_name"], level=1)

            score_info = doc.add_paragraph()
            score_info.add_run(
f'（本大题共{len(section["questions"])}小题，'
f'每小题{section["score_per_question"]}分，'
f'共{section["section_score"]}分）'
            ).italic = True

for q in section["questions"]:
# 题干
                p = doc.add_paragraph()
                p.add_run(f'{question_num}. ').bold = True
                p.add_run(q.get("content", ""))

# 选择题选项
if q.get("options"):
for opt in q["options"]:
                        doc.add_paragraph(opt)

                doc.add_paragraph("")  # 空行
                question_num += 1

            doc.add_page_break()

# 答案与解析
if include_answer:
            doc.add_heading("参考答案与解析", level=0)

            question_num = 1
for section in exam_paper["sections"]:
for q in section["questions"]:
                    p = doc.add_paragraph()
                    p.add_run(f'{question_num}. ').bold = True
                    p.add_run(f'答案：{q.get("answer", "——")}').bold = True

if q.get("analysis"):
                        doc.add_paragraph(f'解析：{q["analysis"]}')

if q.get("needs_review"):
                        warning = doc.add_paragraph()
                        run = warning.add_run("⚠️ 本题为AI生成，请教师审核后使用")
                        run.font.color.rgb = None# 红色
                        run.italic = True

                    doc.add_paragraph("")
                    question_num += 1

        doc.save(output_path)
print(f"试卷已导出：{output_path}")


# 使用示例
if __name__ == "__main__":
from langchain_openai import ChatOpenAI

    llm = ChatOpenAI(
        model="deepseek-chat",
        api_key="your-api-key",
        base_url="https://api.deepseek.com",
        temperature=0.5
    )

    kb = TeachingKnowledgeBase()
    generator = QuizGenerator(llm, kb)

# 定义试卷规格
    exam_spec = ExamSpec(
        exam_title="七年级数学期中测试卷",
        subject="数学",
        grade="七年级",
        duration=90,
        total_score=100,
        sections=[
            QuestionSpec(question_type="选择", knowledge_point="有理数", difficulty="基础", count=10),
            QuestionSpec(question_type="填空", knowledge_point="有理数运算", difficulty="中等", count=5),
            QuestionSpec(question_type="解答", knowledge_point="有理数应用", difficulty="提高", count=3),
        ]
    )

# 生成试卷
    exam_paper = generator.generate_from_bank(exam_spec)

# 导出Word
    generator.export_to_docx(exam_paper, "./output/七年级数学期中测试卷.docx")