@Service
public class PersonalizedTutoringService {

    private final ChatClient chatClient;
    private final VectorStore knowledgeVectorStore;
    private final KnowledgeGraphService knowledgeGraph;
    private final StudentProfileRepository studentProfileRepo;
    private final LearningRecordService learningRecordService;

    // 引导式答疑的最大追问轮数（超过此轮数才会提供更直接的提示）
    private static final int MAX_GUIDED_ROUNDS = 3;

    public TutoringResponse tutor(TutoringRequest request) {
        // 1. 加载学生画像
        StudentProfile profile = studentProfileRepo.findByStudentId(request.getStudentId())
            .orElse(StudentProfile.createDefault(request.getStudentId()));

        // 2. 识别问题中的知识点
        List<String> targetKnowledgePoints = identifyKnowledgePoints(request.getQuestion());
        
        // 3. 知识图谱查询：获取结构化知识上下文
        KnowledgeContext knowledgeContext = buildKnowledgeContext(
            targetKnowledgePoints, profile
        );
        
        // 4. RAG检索相关讲解内容
        List<Document> relevantContent = retrieveRelevantContent(
            request.getQuestion(), targetKnowledgePoints
        );
        
        // 5. 判断是否是「反复追问要答案」的行为
        boolean isAnswerSeeking = detectAnswerSeekingBehavior(
            request.getStudentId(), request.getSessionId(), request.getQuestion()
        );
        
        // 6. 生成引导式答复
        String response = generateGuidedResponse(
            request, profile, knowledgeContext, relevantContent, isAnswerSeeking
        );
        
        // 7. 记录学习行为
        learningRecordService.record(LearningRecord.builder()
            .studentId(request.getStudentId())
            .sessionId(request.getSessionId())
            .question(request.getQuestion())
            .response(response)
            .knowledgePoints(targetKnowledgePoints)
            .answerSeeking(isAnswerSeeking)
            .timestamp(LocalDateTime.now())
            .build());
        
        return TutoringResponse.builder()
            .response(response)
            .knowledgePointsInvolved(targetKnowledgePoints)
            .suggestedNextStudy(knowledgeContext.getSuggestedNextStudy())
            .build();
    }

    private List<String> identifyKnowledgePoints(String question) {
        // 用LLM从问题中提取涉及的知识点ID
        String extractionPrompt = """
            从以下学生问题中，识别涉及的数学/语文/物理等学科知识点。
            返回JSON格式的知识点列表：{"knowledgePoints": ["知识点1", "知识点2"]}
            只返回明确涉及的知识点，不要过度推断。
            
            学生问题：%s
            """.formatted(question);
        
        String response = chatClient.prompt()
            .user(extractionPrompt)
            .call()
            .content();
        
        try {
            String json = extractJsonFromResponse(response);
            Map<String, Object> parsed = new ObjectMapper().readValue(json, Map.class);
            return (List<String>) parsed.getOrDefault("knowledgePoints", List.of());
        } catch (Exception e) {
            log.warn("Failed to extract knowledge points, using empty list", e);
            return List.of();
        }
    }

    private KnowledgeContext buildKnowledgeContext(
            List<String> knowledgePoints, StudentProfile profile) {
        
        KnowledgeContext.Builder contextBuilder = KnowledgeContext.builder();
        
        for (String kp : knowledgePoints) {
            // 从知识图谱查询该知识点的前置知识
            List<String> prerequisites = knowledgeGraph.getPrerequisites(kp);
            
            // 判断学生是否掌握了前置知识
            List<String> missingPrerequisites = prerequisites.stream()
                .filter(prereq -> !profile.hasMastered(prereq))
                .collect(Collectors.toList());
            
            // 查询相关例题（按难度匹配学生水平）
            List<ExampleProblem> examples = knowledgeGraph.getExamples(
                kp, 
                profile.getCurrentLevel(kp),
                3 // 最多3道例题
            );
            
            // 查询常见错误点
            List<String> commonMistakes = knowledgeGraph.getCommonMistakes(kp);
            
            // 查询掌握该知识点后的后续学习路径
            List<String> nextStudyPoints = knowledgeGraph.getNextStudyPoints(kp);
            
            contextBuilder.addKnowledgePointContext(KnowledgePointContext.builder()
                .knowledgePoint(kp)
                .missingPrerequisites(missingPrerequisites)
                .relevantExamples(examples)
                .commonMistakes(commonMistakes)
                .studentMasteryLevel(profile.getMasteryLevel(kp))
                .build());
            
            contextBuilder.suggestedNextStudy(nextStudyPoints);
        }
        
        return contextBuilder.build();
    }

