Upload 15 files

Project.md

@@ -0,0 +1,126 @@
+# 教育LLM助手项目文档
+
+## 项目概述
+
+这是一个基于Gradio构建的教育类LLM应用，主要功能是将学习问题分解为相关概念并提供详细解释。
+
+## 系统架构
+
+### 主要组件
+
+1. **前端界面** (app.py)
+   - 使用Gradio构建的Web界面
+   - 包含用户配置、问题输入、概念图谱展示和概念解释等模块
+
+2. **LLM链** (llm_chain.py)
+   - 处理核心的AI交互逻辑
+   - 包含两个主要功能：概念分解和概念解释
+
+3. **可视化模块** (visualization.py)
+   - 负责生成概念知识图谱
+
+### 数据流程
+
+```mermaid
+graph LR
+    A[用户输入] --> B[问题分析]
+    B --> C[概念分解]
+    C --> D[知识图谱生成]
+    C --> E[概念卡片生成]
+    E --> F[概念选择]
+    F --> G[概念解释生成]
+```
+
+## Prompt系统
+
+### 1. 概念分解 Prompt (prompts.py)
+
+输入参数：
+- question: 用户问题
+- grade: 年级水平
+- subject: 学科
+- learning_needs: 学习需求
+
+Prompt模板：
+```python
+def generate_decomposition_prompt(question, grade, subject, learning_needs):
+    return f"""
+    作为一名{subject}教育专家，请分析以下{grade}级学生的问题：
+    
+    问题：{question}
+    
+    学习需求：{learning_needs}
+    
+    请将这个问题分解为相关的核心概念，并说明它们之间的关系。
+    """
+```
+
+### 2. 概念解释 Prompt (prompts.py)
+
+输入参数：
+- concept_name: 概念名称
+- concept_description: 概念描述
+- grade: 年级水平
+- subject: 学科
+- learning_needs: 学习需求
+
+Prompt模板：
+```python
+def generate_explanation_prompt(concept_name, concept_description, grade, subject, learning_needs):
+    return f"""
+    请为{grade}级{subject}学生解释以下概念：
+    
+    概念：{concept_name}
+    描述：{concept_description}
+    
+    学习需求：{learning_needs}
+    
+    请提供：
+    1. 详细解释
+    2. 具体例子
+    3. 相关学习资源
+    4. 练习题
+    """
+```
+
+## 处理流程
+
+1. **用户输入阶段**
+   - 用户设置学习配置（年级、学科、学习需求）
+   - 输入学习问题
+
+2. **概念分解阶段**
+   - 系统使用decomposition prompt分析问题
+   - 生成相关概念及其关系
+   - 创建概念知识图谱
+   - 生成概念卡片
+
+3. **概念解释阶段**
+   - 用户选择特定概念
+   - 系统使用explanation prompt生成详细解释
+   - 提供例子、资源和练习题
+
+4. **缓存机制**
+   - 使用AppState类管理状态
+   - 缓存已生成的概念解释
+   - 存储用户配置和当前概念数据
+
+## 输出格式
+
+1. **概念分解输出**
+   - 概念列表（名称、描述、难度）
+   - 概念间关系
+   - 可视化知识图谱
+
+2. **概念解释输出**
+   - 详细解释文本
+   - 示例（包含难度分级）
+   - 学习资源链接
+   - 练习题（带答案）
+
+## 注意事项
+
+1. 所有输出都经过格式化，以适应不同年级水平
+2. 系统支持多语言（通过用户界面配置）
+3. 实现了错误处理和优雅的降级机制
+4. 使用缓存来提高响应速度 

cache_utils.py

