第19章 教育与培训MCP应用
前言
教育改变生命。本章展示如何通过MCP将Claude集成到教育培训系统中，实现个性化学习、智能答疑、学习路径推荐和员工能力发展的完全自动化。
19.1 案例1：智能学习系统
19.1.1 应用场景
graph TB
A["学习资源"] --> B["课程库"]
A --> C["习题库"]
A --> D["学习进度"]
A --> E["知识图谱"]
F["学生学习"] --> F1["智能答疑"]
F --> F2["习题推荐"]
F --> F3["学习路径"]
F --> F4["进度追踪"]
B --> F
C --> F
D --> F
E --> F
F --> G["学习效果提升"]
F --> H["个性化教学"]
19.1.2 学习系统核心实现
from typing import Dict, List, Optional
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
class DifficultyLevel(Enum):
"""难度等级"""
BEGINNER = "beginner"
INTERMEDIATE = "intermediate"
ADVANCED = "advanced"
EXPERT = "expert"
class QuestionType(Enum):
"""题型"""
MULTIPLE_CHOICE = "multiple_choice"
SHORT_ANSWER = "short_answer"
ESSAY = "essay"
CODE = "code"
@dataclass
class Course:
"""课程"""
course_id: str
title: str
description: str
duration_hours: int
difficulty: DifficultyLevel
prerequisites: List[str] = field(default_factory=list)
learning_objectives: List[str] = field(default_factory=list)
modules: List[str] = field(default_factory=list)
@dataclass
class Question:
"""题目"""
question_id: str
content: str
question_type: QuestionType
difficulty: DifficultyLevel
course_id: str
answer: str
explanation: str
@dataclass
class StudentProfile:
"""学生档案"""
student_id: str
name: str
enrolled_courses: List[str] = field(default_factory=list)
completed_courses: List[str] = field(default_factory=list)
learning_style: str = "mixed" # visual, auditory, kinesthetic, reading
learning_pace: str = "normal" # slow, normal, fast
knowledge_map: Dict[str, float] = field(default_factory=dict) # 各知识点掌握度
class IntelligentLearningSystem:
"""智能学习系统"""
def __init__(self):
self.courses: Dict[str, Course] = {}
self.questions: Dict[str, Question] = {}
self.students: Dict[str, StudentProfile] = {}
self.learning_records: Dict[str, List[Dict]] = {}
async def answer_student_question(self, student_id: str,
question: str,
context: Dict = None) -> Dict:
"""
回答学生问题
Args:
student_id: 学生ID
question: 问题内容
context: 上下文（当前课程、章节等）
Returns:
答案与解释
"""
student = self.students.get(student_id)
if not student:
return {"error": "Student not found"}
# 识别问题主题
keywords = question.lower().split()
related_courses = self._find_related_courses(keywords, student.enrolled_courses)
# 获取相关知识点
knowledge_points = self._extract_knowledge_points(question)
# 生成回答
answer_context = {
"difficulty": self._estimate_student_level(student),
"learning_style": student.learning_style,
"known_concepts": self._get_known_concepts(student)
}
return {
"student_id": student_id,
"question": question,
"related_courses": related_courses,
"knowledge_points": knowledge_points,
"answer_style": "explanation",
"suggested_follow_up": ["相关练习题", "深入讲解", "视频教程"],
"learning_record": {
"timestamp": datetime.now().isoformat(),
"question_type": "conceptual",
"difficulty_encountered": "medium"
}
}
def _find_related_courses(self, keywords: List[str],
enrolled: List[str]) -> List[str]:
"""查找相关课程"""
related = []
for course_id in enrolled:
course = self.courses.get(course_id)
if course and any(kw in course.title.lower() for kw in keywords):
related.append(course.title)
return related[:3]
def _extract_knowledge_points(self, question: str) -> List[str]:
"""提取知识点"""
# 简化版本，实际应使用NER或NLP技术
return ["基础概念", "应用实践"]
def _estimate_student_level(self, student: StudentProfile) -> str:
"""评估学生水平"""
if len(student.completed_courses) == 0:
return "beginner"
elif len(student.completed_courses) <= 3:
return "intermediate"
else:
return "advanced"
def _get_known_concepts(self, student: StudentProfile) -> List[str]:
"""获取已知概念"""
known = []
for concept, mastery in student.knowledge_map.items():
if mastery >= 0.7:
known.append(concept)
return known
async def recommend_learning_path(self, student_id: str) -> Dict:
"""
推荐学习路径
Args:
student_id: 学生ID
Returns:
学习路径推荐
"""
student = self.students.get(student_id)
if not student:
return {"error": "Student not found"}
# 分析学生进度
completed = len(student.completed_courses)
enrolled = len(student.enrolled_courses)
# 生成学习路径
path = []
# 1. 完成当前课程
for course_id in student.enrolled_courses:
course = self.courses.get(course_id)
if course:
progress = self._get_course_progress(student_id, course_id)
path.append({
"course": course.title,
"status": "in_progress",
"progress": progress,
"estimated_completion_days": max(1, (100 - progress) // 20)
})
# 2. 推荐后续课程
recommended = self._recommend_next_courses(student)
for course in recommended:
path.append({
"course": course.title,
"status": "recommended",
"difficulty": course.difficulty.value,
"estimated_hours": course.duration_hours
})
return {
"student_id": student_id,
"current_level": self._estimate_student_level(student),
"learning_path": path,
"estimated_total_hours": sum(
c.get("estimated_hours", 40) for c in path
),
"next_milestone": "完成第一门课程获得认证"
}
def _get_course_progress(self, student_id: str, course_id: str) -> float:
"""获取课程进度"""
records = self.learning_records.get(student_id, [])
course_records = [r for r in records if r.get("course_id") == course_id]
return len(course_records) * 10 % 100 # 简化计算
def _recommend_next_courses(self, student: StudentProfile) -> List[Course]:
"""推荐后续课程"""
recommended = []
student_level = self._estimate_student_level(student)
for course_id, course in self.courses.items():
# 检查是否已完成或已注册
if course_id in student.completed_courses or course_id in student.enrolled_courses:
continue
# 检查先修要求
if course.prerequisites and not all(p in student.completed_courses for p in course.prerequisites):
continue
# 难度匹配
if (student_level == "beginner" and course.difficulty in [DifficultyLevel.BEGINNER, DifficultyLevel.INTERMEDIATE]) or \
(student_level == "intermediate" and course.difficulty in [DifficultyLevel.INTERMEDIATE, DifficultyLevel.ADVANCED]) or \
(student_level == "advanced" and course.difficulty in [DifficultyLevel.ADVANCED, DifficultyLevel.EXPERT]):
recommended.append(course)
return recommended[:3]
async def suggest_practice_problems(self, student_id: str,
topic: str, limit: int = 5) -> Dict:
"""
推荐练习题
Args:
student_id: 学生ID
topic: 主题
limit: 推荐数量
Returns:
练习题推荐
"""
student = self.students.get(student_id)
if not student:
return {"error": "Student not found"}
student_level = self._estimate_student_level(student)
# 查找相关题目
matching_questions = []
for q_id, q in self.questions.items():
# 检查主题相关性（简化版）
if topic.lower() in q.content.lower():
# 难度匹配
if self._match_difficulty(student_level, q.difficulty):
matching_questions.append(q)
# 按难度排序
matching_questions.sort(key=lambda x: x.difficulty.value)
return {
"student_id": student_id,
"topic": topic,
"suggested_problems": [
{
"id": q.question_id,
"content": q.content[:100],
"type": q.question_type.value,
"difficulty": q.difficulty.value,
"estimated_time_minutes": 5 if q.question_type == QuestionType.MULTIPLE_CHOICE else 15
}
for q in matching_questions[:limit]
],
"learning_objectives": [
"掌握核心概念",
"提升解题能力",
"应用知识点"
]
}
def _match_difficulty(self, student_level: str,
question_difficulty: DifficultyLevel) -> bool:
"""检查难度匹配"""
level_map = {
"beginner": [DifficultyLevel.BEGINNER, DifficultyLevel.INTERMEDIATE],
"intermediate": [DifficultyLevel.INTERMEDIATE, DifficultyLevel.ADVANCED],
"advanced": [DifficultyLevel.ADVANCED, DifficultyLevel.EXPERT]
}
return question_difficulty in level_map.get(student_level, [])
class LearningMCPServer:
"""学习MCP服务器"""
def __init__(self, system: IntelligentLearningSystem):
self.system = system
def get_tools(self) -> List[Dict]:
"""定义工具"""
return [
{
"name": "answer_question",
"description": "回答学生问题",
"inputSchema": {
"type": "object",
"properties": {
"student_id": {"type": "string"},
"question": {"type": "string"},
"context": {"type": "object"}
},
"required": ["student_id", "question"]
}
},
{
"name": "learning_path",
"description": "推荐学习路径",
"inputSchema": {
"type": "object",
"properties": {
"student_id": {"type": "string"}
},
"required": ["student_id"]
}
},
{
"name": "practice_problems",
"description": "推荐练习题",
"inputSchema": {
"type": "object",
"properties": {
"student_id": {"type": "string"},
"topic": {"type": "string"},
"limit": {"type": "integer"}
},
"required": ["student_id", "topic"]
}
}
]
async def call_tool(self, tool_name: str, arguments: Dict) -> str:
"""调用工具"""
import json
try:
if tool_name == "answer_question":
result = await self.system.answer_student_question(
arguments["student_id"],
arguments["question"],
arguments.get("context")
)
elif tool_name == "learning_path":
result = await self.system.recommend_learning_path(
arguments["student_id"]
)
elif tool_name == "practice_problems":
result = await self.system.suggest_practice_problems(
arguments["student_id"],
arguments["topic"],
arguments.get("limit", 5)
)
else:
return json.dumps({"error": f"Unknown tool: {tool_name}"})
return json.dumps(result, ensure_ascii=False, indent=2)
except Exception as e:
return json.dumps({"error": str(e)})
19.2 案例2：员工培训与发展系统
19.2.1 能力模型与培训管理
@dataclass
class Competency:
"""能力"""
competency_id: str
name: str
description: str
proficiency_levels: List[str] # ["基础", "中级", "高级", "专家"]
assessment_criteria: Dict[str, str]
@dataclass
class EmployeeProfile:
"""员工档案"""
employee_id: str
name: str
position: str
current_competencies: Dict[str, int] = field(default_factory=dict) # 能力ID -> 等级
target_competencies: Dict[str, int] = field(default_factory=dict) # 目标
completed_trainings: List[str] = field(default_factory=list)
class EmployeeTrainingManager:
"""员工培训管理"""
def __init__(self):
self.employees: Dict[str, EmployeeProfile] = {}
self.competencies: Dict[str, Competency] = {}
self.trainings: Dict[str, Dict] = {}
self.development_plans: Dict[str, Dict] = {}
async def create_development_plan(self, employee_id: str) -> Dict:
"""
创建发展计划
Args:
employee_id: 员工ID
Returns:
发展计划
"""
employee = self.employees.get(employee_id)
if not employee:
return {"error": "Employee not found"}
# 分析能力差距
gaps = {}
for comp_id, target_level in employee.target_competencies.items():
current_level = employee.current_competencies.get(comp_id, 0)
if current_level < target_level:
gaps[comp_id] = target_level - current_level
# 推荐培训
recommended_trainings = []
for comp_id, gap_size in gaps.items():
competency = self.competencies.get(comp_id)
if competency:
recommended_trainings.append({
"competency": competency.name,
"current_level": employee.current_competencies.get(comp_id, 0),
"target_level": employee.target_competencies[comp_id],
"gap": gap_size,
"priority": "high" if gap_size >= 2 else "medium"
})
# 按优先级排序
recommended_trainings.sort(key=lambda x: x["priority"] == "high", reverse=True)
return {
"employee_id": employee_id,
"employee_name": employee.name,
"position": employee.position,
"current_period": f"{datetime.now().year}年Q1",
"development_plan": {
"competency_gaps": recommended_trainings,
"training_recommendations": [t["competency"] for t in recommended_trainings[:5]],
"timeline_months": len(gaps) * 2,
"success_metrics": [
"完成所有推荐培训",
"能力达到目标等级",
"通过能力评估"
]
},
"mentor_assignment": "根据能力匹配分配导师"
}
async def assess_competency(self, employee_id: str,
competency_id: str) -> Dict:
"""
评估能力
Args:
employee_id: 员工ID
competency_id: 能力ID
Returns:
评估结果
"""
employee = self.employees.get(employee_id)
competency = self.competencies.get(competency_id)
if not employee or not competency:
return {"error": "Employee or competency not found"}
current_level = employee.current_competencies.get(competency_id, 0)
return {
"employee_id": employee_id,
"competency": competency.name,
"current_level": current_level,
"level_description": competency.proficiency_levels[current_level] if current_level < len(competency.proficiency_levels) else "未评估",
"assessment_criteria": competency.assessment_criteria,
"next_level_requirements": [
"完成进阶培训",
"项目实践2个月",
"通过能力测试"
],
"estimated_time_to_next_level_months": 3
}
async def recommend_mentor(self, employee_id: str) -> Dict:
"""
推荐导师
Args:
employee_id: 员工ID
Returns:
导师推荐
"""
employee = self.employees.get(employee_id)
if not employee:
return {"error": "Employee not found"}
# 查找能力互补的导师
mentors = []
for emp_id, emp in self.employees.items():
if emp_id == employee_id:
continue
# 检查导师是否在相关能力上更强
match_score = 0
for comp_id, target_level in employee.target_competencies.items():
mentor_level = emp.current_competencies.get(comp_id, 0)
if mentor_level > employee.current_competencies.get(comp_id, 0):
match_score += 1
if match_score > 0:
mentors.append({
"mentor_id": emp.employee_id,
"name": emp.name,
"match_score": match_score,
"strengths": self._get_mentor_strengths(emp)
})
mentors.sort(key=lambda x: x["match_score"], reverse=True)
return {
"employee_id": employee_id,
"recommended_mentors": mentors[:3],
"mentoring_format": ["一对一指导", "项目协作", "知识分享会"],
"recommended_duration_months": 6
}
def _get_mentor_strengths(self, employee: EmployeeProfile) -> List[str]:
"""获取导师优势"""
strengths = []
for comp_id, level in employee.current_competencies.items():
competency = self.competencies.get(comp_id)
if competency and level >= 2: # 高级或以上
strengths.append(competency.name)
return strengths[:3]
class TrainingMCPServer:
"""培训MCP服务器"""
def __init__(self, manager: EmployeeTrainingManager):
self.manager = manager
def get_tools(self) -> List[Dict]:
"""定义工具"""
return [
{
"name": "create_plan",
"description": "创建发展计划",
"inputSchema": {
"type": "object",
"properties": {
"employee_id": {"type": "string"}
},
"required": ["employee_id"]
}
},
{
"name": "assess_competency",
"description": "评估能力",
"inputSchema": {
"type": "object",
"properties": {
"employee_id": {"type": "string"},
"competency_id": {"type": "string"}
},
"required": ["employee_id", "competency_id"]
}
},
{
"name": "recommend_mentor",
"description": "推荐导师",
"inputSchema": {
"type": "object",
"properties": {
"employee_id": {"type": "string"}
},
"required": ["employee_id"]
}
}
]
async def call_tool(self, tool_name: str, arguments: Dict) -> str:
"""调用工具"""
import json
try:
if tool_name == "create_plan":
result = await self.manager.create_development_plan(
arguments["employee_id"]
)
elif tool_name == "assess_competency":
result = await self.manager.assess_competency(
arguments["employee_id"],
arguments["competency_id"]
)
elif tool_name == "recommend_mentor":
result = await self.manager.recommend_mentor(
arguments["employee_id"]
)
else:
return json.dumps({"error": f"Unknown tool: {tool_name}"})
return json.dumps(result, ensure_ascii=False, indent=2)
except Exception as e:
return json.dumps({"error": str(e)})
本章总结
| 关键点 | 说明 |
|---|---|
| 智能答疑 | 基于学生水平的个性化解答 |
| 学习路径 | 个性化学习推荐和进度规划 |
| 练习推荐 | 难度匹配的习题推荐 |
| 能力模型 | 多维度能力评估体系 |
| 发展计划 | 个性化培训与发展规划 |
| 导师匹配 | 智能导师推荐和配对 |
| 学习进度 | 实时追踪和反馈 |
常见问题
Q1: 如何实现个性化学习推荐？ A: 学生档案、学习历史、能力评估、协同过滤算法。
Q2: 如何评估学习效果？ A: 练习成绩、测试分数、能力等级、学习时间。
Q3: 如何设计学习路径？ A: 先修要求、难度梯度、时间规划、目标导向。
Q4: 如何选择合适的导师？ A: 能力互补、工作相关、可用性、学生偏好。
Q5: 如何处理学习障碍？ A: 诊断问题、调整策略、提供辅导资源、跟踪改进。
下一章预告：第20章将讲述制造与供应链MCP应用！