    private boolean detectAnswerSeekingBehavior(
            String studentId, String sessionId, String currentQuestion) {
        
        // 获取当前会话的历史交互
        List<LearningRecord> sessionHistory = learningRecordService
            .getSessionHistory(studentId, sessionId);
        
        if (sessionHistory.isEmpty()) return false;
        
        // 判断标准：最近3轮中，有2轮以上包含「直接给我答案」类似语义
        long directAnswerRequests = sessionHistory.stream()
            .skip(Math.max(0, sessionHistory.size() - 3))
            .filter(record -> isDirectAnswerRequest(record.getQuestion()))
            .count();
        
        return directAnswerRequests >= 2 || isDirectAnswerRequest(currentQuestion);
    }

    private boolean isDirectAnswerRequest(String question) {
        // 检测直接要答案的行为
        List<String> answerSeekingPatterns = List.of(
            "直接告诉我答案", "给我答案", "答案是什么", "直接说答案",
            "就告诉我结果", "不用解释", "答案给我", "直接给答案"
        );
        return answerSeekingPatterns.stream()
            .anyMatch(pattern -> question.contains(pattern));
    }

    private String generateGuidedResponse(
            TutoringRequest request,
            StudentProfile profile,
            KnowledgeContext knowledgeContext,
            List<Document> relevantContent,
            boolean isAnswerSeeking) {
        
        String systemPrompt = buildTutoringSystemPrompt(profile, isAnswerSeeking);
        String userPrompt = buildTutoringUserPrompt(
            request, knowledgeContext, relevantContent, isAnswerSeeking
        );
        
        return chatClient.prompt()
            .system(systemPrompt)
            .user(userPrompt)
            .call()
            .content();
    }

    private String buildTutoringSystemPrompt(StudentProfile profile, boolean isAnswerSeeking) {
        StringBuilder sb = new StringBuilder();
        
        sb.append("""
            你是一位耐心、专业的学习辅导老师，擅长引导学生通过思考自己找到答案。
            
            你的辅导风格：
            1. 不直接给出答案，而是通过提问和提示，帮助学生自己推导
            2. 发现学生的思维误区时，用温和的方式指出，不批评
            3. 适时给予鼓励，让学生有成就感
            4. 解释要与学生的水平匹配，不要太难也不要太简单
            
            """);
        
        // 根据学生水平调整语言风格
        sb.append("学生基本情况：\n");
        sb.append(String.format("- 年级：%s\n", profile.getGrade()));
        sb.append(String.format("- 整体学习水平：%s\n", profile.getOverallLevel()));
        sb.append(String.format("- 偏好的解释风格：%s\n", profile.getPreferredExplanationStyle()));
        
        if (isAnswerSeeking) {
            sb.append("""
                
                特别注意：该学生反复要求直接给答案。
                处理方式：
                - 明确告知AI辅导的目的是帮助学习，不是替代思考
                - 提供更详细的解题步骤提示，但仍然不给最终答案
                - 可以说"我注意到你已经问了好几次答案了，让我换个方式帮助你..."
                - 向学生解释：掌握方法比得到答案更重要
                """);
        }
        
        return sb.toString();
    }