@@ -0,0 +1,147 @@
+"""
+Utility module for caching LLM responses
+"""
+import os
+import json
+import hashlib
+from typing import Dict, Any, Optional
+from config import CACHE_ENABLED, DEBUG_MODE
+
+# Cache directory
+CACHE_DIR = "cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+def generate_cache_key(prompt_type: str, params: Dict[str, Any]) -> str:
+    """
+    Generate a cache key based on prompt type and parameters
+    
+    Args:
+        prompt_type: Prompt type, such as 'decompose' or 'explain'
+        params: Prompt parameters
+        
+    Returns:
+        Cache key string
+    """
+    # Convert parameters to a standardized JSON string
+    params_str = json.dumps(params, sort_keys=True, ensure_ascii=False)
+    
+    # Calculate hash value
+    hash_obj = hashlib.md5(f"{prompt_type}:{params_str}".encode('utf-8'))
+    return hash_obj.hexdigest()
+
+def save_to_cache(cache_key: str, data: Dict[str, Any]) -> None:
+    """
+    Save data to cache file
+    
+    Args:
+        cache_key: Cache key
+        data: Data to be cached
+    """
+    cache_path = os.path.join(CACHE_DIR, f"{cache_key}.json")
+    
+    with open(cache_path, 'w', encoding='utf-8') as f:
+        json.dump(data, f, ensure_ascii=False, indent=2)
+
+def load_from_cache(cache_key: str) -> Optional[Dict[str, Any]]:
+    """
+    Load data from cache
+    
+    Args:
+        cache_key: Cache key
+        
+    Returns:
+        Cached data, or None if it doesn't exist
+    """
+    cache_path = os.path.join(CACHE_DIR, f"{cache_key}.json")
+    
+    if not os.path.exists(cache_path):
+        return None
+    
+    try:
+        with open(cache_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        # Return None if file is corrupted or cannot be read
+        return None
+
+def cached_llm_call(prompt_type: str, params: Dict[str, Any], call_function) -> Dict[str, Any]:
+    """
+    Cache decorator for LLM calls
+    
+    Args:
+        prompt_type: Prompt type
+        params: Prompt parameters
+        call_function: Actual function to call LLM
+        
+    Returns:
+        LLM response or cached response
+    """
+    # Generate cache key
+    cache_key = generate_cache_key(prompt_type, params)
+    
+    # Try to load from cache
+    cached_result = load_from_cache(cache_key)
+    if cached_result:
+        print(f"[Cache] Using cached response: {prompt_type}")
+        return cached_result
+    
+    # If not cached, call LLM
+    result = call_function(params)
+    
+    # Save to cache
+    save_to_cache(cache_key, result)
+    
+    return result
+
+def get_from_cache(cache_key: str) -> Optional[str]:
+    """
+    Get data directly from cache
+    
+    Args:
+        cache_key: Cache key (can be a string)
+        
+    Returns:
+        Cached data, or None if it doesn't exist
+    """
+    if not CACHE_ENABLED:
+        return None
+        
+    # Hash the cache key
+    hash_obj = hashlib.md5(cache_key.encode('utf-8'))
+    hashed_key = hash_obj.hexdigest()
+    
+    cache_path = os.path.join(CACHE_DIR, f"{hashed_key}.json")
+    
+    if not os.path.exists(cache_path):
+        return None
+    
+    try:
+        with open(cache_path, 'r', encoding='utf-8') as f:
+            if DEBUG_MODE:
+                print(f"Loading from cache: {cache_key[:30]}...")
+            return f.read()
+    except (IOError):
+        # Return None if file cannot be read
+        return None
+
+def save_to_cache(cache_key: str, data: str) -> None:
+    """
+    Save data to cache file
+    
+    Args:
+        cache_key: Cache key (can be a string)
+        data: Data string to cache
+    """
+    if not CACHE_ENABLED:
+        return
+        
+    # Hash the cache key
+    hash_obj = hashlib.md5(cache_key.encode('utf-8'))
+    hashed_key = hash_obj.hexdigest()
+    
+    cache_path = os.path.join(CACHE_DIR, f"{hashed_key}.json")
+    
+    with open(cache_path, 'w', encoding='utf-8') as f:
+        f.write(data)
+        if DEBUG_MODE:
+            print(f"Data cached: {cache_key[:30]}...") 

concept_handler.js

@@ -0,0 +1,191 @@
+// 处理概念卡片点击事件
+function handleConceptClick(conceptId) {
+    // 将点击的概念ID传递给Gradio
+    if (typeof gradioApp !== 'undefined') {
+        const app = gradioApp();
+        const hiddenInput = app.querySelector('#concept-selection');
+        if (hiddenInput) {
+            hiddenInput.value = conceptId;
+            // 触发change事件
+            const event = new Event('change');
+            hiddenInput.dispatchEvent(event);
+        }
+    }
+}
+
+// 添加点击事件监听器到所有概念卡片
+function addConceptCardListeners() {
+    const conceptCards = document.querySelectorAll('.concept-card');
+    conceptCards.forEach(card => {
+        card.addEventListener('click', function() {
+            const conceptId = this.getAttribute('data-concept-id');
+            if (conceptId) {
+                handleConceptClick(conceptId);
+                // 添加视觉反馈
+                highlightSelectedCard(this);
+            }
+        });
+    });
+}
+
+// 高亮选中的卡片
+function highlightSelectedCard(selectedCard) {
+    // 移除所有卡片的高亮
+    document.querySelectorAll('.concept-card').forEach(card => {
+        card.classList.remove('selected-card');
+    });
+    // 添加高亮到选中的卡片
+    selectedCard.classList.add('selected-card');
+}
+
+// 在知识图谱节点上添加悬停效果
+function addGraphNodeHoverEffects() {
+    const nodes = document.querySelectorAll('#concept-graph svg .node');
+    nodes.forEach(node => {
+        node.addEventListener('mouseenter', function() {
+            this.classList.add('node-hover');
+        });
+        node.addEventListener('mouseleave', function() {
+            this.classList.remove('node-hover');
+        });
+    });
+}
+
+// 增强图像显示
+function enhanceImageDisplay() {
+    const graphContainer = document.querySelector('#concept-graph');
+    if (graphContainer) {
+        const img = graphContainer.querySelector('img');
+        if (img) {
+            // 确保图像加载完成后应用样式
+            img.onload = function() {
+                this.style.maxWidth = '100%';
+                this.style.height = 'auto';
+                this.style.borderRadius = '8px';
+                this.style.boxShadow = '0 4px 8px rgba(0,0,0,0.1)';
+            };
+        }
+    }
+}
+
+// 在DOM加载完成后初始化
+document.addEventListener('DOMContentLoaded', function() {
+    // 知识图谱交互
+    const conceptGraph = document.querySelector('#concept-graph');
+    if (conceptGraph) {
+        const img = conceptGraph.querySelector('img');
+        if (img) {
+            enhanceImageDisplay();
+        }
+        
+        const nodes = conceptGraph.querySelectorAll('g.node');
+        nodes.forEach(node => {
+            node.style.cursor = 'pointer';
+            node.addEventListener('click', function() {
+                const conceptId = this.getAttribute('data-concept-id');
+                if (conceptId && conceptId !== 'main') {
+                    handleConceptClick(conceptId);
+                }
+            });
+        });
+        // 添加悬停效果
+        addGraphNodeHoverEffects();
+    }
+    
+    // 概念卡片交互
+    addConceptCardListeners();
+    
+    // 添加CSS样式
+    addCustomStyles();
+});
+
+// 添加自定义样式
+function addCustomStyles() {
+    const style = document.createElement('style');
+    style.textContent = `
+        /* 通用样式设置，支持中文 */
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Microsoft YaHei", "WenQuanYi Micro Hei", sans-serif;
+        }
+        
+        /* 概念卡片样式 */
+        .concept-card {
+            transition: all 0.3s ease;
+            border: 1px solid #ddd;
+            border-radius: 8px;
+            padding: 12px;
+            margin-bottom: 10px;
+            cursor: pointer;
+        }
+        .concept-card:hover {
+            box-shadow: 0 2px 12px rgba(0,0,0,0.15);
+            transform: translateY(-2px);
+        }
+        .selected-card {
+            border-color: #2196F3;
+            background-color: rgba(33, 150, 243, 0.05);
+            box-shadow: 0 0 0 2px rgba(33, 150, 243, 0.3);
+        }
+        .concept-title {
+            font-weight: bold;
+            margin-bottom: 5px;
+        }
+        .concept-desc {
+            font-size: 0.9em;
+            color: #555;
+        }
+        
+        /* 图表节点样式 */
+        .node-hover {
+            opacity: 0.8;
+            transform: scale(1.05);
+        }
+        
+        /* 知识图谱容器样式 */
+        #concept-graph img {
+            max-width: 100%;
+            height: auto;
+            border-radius: 8px;
+            box-shadow: 0 4px 8px rgba(0,0,0,0.1);
+        }
+    `;
+    document.head.appendChild(style);
+}
+
+// Gradio元素变化时重新添加监听器
+// 这是必要的，因为Gradio可能会动态替换DOM元素
+const observer = new MutationObserver(function(mutations) {
+    mutations.forEach(function(mutation) {
+        if (mutation.addedNodes && mutation.addedNodes.length > 0) {
+            // 检查是否有新的概念卡片添加
+            for (let i = 0; i < mutation.addedNodes.length; i++) {
+                const node = mutation.addedNodes[i];
+                if (node.classList && node.classList.contains('concept-card')) {
+                    addConceptCardListeners();
+                    break;
+                }
+            }
+            
+            // 检查是否有新的知识图谱添加
+            const conceptGraph = document.querySelector('#concept-graph');
+            if (conceptGraph) {
+                addGraphNodeHoverEffects();
+                enhanceImageDisplay();
+            }
+        }
+    });
+});
+
+// 开始观察DOM变化
+window.addEventListener('load', function() {
+    const targetNode = document.getElementById('concept-cards');
+    if (targetNode) {
+        observer.observe(targetNode, { childList: true, subtree: true });
+    }
+    
+    // 也观察知识图谱容器
+    const graphContainer = document.getElementById('concept-graph');
+    if (graphContainer) {
+        observer.observe(graphContainer, { childList: true, subtree: true });
+    }
+}); 

concept_handler.py

@@ -0,0 +1,121 @@
+"""
+Concept Handler Module - Contains mock data for fallback when API calls fail
+"""
+
+# Mock concept decomposition result
+MOCK_DECOMPOSITION_RESULT = {
+    "main_concept": "Equation Solving",
+    "sub_concepts": [
+        {
+            "id": "concept_1",
+            "name": "Equality Properties",
+            "description": "Performing the same add, subtract, multiply, or divide operations on both sides of an equation maintains the equality"
+        },
+        {
+            "id": "concept_2",
+            "name": "Transposition",
+            "description": "Moving terms from one side of an equation to the other while changing their signs"
+        },
+        {
+            "id": "concept_3",
+            "name": "Combining Like Terms",
+            "description": "Combining similar terms in the equation"
+        },
+        {
+            "id": "concept_4",
+            "name": "Solution Verification",
+            "description": "Substituting the solution back into the original equation to verify that the equality holds"
+        },
+        {
+            "id": "concept_5",
+            "name": "Fractional Equations",
+            "description": "Equations containing fractions, usually requiring finding a common denominator"
+        },
+        {
+            "id": "concept_6",
+            "name": "Algebraic Expression",
+            "description": "Expression formed by numbers and letters through a finite number of arithmetic operations"
+        }
+    ],
+    "relationships": [
+        {
+            "source": "concept_1",
+            "target": "concept_2",
+            "type": "prerequisite"
+        },
+        {
+            "source": "concept_2",
+            "target": "concept_3",
+            "type": "related"
+        },
+        {
+            "source": "concept_3",
+            "target": "concept_4",
+            "type": "prerequisite"
+        },
+        {
+            "source": "concept_1",
+            "target": "concept_5",
+            "type": "related"
+        },
+        {
+            "source": "concept_6",
+            "target": "concept_3",
+            "type": "prerequisite"
+        }
+    ]
+}
+
+# Mock concept explanation result
+MOCK_EXPLANATION_RESULT = {
+    "explanation": "Equality properties are fundamental principles in mathematics, stating that when the same mathematical operations (addition, subtraction, multiplication, division) are performed on both sides of an equation, the equality relationship is maintained. This is the basic principle for solving equations. For example, in the equation x+3=5, subtracting 3 from both sides gives x=2, with the equality still holding.",
+    "examples": [
+        {
+            "problem": "Solve the equation: 2x + 3 = 7",
+            "solution": "2x + 3 = 7\nSubtract 3: 2x + 3 - 3 = 7 - 3\nSimplify: 2x = 4\nDivide both sides by 2: 2x ÷ 2 = 4 ÷ 2\nResult: x = 2",
+            "difficulty": "Easy"
+        },
+        {
+            "problem": "Solve the equation: 3x - 4 = 2x + 5",
+            "solution": "3x - 4 = 2x + 5\nTranspose: 3x - 2x = 5 + 4\nCombine like terms: x = 9\nVerify: 3(9) - 4 = 2(9) + 5\n        27 - 4 = 18 + 5\n        23 = 23 ✓",
+            "difficulty": "Medium"
+        }
+    ],
+    "resources": [
+        {
+            "type": "Video",
+            "title": "Equality Properties and Equation Basics",
+            "description": "Detailed explanation of equality properties and their applications in equation solving",
+            "link": "https://example.com/equality-properties"
+        },
+        {
+            "type": "Article",
+            "title": "Understanding Equality Properties",
+            "description": "Understanding the concept of equality properties through illustrations and examples",
+            "link": "https://example.com/understanding-equality"
+        },
+        {
+            "type": "Interactive Tool",
+            "title": "Equation Balance Trainer",
+            "description": "Interactive tool to help understand the concept of balancing both sides of an equation",
+            "link": "https://example.com/balance-equations"
+        }
+    ],
+    "practice_questions": [
+        {
+            "question": "Solve the equation: 5x - 2 = 13",
+            "answer": "x = 3",
+            "difficulty": "Easy"
+        },
+        {
+            "question": "Solve the equation: 4(x - 1) = 2(x + 5)",
+            "answer": "x = 7",
+            "difficulty": "Medium"
+        },
+        {
+            "question": "Solve the equation: 2x/3 + 1 = 5/6",
+            "answer": "x = -1/4",
+            "difficulty": "Hard"
+        }
+    ]
+} 

concept_interaction.js

@@ -0,0 +1,142 @@
+// concept_interaction.js - 处理概念卡片的交互
+
+// 页面加载完成后初始化交互
+document.addEventListener('DOMContentLoaded', function() {
+    console.log('概念交互模块已加载');
+    setupConceptCardInteractions();
+    setupImageEnhancements();
+});
+
+// 设置概念卡片交互
+function setupConceptCardInteractions() {
+    // 使用事件委托处理所有卡片点击
+    document.body.addEventListener('click', function(event) {
+        const card = event.target.closest('.concept-card');
+        if (!card) return;
+        
+        const conceptId = card.getAttribute('data-concept-id');
+        if (!conceptId) {
+            console.error('卡片没有设置 data-concept-id 属性');
+            return;
+        }
+        
+        console.log(`点击了概念卡片: ${conceptId}`);
+        
+        // 显示加载动画
+        showLoadingInDetailPanel();
+        
+        // 更新选中状态
+        updateSelectedCard(card);
+        
+        // 触发 Gradio 事件
+        triggerConceptSelection(conceptId);
+    });
+}
+
+// 在详情面板显示加载动画
+function showLoadingInDetailPanel() {
+    const detailContainer = document.querySelector('.concept-detail-box');
+    if (detailContainer) {
+        detailContainer.innerHTML = `
+            <div class="loading">
+                <div class="loading-spinner"></div>
+                <div class="loading-text">正在生成概念详细解释...</div>
+            </div>
+        `;
+    }
+}
+
+// 更新选中的卡片样式
+function updateSelectedCard(selectedCard) {
+    document.querySelectorAll('.concept-card').forEach(card => {
+        card.classList.remove('selected-card');
+    });
+    selectedCard.classList.add('selected-card');
+}
+
+// 触发 Gradio 输入事件
+function triggerConceptSelection(conceptId) {
+    const conceptSelection = document.getElementById('concept-selection');
+    if (conceptSelection) {
+        conceptSelection.value = conceptId;
+        // 使用 input 事件，更可靠地触发 Gradio
+        conceptSelection.dispatchEvent(new Event('input', { bubbles: true }));
+        console.log(`已触发概念选择事件: ${conceptId}`);
+    } else {
+        console.error('找不到概念选择输入框 (concept-selection)');
+    }
+}
+
+// 增强图像显示
+function setupImageEnhancements() {
+    const graphContainer = document.getElementById('concept-graph');
+    if (!graphContainer) return;
+    
+    // 监视节点变化
+    const observer = new MutationObserver(function(mutations) {
+        mutations.forEach(function(mutation) {
+            if (mutation.type === 'childList') {
+                const img = graphContainer.querySelector('img');
+                if (img) {
+                    enhanceImage(img);
+                }
+            }
+        });
+    });
+    
+    observer.observe(graphContainer, { childList: true, subtree: true });
+}
+
+// 增强图像显示效果
+function enhanceImage(img) {
+    img.style.maxWidth = '100%';
+    img.style.height = 'auto';
+    img.style.borderRadius = '8px';
+    img.style.boxShadow = '0 4px 8px rgba(0,0,0,0.1)';
+    img.style.transition = 'transform 0.3s ease, box-shadow 0.3s ease';
+    
+    // 添加悬停效果
+    img.onmouseover = function() {
+        this.style.transform = 'scale(1.01)';
+        this.style.boxShadow = '0 6px 12px rgba(0,0,0,0.15)';
+    };
+    img.onmouseout = function() {
+        this.style.transform = 'scale(1)';
+        this.style.boxShadow = '0 4px 8px rgba(0,0,0,0.1)';
+    };
+}
+
+// 诊断功能：检查所有概念卡片ID
+function checkAllConceptCards() {
+    const cards = document.querySelectorAll('.concept-card');
+    console.log(`发现 ${cards.length} 个概念卡片`);
+    
+    const idMap = {};
+    cards.forEach((card, index) => {
+        const id = card.getAttribute('data-concept-id');
+        console.log(`卡片 #${index + 1}: ID=${id}`);
+        if (id) {
+            idMap[id] = (idMap[id] || 0) + 1;
+        }
+    });
+    
+    // 检查ID是否有重复
+    const duplicates = Object.entries(idMap).filter(([id, count]) => count > 1);
+    if (duplicates.length > 0) {
+        console.error('发现重复的概念ID:', duplicates);
+    }
+    
+    return {
+        totalCards: cards.length,
+        cardsWithIds: Object.keys(idMap).length,
+        duplicateIds: duplicates.map(([id]) => id)
+    };
+}
+
+// 提供全局诊断接口
+window.diagnoseConcepts = checkAllConceptCards;
+
+// 添加调试和错误日志
+window.addEventListener('error', function(e) {
+    console.error('🔴 JavaScript 错误:', e.message, 'at', e.filename, 'line', e.lineno);
+}); 

config.py

@@ -0,0 +1,15 @@
+import os
+"""
+Configuration settings for the Educational LLM Application
+"""
+# OpenAI API settings
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") # Or replace with your actual API key
+
+OPENAI_MODEL = "gpt-4o"  # Model name
+OPENAI_TIMEOUT = 30  # Timeout in seconds
+OPENAI_MAX_RETRIES = 3  # Maximum number of retries
+
+# Application settings
+DEBUG_MODE = True  # Enable debug output
+USE_FALLBACK_DATA = True  # Set to True to enable fallback to mock data when API calls fail
+CACHE_ENABLED = False  # Disable caching to always get fresh responses 

few_shots_examples.py

@@ -0,0 +1,212 @@
+## Stores all the few-shot examples
+
+# Few-shot examples for concept decomposition
+CONCEPT_DECOMPOSITION_EXAMPLES_1= {
+  "main_concept": "Algebra",
+  "Explanation": "Algebra is a branch of mathematics that uses symbols and letters to represent numbers and their relationships. It helps solve equations and understand patterns.",
+  "sub_concepts": [
+    {
+      "id": "1.1",
+      "name": "Functions",
+      "description": "Functions show how one quantity depends on another and are used to model relationships.",
+      "difficulty": "basic"
+    },
+    {
+      "id": "1.2",
+      "name": "The Domain and Range of a Function",
+      "description": "Domain is the set of input values, and range is the set of output values for a function.",
+      "difficulty": "basic"
+    },
+    {
+      "id": "1.3",
+      "name": "Intervals and Interval Notation",
+      "description": "A way to write ranges of values between two endpoints.",
+      "difficulty": "basic"
+    },
+    {
+      "id": "1.4",
+      "name": "Even and Odd Functions",
+      "description": "Even functions are symmetrical about the y-axis; odd functions are symmetrical about the origin.",
+      "difficulty": "intermediate"
+    },
+    {
+      "id": "1.5",
+      "name": "Function Graph Transformations: Vertical and Horizontal Shifts",
+      "description": "Moves the graph of a function up, down, left, or right.",
+      "difficulty": "intermediate"
+    },
+    {
+      "id": "1.6",
+      "name": "Function Graph Transformations: Stretching, Reflecting, and Compressing",
+      "description": "Changes the shape of a graph by stretching, flipping, or squeezing it.",
+      "difficulty": "intermediate"
+    },
+    {
+      "id": "1.7",
+      "name": "Function Graphs: Combined Transformations",
+      "description": "Applies multiple changes to a function’s graph to show complex transformations.",
+      "difficulty": "advanced"
+    },
+    {
+      "id": "1.8",
+      "name": "Arithmetic Operations on Functions",
+      "description": "Combines functions by adding, subtracting, multiplying, or dividing them.",
+      "difficulty": "intermediate"
+    },
+    {
+      "id": "1.9",
+      "name": "Composition of Functions",
+      "description": "Applies one function to the result of another to build new functions.",
+      "difficulty": "advanced"
+    },
+    {
+      "id": "1.10",
+      "name": "One-to-One Functions",
+      "description": "A function where each input has a unique output, important for finding inverses.",
+      "difficulty": "advanced"
+    },
+    {
+      "id": "1.11",
+      "name": "Linear, Quadratic, and Cubic Function Models",
+      "description": "Basic function types that model different patterns of change.",
+      "difficulty": "basic"
+    },
+    {
+      "id": "1.12",
+      "name": "Exponential Models",
+      "description": "Functions that model rapid growth or decay, used in real-life applications.",
+      "difficulty": "intermediate"
+    }
+  ],
+  "relationships": [
+    {
+      "source": "1.1",
+      "target": "1.2",
+      "type": "prerequisite",
+      "explanation": "Understanding functions is necessary to define their domain and range."
+    },
+    {
+      "source": "1.2",
+      "target": "1.3",
+      "type": "related",
+      "explanation": "Interval notation is commonly used when expressing domain and range."
+    },
+    {
+      "source": "1.1",
+      "target": "1.4",
+      "type": "prerequisite",
+      "explanation": "You need to understand basic function behavior before classifying them as even or odd."
+    },
+    {
+      "source": "1.1",
+      "target": "1.5",
+      "type": "prerequisite",
+      "explanation": "Understanding functions is key to learning how their graphs shift."
+    },
+    {
+      "source": "1.5",
+      "target": "1.6",
+      "type": "prerequisite",
+      "explanation": "Once shifts are understood, more complex transformations like stretching or reflecting can be learned."
+    },
+    {
+      "source": "1.6",
+      "target": "1.7",
+      "type": "prerequisite",
+      "explanation": "Understanding individual transformations helps in learning combined transformations."
+    },
+    {
+      "source": "1.1",
+      "target": "1.8",
+      "type": "prerequisite",
+      "explanation": "Understanding functions is necessary before performing operations on them."
+    },
+    {
+      "source": "1.8",
+      "target": "1.9",
+      "type": "prerequisite",
+      "explanation": "You need to be comfortable with function operations before learning function composition."
+    },
+    {
+      "source": "1.9",
+      "target": "1.10",
+      "type": "prerequisite",
+      "explanation": "Understanding composition is helpful when studying one-to-one functions and their inverses."
+    },
+    {
+      "source": "1.1",
+      "target": "1.11",
+      "type": "related",
+      "explanation": "Function models are real-world applications of the basic function concept."
+    },
+    {
+      "source": "1.11",
+      "target": "1.12",
+      "type": "prerequisite",
+      "explanation": "Linear, quadratic, and cubic models are usually taught before exponential models."
+    }
+  ]
+}
+
+CONCEPT_DECOMPOSITION_EXAMPLES_2 = {
+  "main_concept": "Normal Distribution",
+  "Explanation": "A normal distribution is a symmetric, bell-shaped curve where the mean represents the center and the variance measures how spread out the data is. Most data falls close to the mean, especially within a few standard deviations.",
+  "sub_concepts": [
+    {
+      "id": "1.1",
+      "name": "Mean of a Normal Distribution",
+      "description": "The average value of the data and the center point of the bell curve.",
+      "difficulty": "basic"
+    },
+    {
+      "id": "1.2",
+      "name": "Variance of a Normal Distribution",
+      "description": "A measure of how much the data spreads out from the mean.",
+      "difficulty": "intermediate"
+    },
+    {
+      "id": "1.3",
+      "name": "Standard Deviation",
+      "description": "The square root of variance; it shows the average distance of data from the mean.",
+      "difficulty": "intermediate"
+    },
+    {
+      "id": "1.4",
+      "name": "Properties of the Normal Distribution",
+      "description": "The distribution is symmetric with the mean, median, and mode all equal, forming a bell curve.",
+      "difficulty": "basic"
+    },
+    {
+      "id": "1.5",
+      "name": "Empirical Rule (68-95-99.7 Rule)",
+      "description": "Describes how data is spread in a normal distribution using standard deviations.",
+      "difficulty": "intermediate"
+    }
+  ],
+  "relationships": [
+    {
+      "source": "1.1",
+      "target": "1.4",
+      "type": "prerequisite",
+      "explanation": "Understanding the mean is necessary to grasp the symmetry and central tendency of the normal distribution."
+    },
+    {
+      "source": "1.2",
+      "target": "1.3",
+      "type": "prerequisite",
+      "explanation": "Standard deviation is derived from the variance, so variance must be understood first."
+    },
+    {
+      "source": "1.3",
+      "target": "1.5",
+      "type": "prerequisite",
+      "explanation": "The empirical rule is based on standard deviations, so understanding standard deviation is essential."
+    },
+    {
+      "source": "1.4",
+      "target": "1.5",
+      "type": "related",
+      "explanation": "The empirical rule is one of the defining properties of a normal distribution."
+    }
+  ]
+}

llm_chain.py

@@ -0,0 +1,199 @@
+"""
+LLM Chain implementation using Langchain for educational concept analysis
+"""
+
+from typing import Dict, Any, List
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate
+from langchain.output_parsers import PydanticOutputParser
+from langchain.chains import LLMChain
+from pydantic import BaseModel, Field
+from config import OPENAI_API_KEY, OPENAI_MODEL
+
+# Define Pydantic models for structured output
+class Concept(BaseModel):
+    """Model for a single concept"""
+    id: str = Field(description="Unique identifier for the concept")
+    name: str = Field(description="Name of the concept")
+    description: str = Field(description="Brief description of the concept")
+    difficulty: str = Field(description="Difficulty level: basic, intermediate, or advanced")
+
+class Relationship(BaseModel):
+    """Model for relationship between concepts"""
+    source: str = Field(description="Source concept ID")
+    target: str = Field(description="Target concept ID")
+    type: str = Field(description="Type of relationship: prerequisite or related")
+    explanation: str = Field(description="Explanation of why this relationship exists")
+
+class ConceptMap(BaseModel):
+    """Model for complete concept map"""
+    main_concept: str = Field(description="Main concept being analyzed")
+    sub_concepts: List[Concept] = Field(description="List of sub-concepts")
+    relationships: List[Relationship] = Field(description="List of relationships between concepts")
+
+class Example(BaseModel):
+    """Model for concept examples"""
+    problem: str = Field(description="Example problem")
+    solution: str = Field(description="Step-by-step solution")
+    difficulty: str = Field(description="Difficulty level: Easy, Medium, or Hard")
+
+class Resource(BaseModel):
+    """Model for learning resources"""
+    type: str = Field(description="Type of resource (Video/Article/Interactive/Book)")
+    title: str = Field(description="Resource title")
+    description: str = Field(description="Resource description")
+    link: str = Field(description="Optional resource link")
+
+class ConceptExplanation(BaseModel):
+    """Model for detailed concept explanation"""
+    explanation: str = Field(description="Detailed concept explanation")
+    examples: List[Example] = Field(description="List of example problems and solutions")
+    resources: List[Resource] = Field(description="List of learning resources")
+    practice_questions: List[Example] = Field(description="List of practice questions")
+
+class EducationalLLMChain:
+    """
+    Chain for processing educational concepts using LLM
+    """
+    def __init__(self):
+        """Initialize the LLM and parsers"""
+        self.llm = ChatOpenAI(
+            model=OPENAI_MODEL,
+            temperature=0.1,
+            openai_api_key=OPENAI_API_KEY
+        )
+        
+        # Initialize output parsers
+        self.concept_parser = PydanticOutputParser(pydantic_object=ConceptMap)
+        self.explanation_parser = PydanticOutputParser(pydantic_object=ConceptExplanation)
+        
+        # Create decomposition chain
+        self.decomposition_chain = self._create_decomposition_chain()
+        
+        # Create explanation chain
+        self.explanation_chain = self._create_explanation_chain()
+
+    def _create_decomposition_chain(self) -> LLMChain:
+        """
+        Create chain for concept decomposition
+        
+        Returns:
+            LLMChain for decomposing concepts
+        """
+        template = """You are an expert educational AI tutor.
+        
+        Analyze this question for a {grade} level student studying {subject}.
+        
+        Question: {question}
+        
+        Student Background:
+        - Grade Level: {grade}
+        - Subject: {subject}
+        - Learning Needs: {learning_needs}
+        
+        Break down the concepts needed to understand this question into a knowledge graph.
+        Consider the student's grade level and background knowledge.
+        
+        {format_instructions}
+        """
+        
+        prompt = ChatPromptTemplate.from_template(
+            template=template,
+            partial_variables={
+                "format_instructions": self.concept_parser.get_format_instructions()
+            }
+        )
+        
+        return LLMChain(llm=self.llm, prompt=prompt)
+
+    def _create_explanation_chain(self) -> LLMChain:
+        """
+        Create chain for concept explanation
+        
+        Returns:
+            LLMChain for explaining concepts
+        """
+        template = """You are an expert educational tutor.
+        
+        Explain this concept for a {grade} level student studying {subject}:
+        
+        Concept: {concept_name}
+        Description: {concept_description}
+        
+        Student Background:
+        - Grade Level: {grade}
+        - Subject: {subject}
+        - Learning Needs: {learning_needs}
+        
+        Provide a detailed explanation, examples, resources, and practice questions.
+        
+        {format_instructions}
+        """
+        
+        prompt = ChatPromptTemplate.from_template(
+            template=template,
+            partial_variables={
+                "format_instructions": self.explanation_parser.get_format_instructions()
+            }
+        )
+        
+        return LLMChain(llm=self.llm, prompt=prompt)
+
+    async def decompose_concepts(
+        self,
+        question: str,
+        grade: str,
+        subject: str,
+        learning_needs: str
+    ) -> ConceptMap:
+        """
+        Decompose a question into concepts
+        
+        Args:
+            question: User's question
+            grade: Educational grade level
+            subject: Subject area
+            learning_needs: Learning needs/goals
+            
+        Returns:
+            Structured concept map
+        """
+        response = await self.decomposition_chain.arun({
+            "question": question,
+            "grade": grade,
+            "subject": subject,
+            "learning_needs": learning_needs
+        })
+        
+        return self.concept_parser.parse(response)
+
+    async def explain_concept(
+        self,
+        concept_name: str,
+        concept_description: str,
+        grade: str,
+        subject: str,
+        learning_needs: str
+    ) -> ConceptExplanation:
+        """
+        Generate detailed concept explanation
+        
+        Args:
+            concept_name: Name of concept to explain
+            concept_description: Brief concept description
+            grade: Educational grade level
+            subject: Subject area
+            learning_needs: Learning needs/goals
+            
+        Returns:
+            Structured concept explanation
+        """
+        response = await self.explanation_chain.arun({
+            "concept_name": concept_name,
+            "concept_description": concept_description,
+            "grade": grade,
+            "subject": subject,
+            "learning_needs": learning_needs
+        })
+        
+        return self.explanation_parser.parse(response) 

llm_utils.py

@@ -0,0 +1,195 @@
+"""
+Utility functions for LLM-related operations
+"""
+import json
+import os
+import time
+from typing import Dict, List, Any, Optional
+
+# Import from OpenAI newer SDK
+from openai import OpenAI
+
+# Import local modules
+from cache_utils import cached_llm_call, get_from_cache, save_to_cache
+from config import OPENAI_API_KEY, OPENAI_MODEL, OPENAI_TIMEOUT, OPENAI_MAX_RETRIES, USE_FALLBACK_DATA, DEBUG_MODE
+
+def call_llm(system_prompt: str, user_prompt: str, mock_data: Optional[Dict] = None) -> Dict[str, Any]:
+    """
+    Call LLM with improved error handling and response validation
+    
+    Args:
+        system_prompt: System role prompt
+        user_prompt: User input prompt
+        mock_data: Mock data for fallback
+        
+    Returns:
+        Parsed JSON response from LLM
+        
+    Raises:
+        ValueError: If response format is invalid
+        Exception: For other API call failures
+    """
+    cache_key = f"{system_prompt}_{user_prompt}"
+    cached_response = get_from_cache(cache_key)
+    
+    if cached_response:
+        if DEBUG_MODE:
+            print("Using cached response")
+        return json.loads(cached_response)
+    
+    try:
+        client = OpenAI(api_key=OPENAI_API_KEY)
+        
+        # Make API call with temperature=0.1 for more consistent outputs
+        response = client.chat.completions.create(
+            model=OPENAI_MODEL,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.1,
+            response_format={"type": "json_object"}
+        )
+        
+        content = response.choices[0].message.content
+        
+        # Validate JSON response
+        try:
+            json_response = json.loads(content)
+            validate_response_format(json_response)
+            save_to_cache(cache_key, content)
+            return json_response
+            
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON response from LLM")
+            
+    except Exception as e:
+        if DEBUG_MODE:
+            print(f"LLM API call failed: {str(e)}")
+        if USE_FALLBACK_DATA and mock_data:
+            return mock_data
+        raise
+
+def validate_response_format(response: Dict[str, Any]) -> None:
+    """
+    Validate the format of LLM response
+    
+    Args:
+        response: Parsed JSON response
+        
+    Raises:
+        ValueError: If required fields are missing or invalid
+    """
+    required_fields = {
+        "decomposition": ["main_concept", "sub_concepts", "relationships"],
+        "explanation": ["explanation", "key_points", "examples", "practice", "resources"]
+    }
+    
+    # Determine response type and validate fields
+    if "main_concept" in response:
+        fields = required_fields["decomposition"]
+    elif "explanation" in response:
+        fields = required_fields["explanation"]
+    else:
+        raise ValueError("Unknown response format")
+        
+    for field in fields:
+        if field not in response:
+            raise ValueError(f"Missing required field: {field}")
+
+def _do_decompose_concepts(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute concept decomposition (internal function)
+    
+    Args:
+        params: Parameter dictionary containing user profile and question
+        
+    Returns:
+        Decomposed concept data
+    """
+    from prompts import generate_decomposition_prompt
+    
+    user_profile = params.get("user_profile", {})
+    question = params.get("question", "")
+    
+    system_prompt, user_prompt = generate_decomposition_prompt(
+        question,
+        user_profile.get("grade", "Not specified"),
+        user_profile.get("subject", "Not specified"),
+        user_profile.get("needs", "Not specified")
+    )
+    
+    from concept_handler import MOCK_DECOMPOSITION_RESULT
+    response = call_llm(system_prompt, user_prompt, MOCK_DECOMPOSITION_RESULT)
+    return response
+
+def decompose_concepts(user_profile: Dict[str, str], question: str) -> Dict[str, Any]:
+    """
+    Use LLM to break down user questions into multiple concepts, with caching
+    
+    Args:
+        user_profile: User profile information
+        question: User question
+        
+    Returns:
+        Dictionary containing main concept, sub-concepts, and relationships
+    """
+    params = {
+        "user_profile": user_profile,
+        "question": question
+    }
+    
+    return cached_llm_call("decompose", params, _do_decompose_concepts)
+
+def _do_get_concept_explanation(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute concept explanation (internal function)
+    
+    Args:
+        params: Parameter dictionary containing user profile and concept information
+        
+    Returns:
+        Concept explanation data
+    """
+    from prompts import generate_explanation_prompt
+    
+    user_profile = params.get("user_profile", {})
+    concept_id = params.get("concept_id", "")
+    concept_name = params.get("concept_name", "")
+    concept_description = params.get("concept_description", "")
+    
+    system_prompt, user_prompt = generate_explanation_prompt(
+        concept_name,
+        concept_description,
+        "", # Original question (not needed here)
+        user_profile.get("grade", "Not specified"),
+        user_profile.get("subject", "Not specified"),
+        user_profile.get("needs", "Not specified")
+    )
+    
+    from concept_handler import MOCK_EXPLANATION_RESULT
+    response = call_llm(system_prompt, user_prompt, MOCK_EXPLANATION_RESULT)
+    return response
+
+def get_concept_explanation(user_profile: Dict[str, str], concept_id: str, 
+                           concept_name: str, concept_description: str) -> Dict[str, Any]:
+    """
+    Get detailed explanation and learning resources for a specific concept, with caching
+    
+    Args:
+        user_profile: User profile information
+        concept_id: Concept ID
+        concept_name: Concept name
+        concept_description: Brief concept description
+        
+    Returns:
+        Dictionary containing explanation, examples, and resources
+    """
+    params = {
+        "user_profile": user_profile,
+        "concept_id": concept_id,
+        "concept_name": concept_name,
+        "concept_description": concept_description
+    }
+    
+    return cached_llm_call("explain", params, _do_get_concept_explanation) 

prompts.py

@@ -0,0 +1,241 @@
+"""
+Prompt Template Module - Stores functions for generating LLM prompts
+"""
+
+from typing import Tuple
+
+import few_shots_examples
+
+
+def generate_decomposition_prompt(question: str, grade: str, subject: str, learning_needs: str) -> Tuple[str, str]:
+    """
+    Generate prompts for concept decomposition based on user background
+    
+    Args:
+        question: User's question
+        grade: Educational grade level
+        subject: Subject area
+        learning_needs: Specific learning needs/goals
+        
+    Returns:
+        Tuple of (system_prompt, user_prompt)
+    """
+    system_prompt = """You are an expert educational AI tutor. Your task is to break down complex questions into fundamental concepts that are appropriate for the student's grade level and background knowledge.
+
+Please analyze the question and create a knowledge graph that shows:
+1. The main concept being asked about
+2. Essential sub-concepts needed to understand the main concept
+3. The relationships between these concepts (prerequisite or related)
+
+Consider the student's grade level and subject background when determining:
+- Which concepts to include
+- How detailed the explanations should be
+- The appropriate terminology to use
+- The complexity level of relationships
+
+Your response must be in the following JSON format:
+{
+  "main_concept": "Core concept name",
+  "Explanation": "Brief, grade-appropriate explanation of the main concept",
+  "sub_concepts": [
+    {
+      "id": "unique_id",
+      "name": "Concept name",
+      "description": "Brief, grade-appropriate description",
+      "difficulty": "basic|intermediate|advanced"
+    }
+  ],
+  "relationships": [
+    {
+      "source": "concept_id",
+      "target": "concept_id",
+      "type": "prerequisite|related",
+      "explanation": "Why this relationship exists"
+    }
+  ]
+}"""
+
+    user_prompt = f"""
+Break down the concepts needed to understand this question, considering:
+1. The student's current grade level and subject knowledge
+2. Any specific learning needs mentioned
+3. The logical progression of concepts needed
+4. Appropriate difficulty levels for each concept
+
+Please ensure all explanations and terminology are appropriate for a {grade} level student.
+
+
+Here is an example:
+Input: "What is Algebra"
+OUTPUT: {str(few_shots_examples.CONCEPT_DECOMPOSITION_EXAMPLES_1)}
+
+Input: "What is the relationship between the mean and variance of a normal distribution."
+OUTPUT: {str(few_shots_examples.CONCEPT_DECOMPOSITION_EXAMPLES_2)},
+
+Please analyze this question for a {grade} level student studying {subject}.
+
+Question: {question}
+
+Student Background:
+- Grade Level: {grade}
+- Subject: {subject}
+- Learning Needs: {learning_needs if learning_needs else 'Not specified'}
+
+"""
+
+    return system_prompt, user_prompt
+
+
+def generate_explanation_prompt(concept_name, concept_description, question, grade, subject, learning_needs):
+    """
+    Generate prompt for concept explanation
+    
+    Args:
+        concept_name: Concept name
+        concept_description: Concept description
+        question: Original question
+        grade: Grade level
+        subject: Subject
+        learning_needs: Learning needs
+        
+    Returns:
+        Tuple of system prompt and user prompt
+    """
+    system_prompt = """You are an AI assistant in the educational field, specializing in explaining academic concepts and providing constructive learning resources.
+Your task is to deeply explain the specified concept, providing examples, resources, and practice questions.
+Your answer must be in valid JSON format, including the following fields:
+{
+  "explanation": "Detailed concept explanation",
+  "examples": [
+    {
+      "problem": "Example problem",
+      "solution": "Step-by-step solution",
+      "difficulty": "Difficulty level (Easy/Medium/Hard)"
+    },
+    ...
+  ],
+  "resources": [
+    {
+      "type": "Resource type (Video/Article/Interactive/Book)",
+      "title": "Resource title",
+      "description": "Resource description",
+      "link": "Link (optional)"
+    },
+    ...
+  ],
+  "practice_questions": [
+    {
+      "question": "Practice question",
+      "answer": "Answer",
+      "difficulty": "Difficulty level (Easy/Medium/Hard)"
+    },
+    ...
+  ]
+}
+The explanation should be clear, comprehensive, and appropriate for a {grade} level {subject} student's language and difficulty level.
+Examples should include 1-3 items, ranging from simple to complex, with step-by-step solutions.
+Resources should be diverse, including videos, articles, interactive tools, etc.
+Practice questions should include 2-4 items of varying difficulty to help students solidify the concept."""
+
+    user_prompt = f"""Please explain the following concept in detail, considering the student's grade, subject background, and learning needs:
+
+Concept: {concept_name}
+Description: {concept_description}
+Original Question: {question}
+Grade: {grade}
+Subject: {subject}
+Learning Needs: {learning_needs if learning_needs else "Not specified"}
+
+Please provide a detailed explanation, relevant examples, learning resources, and practice questions, and return JSON in the specified format."""
+
+    return system_prompt, user_prompt
+
+
+# Prompt template for decomposing concepts
+CONCEPT_DECOMPOSITION_PROMPT = """
+Based on the user's question and profile information, please break down the question into multiple essential basic concepts, and output the relationships between these concepts in JSON format.
+
+User Profile:
+- Grade: {grade}
+- Subject: {subject}
+- Needs: {needs}
+
+User Question: {question}
+
+Please follow the format below for your response:
+```json
+{
+  "main_concept": "Main concept name",
+  "sub_concepts": [
+    {
+      "id": "concept_1",
+      "name": "Concept 1 name", 
+      "description": "Brief description of concept 1"
+    },
+    {
+      "id": "concept_2",
+      "name": "Concept 2 name",
+      "description": "Brief description of concept 2"
+    }
+    // More concepts...
+  ],
+  "relationships": [
+    {
+      "source": "concept_1",
+      "target": "concept_2",
+      "type": "prerequisite" // Can be "prerequisite" or "related"
+    }
+    // More relationships...
+  ]
+}
+```
+
+Please ensure the generated JSON is correctly formatted, each concept has a unique ID, and the relationships clearly express the dependencies between concepts.
+"""
+
+# Prompt template for generating concept explanations and learning resources
+CONCEPT_EXPLANATION_PROMPT = """
+Please generate detailed explanations, examples, and learning resource suggestions for the following concept based on the user's profile information.
+
+User Profile:
+- Grade: {grade}
+- Subject: {subject}
+- Needs: {needs}
+
+Selected Concept: {concept_name}
+Concept Description: {concept_description}
+
+Please provide your answer in the following format:
+```json
+{
+  "explanation": "Detailed explanation of the concept, appropriate for the user's grade level...",
+  "examples": [
+    {
+      "problem": "Example 1...",
+      "solution": "Solution process and answer...",
+      "difficulty": "Easy/Medium/Hard"
+    },
+    // More examples...
+  ],
+  "resources": [
+    {
+      "type": "Video/Book/Website",
+      "title": "Resource title",
+      "description": "Resource description",
+      "link": "Link (optional)"
+    },
+    // More resources...
+  ],
+  "practice_questions": [
+    {
+      "question": "Practice question 1...",
+      "answer": "Answer...",
+      "difficulty": "Easy/Medium/Hard"
+    },
+    // More practice questions...
+  ]
+}
+```
+
+Please ensure the content is appropriate for the user's grade level, the explanations are easy to understand, and provide valuable learning resources and examples.
+"""

requirements.txt

@@ -0,0 +1,7 @@
+gradio==5.23.1
+langchain==0.0.352
+matplotlib==3.7.3
+networkx==3.1
+openai==1.68.2
+pydantic==2.10.6
+langchain-core==0.1.1

run.bat

@@ -0,0 +1,27 @@
+@echo off
+REM Batch script to start the Educational LLM Application
+
+REM Check Python environment
+where python >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo Error: Python is required but not found. Please install Python.
+    exit /b 1
+)
+
+REM Check virtual environment
+if not exist venv (
+    echo Creating Python virtual environment...
+    python -m venv venv
+    call venv\Scripts\activate
+    echo Installing dependencies...
+    pip install -r requirements.txt
+) else (
+    call venv\Scripts\activate
+)
+
+REM Run application
+echo Starting Educational LLM Application...
+python app.py
+
+REM Deactivate virtual environment
+call deactivate 

run.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Script to start the Educational LLM Application
+
+# Color definitions
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Welcome message
+echo -e "${GREEN}=== Educational LLM Application Startup Script ===${NC}"
+echo -e "${YELLOW}Setting up environment...${NC}"
+
+# Check Python3 exists
+if ! command -v python3 &> /dev/null; then
+    echo "Error: Python3 not found. Please install Python3 first."
+    exit 1
+fi
+
+# Create virtual environment (if it doesn't exist)
+if [ ! -d "venv" ]; then
+    echo -e "${YELLOW}Creating virtual environment...${NC}"
+    python3 -m venv venv
+    if [ $? -ne 0 ]; then
+        echo "Error: Unable to create virtual environment. Please check your Python installation."
+        exit 1
+    fi
+fi
+
+# Activate virtual environment
+echo -e "${YELLOW}Activating virtual environment...${NC}"
+source venv/bin/activate
+if [ $? -ne 0 ]; then
+    echo "Error: Unable to activate virtual environment."
+    exit 1
+fi
+
+# Check requirements.txt and install dependencies
+echo -e "${YELLOW}Installing dependencies...${NC}"
+pip install -r requirements.txt
+if [ $? -ne 0 ]; then
+    echo "Error: Unable to install dependencies. Please check your network connection and requirements.txt file."
+    exit 1
+fi
+
+# Ensure cache directory exists
+echo -e "${YELLOW}Creating cache directory...${NC}"
+mkdir -p cache
+
+# Start application
+echo -e "${GREEN}Starting Educational LLM Application...${NC}"
+echo -e "${YELLOW}The application will open in your browser${NC}"
+python app.py
+
+# Exit virtual environment
+deactivate 

visualization.py

@@ -0,0 +1,212 @@
+"""
+Visualization Module - Generate concept knowledge graphs
+"""
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import matplotlib
+import io
+import base64
+import os
+from typing import Dict, Any, List
+
+# Ensure using Agg backend (no need for GUI)
+matplotlib.use('Agg')
+
+# Set up Chinese font support
+# Try to find suitable Chinese fonts
+font_found = False
+chinese_fonts = ['SimHei', 'Microsoft YaHei', 'WenQuanYi Micro Hei', 'AR PL UMing CN', 'STSong', 'NSimSun', 'FangSong', 'KaiTi']
+for font in chinese_fonts:
+    try:
+        matplotlib.font_manager.findfont(font)
+        matplotlib.rcParams['font.sans-serif'] = [font, 'DejaVu Sans', 'Arial Unicode MS', 'sans-serif']
+        print(f"Using Chinese font: {font}")
+        font_found = True
+        break
+    except:
+        continue
+
+if not font_found:
+    print("Warning: No suitable Chinese font found, using default font")
+    matplotlib.rcParams['font.sans-serif'] = ['DejaVu Sans', 'Arial Unicode MS', 'sans-serif']
+
+matplotlib.rcParams['axes.unicode_minus'] = False
+matplotlib.rcParams['font.size'] = 10
+
+def create_network_graph(concepts_data: Dict[str, Any]) -> str:
+    """
+    Create an enhanced network visualization of concept relationships
+    
+    Args:
+        concepts_data: Dictionary containing concept hierarchy and relationships
+        
+    Returns:
+        Base64 encoded PNG image as data URL
+    """
+    G = nx.DiGraph()
+    
+    # Clear any existing plots
+    plt.clf()
+    plt.close('all')
+    
+    # Increase figure size and DPI for better display
+    plt.figure(figsize=(14, 10), dpi=150, facecolor='white')
+    
+    # Add nodes with difficulty-based colors
+    difficulty_colors = {
+        'basic': '#90CAF9',      # Light blue
+        'intermediate': '#FFB74D', # Orange
+        'advanced': '#EF5350'     # Red
+    }
+    
+    # Only add subconcepts (skip main concept)
+    for concept in concepts_data.get("sub_concepts", []):
+        concept_id = concept.get("id")
+        concept_name = concept.get("name")
+        difficulty = concept.get("difficulty", "basic")
+        
+        if concept_id and concept_name:
+            G.add_node(
+                concept_id,
+                name=concept_name,
+                type="sub",
+                difficulty=difficulty,
+                color=difficulty_colors.get(difficulty, '#90CAF9')
+            )
+    
+    # Add relationships between subconcepts only
+    for relation in concepts_data.get("relationships", []):
+        source = relation.get("source")
+        target = relation.get("target")
+        rel_type = relation.get("type")
+        
+        # Skip relationships involving main concept
+        if (source and target and 
+            source in G.nodes and target in G.nodes):  # Only add edges between existing subconcepts
+            G.add_edge(
+                source,
+                target,
+                type=rel_type
+            )
+    
+    # Optimize layout parameters and increase node spacing
+    pos = nx.spring_layout(
+        G,
+        k=2.0,  # Increase node spacing
+        iterations=100,  # Increase iterations for better layout
+        seed=42  # Fixed random seed for consistent layout
+    )
+    
+    # Draw nodes with difficulty-based colors
+    node_colors = [G.nodes[node].get('color', '#90CAF9') for node in G.nodes()]
+    
+    # All nodes are now the same size since there's no main concept
+    node_sizes = [1500 for _ in G.nodes()]
+    
+    # Draw nodes
+    nx.draw_networkx_nodes(
+        G, pos,
+        node_color=node_colors,
+        node_size=node_sizes,
+        alpha=0.8
+    )
+    
+    # Draw edges with different styles for different relationship types
+    edges_prerequisite = [(u, v) for (u, v, d) in G.edges(data=True) if d.get('type') == 'prerequisite']
+    edges_related = [(u, v) for (u, v, d) in G.edges(data=True) if d.get('type') == 'related']
+    
+    # Draw edges with curves to avoid overlap
+    nx.draw_networkx_edges(
+        G, pos,
+        edgelist=edges_prerequisite,
+        edge_color='red',
+        width=2,
+        connectionstyle="arc3,rad=0.2",  # Add curve
+        arrowsize=20,
+        arrowstyle='->',
+        min_source_margin=30,
+        min_target_margin=30
+    )
+    nx.draw_networkx_edges(
+        G, pos,
+        edgelist=edges_related,
+        edge_color='blue',
+        style='dashed',
+        width=1.5,
+        connectionstyle="arc3,rad=-0.2",  # Add reverse curve
+        arrowsize=15,
+        arrowstyle='->',
+        min_source_margin=25,
+        min_target_margin=25
+    )
+    
+    # Optimize label display
+    labels = {
+        node: G.nodes[node].get('name', node)
+        for node in G.nodes()
+    }
+    
+    # Calculate label position offsets
+    label_pos = {
+        node: (coord[0], coord[1] + 0.08)  # Offset labels upward
+        for node, coord in pos.items()
+    }
+    
+    # Use larger font size and add text background
+    nx.draw_networkx_labels(
+        G,
+        label_pos,
+        labels,
+        font_size=12,  # Increase font size
+        font_weight='bold',
+        bbox={  # Add text background
+            'facecolor': 'white',
+            'edgecolor': '#E0E0E0',
+            'alpha': 0.9,
+            'pad': 6,
+            'boxstyle': 'round,pad=0.5'
+        }
+    )
+    
+    # Adjust legend position and size
+    legend_elements = [
+        plt.Line2D([0], [0], color='red', lw=2, label='Prerequisite'),
+        plt.Line2D([0], [0], color='blue', linestyle='--', lw=2, label='Related'),
+        plt.Line2D([0], [0], marker='o', color='w', label='Basic', markerfacecolor='#90CAF9', markersize=12),
+        plt.Line2D([0], [0], marker='o', color='w', label='Intermediate', markerfacecolor='#FFB74D', markersize=12),
+        plt.Line2D([0], [0], marker='o', color='w', label='Advanced', markerfacecolor='#EF5350', markersize=12)
+    ]
+    plt.legend(
+        handles=legend_elements,
+        loc='upper right',
+        bbox_to_anchor=(1.2, 1),
+        fontsize=10,
+        frameon=True,
+        facecolor='white',
+        edgecolor='none',
+        shadow=True
+    )
+    
+    # Add title showing the main concept without creating a node for it
+    main_concept = concepts_data.get("main_concept", "Concept Map")
+    plt.title(f"Concept Map: {main_concept}", pad=20, fontsize=14, fontweight='bold')
+    
+    # Increase graph margins
+    plt.margins(x=0.2, y=0.2)
+    plt.axis('off')
+    plt.tight_layout()
+    
+    # Add padding when saving the image
+    buf = io.BytesIO()
+    plt.savefig(
+        buf,
+        format='png',
+        bbox_inches='tight',
+        dpi=150,
+        pad_inches=0.5
+    )
+    plt.close('all')
+    buf.seek(0)
+    
+    return "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode('utf-8')