    private String buildTutoringUserPrompt(
            TutoringRequest request,
            KnowledgeContext knowledgeContext,
            List<Document> relevantContent,
            boolean isAnswerSeeking) {
        
        StringBuilder sb = new StringBuilder();
        
        sb.append("## 学生提问\n");
        sb.append(request.getQuestion()).append("\n\n");
        
        // 如果有对话历史，加入
        if (!request.getConversationHistory().isEmpty()) {
            sb.append("## 本次对话历史\n");
            request.getConversationHistory().forEach(msg -> {
                sb.append(msg.getRole()).append("：").append(msg.getContent()).append("\n");
            });
            sb.append("\n");
        }
        
        // 知识图谱上下文
        if (!knowledgeContext.getContexts().isEmpty()) {
            sb.append("## 知识点上下文（辅导参考，不直接展示给学生）\n");
            
            for (KnowledgePointContext kpc : knowledgeContext.getContexts()) {
                sb.append(String.format("### 知识点：%s\n", kpc.getKnowledgePoint()));
                sb.append(String.format("学生掌握程度：%s\n", kpc.getStudentMasteryLevel()));
                
                if (!kpc.getMissingPrerequisites().isEmpty()) {
                    sb.append("⚠️ 缺少前置知识：\n");
                    kpc.getMissingPrerequisites()
                        .forEach(prereq -> sb.append("- ").append(prereq).append("\n"));
                    sb.append("→ 辅导时需要先补充这些前置知识\n");
                }
                
                if (!kpc.getCommonMistakes().isEmpty()) {
                    sb.append("常见错误点（重点关注）：\n");
                    kpc.getCommonMistakes()
                        .forEach(mistake -> sb.append("- ").append(mistake).append("\n"));
                }
            }
            sb.append("\n");
        }
        
        // 相关教材内容
        if (!relevantContent.isEmpty()) {
            sb.append("## 相关教材内容（作为解释依据）\n");
            relevantContent.forEach(doc -> {
                sb.append(doc.getContent()).append("\n---\n");
            });
            sb.append("\n");
        }
        
        sb.append("## 辅导要求\n");
        if (isAnswerSeeking) {
            sb.append("学生一直在要求直接给答案，请先温和地说明学习目的，然后提供分步骤的提示，引导学生自己找到答案。\n");
        } else {
            sb.append("请用引导式方式辅导这位学生，不要直接给出最终答案，而是通过提问和提示帮助他/她思考。\n");
        }
        
        return sb.toString();
    }
}

这段代码的核心设计点：

1. 行为检测机制

detectAnswerSeekingBehavior 会分析学生的历史行为，识别反复要答案的模式。这不是技术炫耀，是真实解决了我前面说的「学生把系统教坏」的问题。

2. 知识图谱在 Prompt 里的使用方式

注意我把知识图谱上下文标注为「辅导参考，不直接展示给学生」。这是告诉 LLM 这部分信息的用途——用来指导辅导策略，不是要原样复读给学生看。LLM 会据此调整辅导方式，比如发现学生缺少前置知识时，会先补充前置知识再讲题。

3. 前置知识检查是个重要设计

很多学生卡在一道题上，不是这道题本身难，是前置知识没掌握。如果系统发现学生缺少前置知识，直接辅导这道题是无效的。正确的做法是先补充前置知识，这在普通 RAG 系统里完全没有考虑，需要知识图谱来支撑。

学生画像的工程实现

个性化的基础是学生画像，画像的质量直接决定个性化的效果。

画像包含什么

@Entity
public class StudentProfile {
    private String studentId;
    private String grade;               // 年级
    private String overallLevel;        // 整体水平（BASIC/INTERMEDIATE/ADVANCED）
    private String preferredExplanationStyle; // 偏好解释方式
    
    // 按知识点的掌握情况
    @ElementCollection
    private Map<String, MasteryLevel> knowledgeMastery;
    
    // 学习行为特征
    private int averageQuestionLength;  // 平均问题长度（判断思考深度）
    private double answerSeekingRatio;  // 要答案行为占比（识别学习习惯）
    private int consecutiveDays;        // 连续学习天数
    
    // 薄弱知识点列表（频繁出错的）
    @ElementCollection
    private List<String> weakKnowledgePoints;
    
    // 最近学习的知识点（用于上下文连续性）
    @ElementCollection
    private List<String> recentStudyPoints;
}